Translate

sexta-feira, 25 de janeiro de 2013

Introdução a Linguagem C


A linguagem C foi desenvolvida com o objetivo de facilitar e simplificar a vida dos programadores, uma vez que é uma linguagem possui uma mascara, ou seja, um simples comanda pode esconder uma sequência de comandos, já que ao ser compilado um programa em C, ele é traduzido para Assembly e depois linguagem Hexadecimal que é a essência da linguagem da maquina.

Normalmente a linguagem Assembly exige que o programador nova o valor de um bit para uma área de transferência e posteriormente para o destino final, ou seja, o programa é realizado bit a bit; o que torna o programa extenso e complicado de ser lido. Já a linguagem C é bem mais clara, é lógico que um programa depende do ponto de vista do programador, desta forma uma tarefa pode ser programada de várias formas.


Segue abaixo os comandos mais básicos da linguagem abordada:

if - Verifica uma condição.
else - Se não for a condição.

A=10;
B=5;
C= A + B;

if (C = = 15)  // faz a verificação
{
RB0_bit = 1;  // se a verificação for true, executa
}
else RB0_bit = 0;  // se a condição for false executa

Quando queremos uma comparação de forma condicional, podemos mesclar estes comandos, veja.

A=10;
B=5;
C= A + B;

if (C = = 15)  // faz a verificação
{
RB0_bit = 1;  // se a verificação for true, executa
}
else if (C < = 14)
{
RB1_bit = 1;  // se a condição for false executa
}

O comando else if pode ser repetido N vezes.

while - Cria um laço condicionado.
for - Cria um laço até que algum set point seja atingido
do ... while - executa uma determinada tarefa com um laço condicionado

while (true)  /* executa as verificações abaixo de forma continua e ininterrupta, pois a condição é verdadeira dentro do parentese  (true).*/
{
   A=10;
   B=5;
  C= A + B;

  if (C = = 15)  // faz a verificação
  {
   RB0_bit = 1;  // se a verificação for true, executa
   }
   else if (C < = 14)
  {
  RB1_bit = 1;  // se a condição for false executa
  }
}

Outra aplicação:

while (PORTA = = 0x04) /* Enquanto o valor do PORT A for 4 o laço e a verificação serão executadas ciclicamente.*/


{
   A=10;
   B=5;
  C= A + B;

  if (C = = 15)  // faz a verificação
  {
   RB0_bit = 1;  // se a verificação for true, executa
   }

}

Já para o comando do ... while, temos:

do             // faça a sequência de comandos abaixo enquanto a condição for verdadeira

{
   A=10;
   B=5;
  C= A + B;

  if (C = = 15)  // faz a verificação
  {
   RB0_bit = 1;  // se a verificação for true, executa
   }

while (PORTA = = 0x04 && PORTC = =  0x01)   /* condição a ser verificada constantemente, toda vez que a condição for true, o comando é executado*/

Em ambos os casos, que temos o comando while, podemos usar o comando break, ele serve parar a continuação dos comandos abaixo do fechamento das chaves que delimitam o comando while.


No caso do laço for temos varias condições para executar o laço, veja.

for ( a = 10; a > = 11; a - -)


Podemos ainda fazer um laço utilizando o comando goto, porem não é comum nos dias de hoje.

A = 0;
B = 15;
C = B + A;

ciclo:                      // os dois pontos define que é uma subrotina
A = A + 1;             // incrementa mais 1 na variável A
if (C < = 20)           // confere o valor da expressão
{
goto ciclo;               // redireciona
}
else RB1_bit = 1;    // executa caso false na verificação acima


Ainda temos um outro comando muito útil, conhecido como switch, que pode receber varias opções de execução. Segue abaixo:

PORTB = 0x00;

switch ( A)

case 10:             // verifica o valor de A caso este valor seja 10, executa os comandos até encontrar o break
PORTC = 0b10101010;
break

case 2:                 // verifica o valor de A caso este valor seja 2, executa os comandos até encontrar o break
PORTC = 0b01010101;
break

case 4:                 // verifica o valor de A caso este valor seja 4, executa os comandos até encontrar o break
PORTC = 0b00001111;
break

default:                 // caso nenhuma condição acima seja encontrada executa esta, porem não é obrigatória
A = PORTB + 1;
break



Para terminar, quero chamar a atenção para alguns comandos já utilizados, porem não explicado, é o caso do // e do /* ... */

Tudo que estiver após as barras //  será entendido como comentário, e não terá influência na programação, porem, apenas na linha em que for digitado.

Caso seja necessário fazer uma observação extensa, com várias linhas, podemos utilizar o /*, assim tudo que estiver entre esse símbolos será adotado como comentário. /* essa texto é um comentário*/

Abaixo tem a lista com alguns operadores:


+          Adição
Ÿ++        Incremento da variável indicada ( D++ é equivalente a D = D + 1)
-           Subtração
--         Decremento da variável indicada ( X-- é equivalente a X = X - 1)
*          Multi plicação
/           Divisão (parte inteira da divisão para variáveis inteiras)
%         Resto da divisão (se for divisão de inteiros)
^          Exponencial
<         Comparador lógico “menor que”
>         Comparador lógico “maior que”
<=       Comparador lógico “menor ou igual que”
>=       Comparador lógico “maior ou igual que”
= =      Comparador lógico “igual a” (*)
!=        Comparador lógico “diferente de”
&&     AND lógico ou relacional (todas as condições verdadeiras)
||         OR lógico ou relacional (uma das condições é verdadeira)
!         NOT lógico ou relacional (vê se a condição é TRUE ou FALSE)
&       AND binário (bit a bit nas variáveis)
|         OR binário (bit a bit nas variáveis)
~        NOT binário (inverte o estado de cada bit da variável)



Segue um exemplo de definição das portas no que diz respeito a definição de entradas e saídas, valores a serem adotados como valor inicial.


void config()
{
     TRISA = 0X00;              // todas são saídas
     TRISB = 0b11111111;   // todas são entradas
     TRISC = 0b01111001;   // alterna em 1 para input 0 para output
     TRISD = 0X00;               // todas são saídas
     TRISE = 0X00;                // todas são saídas
     NOT_RBPU_bit = 0;      // ativa resistor de pull down
     NOT_RBPU_bit = 1;       // ativa resistor de pull up
     delay_ms(300);                // tempo de sleep
     PORTB = 0x00;            // inicia com valor 0 em todos os bit's, se não for definido assume valor aleatório
     PORTC = 0x00;            // inicia com valor 0 em todos os bit's, se não for definido assume valor aleatório
     PORTD = 0x00;            // inicia com valor 0 em todos os bit's, se não for definido assume valor aleatório
 }