Linguagem C para Microcontroladores

RESUMO Linguagem C para Microcontroladores Prof. Glauber G. O. Brante UTFPR Universidade Tecnológica Federal do Paraná DAELT Departamento Acadêmico de Eletrotécnica

Sumário 1 Introdução................................... 3 2 Definições Gerais em Linguagem C..................... 4 2.1 A Linguagem C é Case Sensitive....................... 4 2.2 Palavras Reservadas.............................. 4 2.3 Comentários.................................. 4 2.4 Representação Numérica........................... 5 2.5 Tipos de Dados................................ 5 2.5.1 Constantes.............................. 6 2.5.2 Definições.............................. 7 2.6 Variáveis................................... 7 2.6.1 Variáveis Locais........................... 8 2.6.2 Variáveis Globais........................... 8 2.7 Funções.................................... 8 2.8 Header.................................... 9 3 Operadores.................................. 10 3.1 Operadores Aritméticos............................ 10 3.2 Operadores Relacionais............................ 11 3.3 Operadores Booleanos............................ 12 3.4 Operadores Lógicos.............................. 13 3.5 Associação de Operadores.......................... 14 4 Estruturas Condicionais............................ 15 4.1 A Estrutura if................................. 15 4.2 A Estrutura if-else............................... 16 4.3 A Estrutura if-else if............................. 16 4.4 A Estrutura switch............................... 17 5 Estruturas de Repetição............................ 18 5.1 O Laço for................................... 18 5.1.1 O Comando break.......................... 18 5.2 O Laço while................................. 19 5.2.1 Estrutura de Repetição Infinita.................... 19 5.3 O Laço do-while............................... 20 6 Comentários Finais.............................. 21

1 Introdução 3 1 Introdução O objetivo desse documento é fornecer um resumo sobre a linguagem C com ênfase em aplicações para microcontroladores. O emprego da linguagem C na programação de microcontroladores não é complicado, mas exige conhecimento mínimo da estrutura de programação, além de conhecimentos específicos sobre as estruturas internas do microcontrolador em questão. Este resumo apresentará as estruturas de programação mais comuns, necessárias para se programar microcontroladores. Para os conhecimentos específicos de cada microcontrolador, uma leitura do datasheet do componente se faz necessária. A estrutura básica de um programa em C para microcontroladores é a seguinte: void main() // inicializações de hardware e software while(1) // loop infinito /* tarefas a serem executadas pelo microcontrolador durante o funcionamento */ Com o uso inteligente dos comentários e funções, a programação se torna de mais fácil compreensão. Programas extensos podem ser divididos em sub-rotinas (funções) que ocasionalmente consumirão menos memória do microcontrolador e tornarão o se processamento mais rápido.

2 Definições Gerais em Linguagem C 4 2 Definições Gerais em Linguagem C 2.1 A Linguagem C é Case Sensitive Case sensitive significa que a linguagem C diferencia as letras maiúsculas das minúsculas. Assim, os identificadores CONTADOR, contador e Contador são diferentes entre si. Devemos prestar bastante atenção a esse fato, pois se criarmos uma variável de uma maneira e escrevermos de outra na hora de utilizá-la teremos um erro de compilação. Essa regra também se aplica a todos os comandos da linguagem C, que devem ser escritos em letras minúsculas, e.g., while, for, if. 2.2 Palavras Reservadas A linguagem C possui um conjunto de palavras reservadas que não podem ser usadas como variáveis de programa. As palavras reservadas da linguagem C, no padrão ANSI, são: Tab. 1: Palavras Reservadas em Linguagem C auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while main Como já comentado, uma palavra reservada da linguagem C não pode ser utilizada pelo programador como variável do programa. A seguir temos um exemplo de erro no emprego de variáveis: while = 1; int = 200; 2.3 Comentários Os comentários auxiliam na documentação do programa e são fundamentais para entendimento futuro de sua funcionalidade, especialmente se quem vai fazer a manutenção do firmware não é o próprio programador que o criou. Além disso, os comentários também são úteis exclusão de linhas de código durante a compilação, facilitando os testes durante a programação. Em geral, grande parte dos compiladores aceita dois tipos de comentários, os de linha simples e os de múltiplas linhas. Os comentários de linha simples sempre são iniciados com // (dupla barra), fazendo com que o compilador ignore tudo o que estiver na mesma linha depois da dupla barra. Por exemplo: // Este é um comentário de linha simples.

2 Definições Gerais em Linguagem C 5 Por sua vez, os comentários de múltiplas linhas devem ser sempre iniciados com /* e terminados com */. Por exemplo: /* Este é um comentário de múltiplas linhas. */ 2.4 Representação Numérica Nessa subseção apresentaremos um resumo das representações numéricas para microcontroladores PIC, baseados no compilador MikroC Pro. Os tipos numéricos são os mesmos para todos os microcontroladores, porém a representação numérica pode variar entre os diversos compiladores existentes. Decimal: valor_decimal = 125; Binário: PORTA = 0b11110001; Hexadecimal: valor_hexa = 0xFF; Octal: valor_octal = 075; Caractere: caracter = a ; 2.5 Tipos de Dados Toda variável usada em um programa deve ser declarada como de um determinado tipo, que define seu tamanho (em número de bits) e suas características. As variáveis podem ser: Tab. 2: Tipos de Dados Tipo Bytes Mínimo Máximo Representa void Zero Sem valor Sem valor Valores nulos char 1-128 127 Caracteres int 2-32768 32767 Inteiros float 4 ±1, 5 10 45 ±3, 4 10 38 Valores com casas decimais (ponto flutuante) double 8 ±4, 9 10 324 ±1, 8 10 308 Valores com casas decimais (ponto flutuante)

2 Definições Gerais em Linguagem C 6 Além disso, temos os seguintes modificadores de tipo: Tab. 3: Modificadores de Tipos de Dados Tipo Modificação signed Com sinal unsigned Sem sinal short Inteiro menor que o padrão long Inteiro maior que o padrão Portanto, temos os seguintes tipos de dados inteiros: Tab. 4: Tipos de Dados Inteiros Tipo Bytes Mínimo Máximo char 1-128 127 signed char 1-128 127 unsigned char 1 0 255 short int 2-128 127 signed short int 2-128 127 unsigned short int 2 0 255 int 2-32768 32767 signed int 2-32768 32767 unsigned int 2 0 65535 short 2-32768 32767 signed short 2-32768 32767 unsigned short 2 0 65535 long int 4 2 31 2 31 1 signed long int 4 2 31 2 31 1 unsigned long int 4 0 2 32 1 2.5.1 Constantes Servem para criar símbolos de valor constante que auxiliam na programação. No momento da compilação, o compilador se encarrega de atribuir os valores corretos aos símbolos criados. Por exemplo: const LIGADO = 1; const DESLIGADO = 0; const TMAX = 100; Após definir as constantes, é possível utilizar estas palavras como tendo o mesmo significado do valor numérico atribuído.

2 Definições Gerais em Linguagem C 7 2.5.2 Definições Além de dar nome a valores constantes, também podemos atribuir outros nomes a símbolos já existentes no microcontrolador. Por exemplo, imagine que você tenha um LED ligado ao bit 0 da porta A do seu microcontrolador, além de um motor DC ligado ao bit 1 dessa mesma porta. Para facilitar a programação, pode-se fazer: #define LED PORTA.B0 #define MOTOR PORTA.B1 Observe que na Linguagem C os comandos iniciados pelo caractere # são os únicos que não recebem ponto-e-vírgula no final da sentença. Assim, os comandos de definição #define e const servem para tornar o programa mais compreensível. Além disso, estes comandos são sempre eliminados pelo compilador, ou seja, não consomem memória extra do microcontrolador. Para visualizar sua utilizada, considere o código abaixo utilizando definições e constantes: #define LED PORTA.B0 #define MOTOR PORTA.B1 const LIGADO = 1; const DESLIGADO = 0; void main() LED = LIGADO; MOTOR = LIGADO; 2.6 Variáveis Uma variável sempre deve ser declarada da seguinte forma: (<modificador>) <tipo de dado> <nome da variável> (= <valor>); Note que a utilização do modificador e da inicialização da variável são opcionais. Exemplos: unsigned int valor = 123; char letra = a ; int contador; As variáveis podem ser do tipo locais ou globais, conforme veremos a seguir.

2 Definições Gerais em Linguagem C 8 2.6.1 Variáveis Locais São variáveis declaradas dentro de um bloco de instruções (ou função) e só podem ser acessadas dentro desse bloco. Exemplo: int media() int valor1 = 5; int valor2 = 7; return (valor1+valor2)/2; Uma observação importante é que todas as definições de variáveis locais devem aparecer logo no início do bloco/função. 2.6.2 Variáveis Globais São declaradas fora dos blocos de função e podem ser acessadas por todas as funções e blocos de instruções. Exemplo: int valor1 = 5; int valor2 = 7; int media() return (valor1+valor2)/2; int soma() return valor1+valor2; Mas atenção, apesar de parecer uma boa ideia declarar funções globais devemos ter bastante cuidado com sua utilização. Uma vez que estas variáveis podem ser acessadas por todas as funções, é difícil manter o controle sobre seus valores à medida que o código vai sendo executado. Por essa razão, declarar variáveis globais não é considerada uma boa prática de programação, devendo ser utilizadas apenas quando estritamente necessárias, e de forma bastante cuidadosa. 2.7 Funções Quando temos trechos de códigos que são repetidos várias vezes, podemos isolar estes trechos em funções. Assim, podemos chamar uma função em diferentes pontos do programa principal, evitando reescrever aquele trecho de código repetidamente. Uma função deve ser declarada antes de ser chamada. Por isso é importante escrever todas as novas funções antes da função principal (main). Por exemplo:

2 Definições Gerais em Linguagem C 9 void piscaled() PORTA.B0 = 1; delay_ms(1000); PORTA.B0 = 0; delay_ms(1000); // declara o início da função piscaled // liga o pino A0 // aguarda 1000ms (1 segundo) // desliga o pino A0 // aguarda 1 segundo void main(void) while(1) piscaled(); // início do programa principal // chama a função piscaled O void, que traduzido para português quer dizer vazio, é um tipo de dado utilizado em funções que não retornam nenhum parâmetro. A função main é sempre do tipo void, pois não retorna nem recebe nanhum valor. Entretanto, as funções podem muitas vezes conter parâmetros de entrada que carregam informações para dentro do bloco da função, além de parâmetros de saída, devolvendo informações ao programa principal. Por exemplo: int media(int a, int b) return (a + b)/2; /* declara o início da função media. Essa função recebe dois valores do tipo int (a e b) */ // retorna um valor do tipo int void main(void) int valor1 = 10; int valor2 = 20; int result; // início do programa principal result = media(valor1, valor2); /* A função média retorna seu valor do tipo int na variável result */ 2.8 Header Em muitos compiladores, é necessário incluir um arquivo que contém todas as definições do microcontrolador sendo utilizado. Isto é feito através do comando #include. Em geral, temos a seguinte sintaxe que deve ser incluída logo no início de qualquer programa: #include<microcontrolador.h> Além deste arquivo com as definições do microcontrolador, podemos utiliza a instrução #include para incluir algum arquivo denominado cabeçalho, contendo funções auxiliares a serem utilizadas. Por exemplo: #include<nome_do_arquivo.h>

3 Operadores 10 3 Operadores A linguagem C possui operadores para atribuir, comparar ou modificar dados e variáveis. Podemos dividir estes operadores em quatro categorias principais: Aritméticos: para cálculos; Relacionais: para comparar valores numéricos; Lógicos: para testar condições ou manipular bits; Booleanos: para realizar operações lógicas com mais de um bit. 3.1 Operadores Aritméticos Em linguagem C temos os seguintes operadores aritméticos: Tab. 5: Operadores Aritméticos Símbolo Operação + Soma - Subtração * Multiplicação / Divisão % Resto inteiro da divisão ++ Incremento em um Decremento em um Os operadores aritméticos sempre usam duas variáveis e retornam um terceiro valor mantendo inalteradas as variáveis originais. Exemplos: Soma: int y = 10; int z = 5; int x = 0; x = y + z; /* Soma o conteúdo da variável y com a variável z e armazena o resultado na variável x */ Subtração: int a = 10; int b = 5; int c = 0; c = b - a; /* Subtrai da variável b o conteúdo da variável a e armazena o resultado na variável c */

3 Operadores 11 Multiplicação: int a = 1; int b = 20; int c = 2; a = b*c; /* Multiplica o conteúdo da variável b pelo da variável c e armazena o resultado na variável a */ Divisão: int a = 0; int b = 20; int c = 2; a = b/c; /* Divide o conteúdo da variável b pelo da variável c e armazena o resultado na variável a */ Resto inteiro da divisão: int a = 1; int b = 25; int c = 2; a = b%c; /* Divide o conteúdo da variável b pelo da variável c e armazena o resto da divisão na variável a */ Incremento em um: int contagem = 0; contagem++; // Incrementa a variável contagem em um Decremento em um: int contagem = 0; contagem--; // Decrementa a variável contagem em um 3.2 Operadores Relacionais Realizam operações de comparação, retornando os valores FALSO (0) ou VERDADEIRO (1). Esses operadores não afetam o conteúdo das variáveis sendo comparadas.

3 Operadores 12 Tab. 6: Operadores Relacionais Símbolo Descrição == Igual a!= Diferente de < Menor que > Maior que <= Menor ou igual >= Maior ou igual Exemplo: void main() unsigned char cont = 0; while(1) if (PORTA.B0 == 1) // Se o pino A0 estiver ligado if (cont < 9) cont++; /* Se contagem for maior que 9, incrementa */ else cont = 0; // Caso contrário, zera 3.3 Operadores Booleanos São usados para realizar testes booleanos entre elementos em um teste condicional. Os operadores são: Tab. 7: Operadores Booleanos Símbolo Descrição && E (AND) OU (OR)! NÃO (NOT) Exemplo 1: int A = 0; if ((A > 0) && (A < 10)) A++; Significado: se A for maior do que zero E A for menor do que dez, então incremente A em um.

3 Operadores 13 Exemplo 2: int A = 0; int B = 0; int C = 0; if ((A!= B) (A!= C)) A--; Significado: se A for diferente de B OU A for diferente de C, então decremente A em um. 3.4 Operadores Lógicos São usados para realizar testes lógicos bit a bit. Os operadores lógicos são: Tab. 8: Operadores Lógicos Símbolo Descrição & E (AND) OU (OR) OU Exclusivo (XOR) NÃO (NOT)» Deslocamento para a direita «Deslocamento para a esquerda Exemplo 1: int cont = 0; if (PORTA.B0 & PORTA.B1) cont++; Significado: se PORTA.B0 for igual a um E PORTA.B1 for igual a um, então cont é incrementado em uma unidade. Exemplo 2: int cont = 0b00000001; if (PORTA.B0 PORTA.B1) cont = cont<<1; Significado: se PORTA.B0 for igual a um OU PORTA.B1 for igual a um, então o valor de cont é deslocado para a esquerda. Exemplo 3: int cont = 10; if (PORTA.B0 & ~PORTA.B1) cont--; Significado: se PORTA.B0 for igual a um E PORTA.B1 não for igual a um, então o valor de cont é decrementado de uma unidade.

3 Operadores 14 3.5 Associação de Operadores Algumas abreviações são comumente utilizadas com os operadores. Dentre elas podemos citar: Tab. 9: Abreviações de Operadores Forma Expandida Forma Reduzida x = x + y x += y x = x - y x -= y x = x * y x *= y x = x / y x /= y x = x % y x %= y x = x & y x &= y x = x y x = y x = x y x = y x = x << y x <<= y x = x >> y x >>= y

4 Estruturas Condicionais 15 4 Estruturas Condicionais 4.1 A Estrutura if A estrutura if, que significa se em português, é uma estrutura de decisão baseada no resultado de um teste lógico. Sua forma geral é: if (condição) comando 1; comando 2;... comando n; Se houver apenas uma instrução a ser executada após o teste lógico, as chaves podem desprezadas: if (condição) comando; Em C, qualquer número diferente de zero é considerado verdadeiro, o que significa que a condição if só será falsa se o teste lógico aplicado resultar em zero (0). Qualquer outro valor, mesmo que negativo, é considerado verdadeiro (1). Exemplo: void main() int contagem = 0; if (PORTA.B0) contador++; /* Apenas se o valor da porta A0 for igual a um, o contador será incrementado */ Entretanto, em geral utilizamos uma expressão lógica como condição de entrada para a estrutura if: void main() int contagem = 0; if (PORTA.B0 == 0) contador++; /* Apenas se o valor da porta A0 for igual a zero, o contador será incrementado */ Uma observação importante é quanto a diferença entre o operador de atribuição (=) e a operação booleana de igualdade (==). Para inicializar uma variável utilizamos =, porém, para testar o valor de uma variável utilizamos ==. Por exemplo: int a = 10; // Inicializamos a variável a com o valor 10 if (a == 10) a++; // Fazemos o teste booleano com a variável a

4 Estruturas Condicionais 16 4.2 A Estrutura if-else A estrutura if pode ser expandida com o uso de else (senão), que permite definir comandos a serem executados caso o teste seja falso (0). Por exemplo: int i = 10; int j = 5; if (i == 10) j++; else j--; // Se i for igual a 10, incrementa j // Senão, decrementa j Caso haja mais de um comando if na sequência, o else estará sempre relacionado com o último if. Por exemplo: int i = 10; int j = 5; if (i == 10) j++; else j--; // Se i for igual a 10, incrementa j // Senão, decrementa j 4.3 A Estrutura if-else if Este tipo de estrutura permite um número de alinhamentos de comandos, possibilitando colocar estruturas if dentro de outras estruturas if com maior facilidade. Seu formato geral é: if (condição 1) comandos; else if (condição 2) comandos; else if (condição 3) comandos; A estrutura if-else if é uma alternativa para tornar tomadas de decisões mais rápidas em alguns casos, Isto ocorre porque, no momento em que alguma condição seja satisfeita, os demais blocos if subsequentes não serão sequer testados.

4 Estruturas Condicionais 17 4.4 A Estrutura switch A estrutura switch é muito parecida com a estrutura if-else if. A diferença é que switch não aceita expressões lógicas para tomar decisões, mas somente constantes. O comando switch testa o valor de uma variável e executa os comandos correspondentes a casos (cases) préestabelecidos. Cada case define uma série de comandos que serão executados até chegar na instrução break. Quando nenhum caso correspondente for encontrado, a cláusula default será executada. Porém, o uso da cláusula default é opcional. Formato da estrutura switch: switch(variável) case constante1: comandos; break; case constante2: comandos; break;... case constante n: comandos; break; default: comandos; break; Exemplo de uso da estrutura switch: int contador = read_adc(); switch(contador) case 0: x++; PORTA.B0 = 1; break; case 1: PORTA.B1 = 1; break; case 2: PORTA.B0 = 0; PORTA.B1 = 0; break; default: break; /* lê o valor do conversor AD e armazena na variável contador */

5 Estruturas de Repetição 18 5 Estruturas de Repetição 5.1 O Laço for O laço for é utilizado quando precisamos de uma ciclo controlado de repetições. Em sua inicialização definimos uma variável de controle, a qual damos um valor inicial, uma condição de parada, e uma regra de incremento (ou decremento). Antes de serem executados os comandos do laço for, avalia-se a condição de teste. Caso esta condição seja verdadeira, os comandos são executados. A cada ciclo de execução (iteração), a variável de controle é incrementada ou decrementada de acordo com uma regra. A estrutura geral do laço for é: for(inicialização; condição; incremento) comandos; Vejamos um exemplo de uso: for(i = 0; i < 10; i++) PORTA.B0 = 1; delay_ms(1000); PORTA.B0 = 0; delay_ms(1000); // liga o pino A0 // aguarda 1 segundo // desliga o pino A0 // aguarda 1 segundo Neste exemplo, a variável i é inicialmente carregada com o valor 0 (i = 0). Como a condição inicial é verdadeira (i < 10), os comandos do laço são executados. Após a execução dos comandos do laço, a variável i é incrementada em uma unidade, dada pela condição de incremento i++, e novamente os comandos do laço são executados. Isto é feito até que a condição se torne falsa, isto é, quando i for igual a 10. Ainda é possível utilizar o laço for em passos decrescentes. O mesmo código acima pode ser escrito de maneira equivalente como: for(i = 10; i > 0; i--) PORTA.B0 = 1; delay_ms(1000); PORTA.B0 = 0; delay_ms(1000); // liga o pino A0 // aguarda 1 segundo // desliga o pino A0 // aguarda 1 segundo 5.1.1 O Comando break o comando break é utilizado para encerrar o laço for antes de se completar todas as iterações. Quando o laço é quebrado, o programa pula para a próxima instrução após o laço. Exemplo: void main() int i = 0;

5 Estruturas de Repetição 19 for(i = 0; i < 10; i++) if (PORTB.B0 == 1) break; PORTA.B0 = 1; delay_ms(1000); PORTA.B0 = 0; delay_ms(1000); // liga o pino A0 // aguarda 1 segundo // desliga o pino A0 // aguarda 1 segundo Neste exemplo, o pino A0 ficará piscando desde que o pino B0 seja diferente de 1. Quando isto acontecer (quando B0 for ligado), o comando break será executado e o laço será encerrado. 5.2 O Laço while O laço while tem a seguinte estrutura: while(condição) comandos; Dessa forma, o laço inicialmente verifica uma condição lógica. Se esta condição for verdadeira, os comandos dentro do laço serão executados, caso contrário, o programa salta para a linha de comando imediatamente após o fim do laço. A condição pode ser uma operação relacional, ou um teste booleano. Por exemplo: while(x<50) // Enquanto x for menor do que 50 x++; // incrementa x 5.2.1 Estrutura de Repetição Infinita Microcontroladores em geral são programados para executar uma tarefa indefinidamente. Dessa forma, o uso de laços infinitos é bastante comum. Uma maneira de criar um laço infinito é fornecer uma condição sempre verdadeira ao while. Assim, uma estrutura típica de um programa em C para microcontroladores é a seguinte: void main() // inicializações de hardware e software while(1) // loop infinito /* tarefas a serem executadas pelo microcontrolador durante o funcionamento */ onde a condição em while(1) é sempre verdadeira (sempre igual a 1).

5 Estruturas de Repetição 20 5.3 O Laço do-while O laço do-while nada mais é do que uma variação do laço while. Sua estrutura geral é: do comandos; while(condição); A diferença aqui é que os comandos são executados antes de se realizar o teste lógico de condição. Caso o teste executado ao final seja verdadeiro, o laço é executado novamente do início. Caso contrário, o programa segue com a instrução imediatamente após o laço.

6 Comentários Finais 21 6 Comentários Finais Todo o material apresentado neste resumo é material de livre acesso, baseado nas notas de aula disponíveis em http://paginapessoal.utfpr.edu.br/gbrante, bem como no livro Programação Linguagem C para Microcontroladores 8051, da iniciativa u8051, disponível em http://www.u8051.com.br/.