MATERIAL AUXILIAR PARA CURSO AVANÇADO I MSP430

TECH TRAINING – ENGENHARIA E TREINAMENTOS

Prof. Alessandro Ferreira da Cunha msn: [email protected]

skype: alessandroferreiradacunha

CURSO AVAÇADO I – MICROCONTROLADOR MSP430

PROGRAMAÇÃO DO TREINAMENTO:

Material auxiliar para curso Avançado I de MSP430 – Prof. Alessandro F. Cunha

Página 2 de 110

1. Arquiteturas von-Neumann X Arquiteturas Harvard

1.1. von-Neumann Algoritmos para computadores se baseiam em alguns conceitos básicos e em um modelo de computador, os quais devem ser bem entendidos para que se possa criar algoritmos eficientes. Este modelo foi proposto pelo matemático húngaro Neumann János Lajos Margittai. Em húngaro o nome de família aparece antes. Assim em português o seu nome seria János Lajos Margittai Neumann. O seu pai, que era rico, comprou um título de nobreza e ele passou a se chamar János Lajos Margittai von Neumann. No modelo de computador proposto por von Neumann as instruções e os dados ficam juntos na memória. O processador busca na memória e executa uma instrução de cada vez. Portanto, as transferências entre a memória e o processador são feitas passo a passo. O ciclo normal da execução de um programa é então: 1. Busca instrução; 2. Decodifica instrução; 3. Executa instrução; 4. Volta para o passo 1 buscando a instrução seguinte na memória. Dados e programas compartilham um meio de armazenamento único.

• Mais simples, menos restritivo, menos eficiente – dados e programas misturados permitem ao programador intercambiar a semântica de dados e programas ao longo do tempo


Página 3 de 110

1.2. Harvard Dados e programas estocados em meios de armazenamento distintos

• Mais propenso a fomentar paralelismo, mais caro, mais complexo – dados e programas separados permitem que ambos sejam facilmente tratados em paralelo.

• Harvard permite duas leituras de memória simultâneas (dado e instrução). • A maioria dos processadores DSP (celulares, telecom, câmeras digitais,…) usam

organização Harvard, pois isto permite maior largura de banda de memória e tempo de acesso a dados mais previsível.


Página 4 de 110

1.3. Qual a escolha da Texas para o MSP430?

Veja o que dizem os manuais das famílias MSP430x4xx e MSP430x2xx: “Architecture The MSP430 incorporates a 16-bit RISC CPU, peripherals, and a flexible clock system that interconnect using a von-Neumann common memory address bus (MAB) and memory data bus (MDB). Partnering a modern CPU with modular memory-mapped analog and digital peripherals, the MSP430 offers solutions for demanding mixed-signal applications.” Isso significa que a Texas optou por uma arquitetura von-Neumann “modificada”, tendo dois barramentos separados (como na arquitetura Harvard) mas fazendo acesso a apenas um barramento por vez (como na arquitetura von-Neumann). Como será visto ao longo deste treinamento, isto acaba tirando proveito das vantagens de cada uma das arquiteturas em um único chip.

1.4. Máquina von-Newmann


Página 5 de 110

Exemplo de funcionamento de uma arquitetura Von Newmann: SOMAR DOIS NÚMEROS QUE SÃO INSERIDOS NA ENTRADA E COLOCAR O RESULTADO NA SAÍDA. 1. Colocar o primeiro número a ser somando na porta de entrada do μC. 2. Dar um pulso de clock no BUFFER.

2.1. O primeiro número passa a ocupar o barramento de dados e fica armazenado no BUFFER.

3. Dar um pulso de clock no Registrador A.

3.1. O primeiro número passa a ocupar o barramento interno, fica armazenado no Registrador A e está na entrada da ULA.

4. Colocar o segundo número a ser somado na porta de entrada do μC.

4.1. Enquanto não for aplicado no BUFFER um pulso de clock, em sua entrada terá o segundo número e em sua saída terá o primeiro número.

5. Dar um pulso de clock no BUFFER.

5.1. Ao fazer isso, o primeiro número é apagado da saída do BUFFER, que passa a ser ocupado pelo segundo número. Caso o primeiro número não tenha sido armazenado em algum Registrador, ele será perdido.

6. Dar um pulso de clock no Registrador B.

6.1. O segundo número passa a ocupar o barramento interno, fica armazenado no Registrador B e está na entrada da ULA.

7. Colocar nos bits de comando da ULA a informação X0 = 0 e X1 = 0.

7.1. Ao fazer isso, a ULA calculará a soma dos dados que estejam presentes em suas entradas. Se não houver dados na entrada, ela somará zero com zero. Automaticamente, o resultado é colocado na saída da ULA.

8. Dar um pulso de clock no Gate da ULA (GULA).

8.1. Ao fazer isso o segundo número é apagado do barramento de dados, que passa a ser ocupado pelo resultado da soma dos dois números.

9. Dar um pulso de clock no LATCH.

9.1. O resultado da soma é colocado na porta de saída.


Página 6 de 110

1.5. Máquina von-Neumann modificada

1.6. CISC x RISC A principal função de um microcontrolador é executar uma série de ordens (comandos ou instruções), armazenados em um programa, na sua memória. Cada uma destas instruções é interpretada pela CPU e, então, executada. Assim, cada tipo de computador digital, deve ter um conjunto de instruções (ou set de instruções) definidas, de modo que sua CPU possa interpretá-las e executá-las. Em função deste conjunto de instruções, existem duas classes de computadores digitais:

1.6.1. CISC Complex Instruction Set Computer

• Conjunto de instruções ampliado, ou seja, a CPU é capaz de executar um grande número de instruções (ex.: microcontrolador 8051, da Intel, com 256 instruções);

• É geralmente associada a computadores com arquitetura von-Neumann.

1.6.2. RISC Reduced Instruction Set Computer

• Conjunto de instruções reduzido (ex.: família PIC, da Microchip, com 35 instruções, e família MSP430, da Texas, com 24 instruções emuladas e 27 instruções físicas);

• É geralmente associada a computadores com arquitetura Harvard.


Página 7 de 110

2. Famílias MSP430 e detalhamento do hardware

Arquitetura do MSP430F2013.

Arquitetura do MSP430FG4618.


Página 8 de 110

3. Clocks e LPM

FAMÍLIA 4 - 16-Bit RISC Architecture, 125-ns Instruction Cycle Time FAMÍLIA 2 - 16-Bit RISC Architecture, 62.5 ns Instruction Cycle Time Quanto tempo demora a ser executada cada uma das instruções no MSP430? Como acontece no 8051, a quantidade de ciclos de máquina necessária para executar uma instrução varia de acordo com o modo de endereçamento utilizado e com o formato da instrução. Sempre as instruções são referenciadas ao sinal de clock chamado de MCLK. Os chips MSP430 se caracterizam pelo baixo consumo de energia. Um dos métodos utilizados para obter estas funcionalidades é o gerenciamento de clock e os modos de operação em baixa potência (LPM – Low Power Mode). Tanto a família 2 quanto a família 4 tem várias opções de clock que podem ser conectadas ao chip.

3.1. Sinais de clock externo Na família 2 o funcionamento do clock é gerenciado pelo Basic Clock Module+. Ele permite que até 4 tipos de clock diferentes sejam utilizados:

• LFXT1CLK (Low-frequency/high-frequency oscillator): Funciona com o uso de um cristal externo. Este cristal pode ser desde um modelo de baixa velocidade, fixado


Página 9 de 110

em 32.768 Hz, até cristais de quartzo ou ressonadores, com valores entre 400 khz e 16 Mhz. Sinais de clock criados por geradores externos também são aceitos.

• XT2CLK (Optional high-frequency oscillator): Funciona com o uso de um cristal externo de alta velocidade. Isto pode ser feito através de cristais de quartzo, ressonadores ou fontes de clock externa (entre 400 khz e 16 Mhz).

• DCOCLK (Internal digitally controlled oscillator (DCO)). • VLOCLK (Internal very low power, low frequency oscillator): com 12-kHz de

frequencia típica. Já na família 4 o funcionamento do clock é bem similar ao da família 2, mas o gerenciamento é feito por um módulo que leva o nome de FLL+ Clock Module. Ele permite que somente 3 primeiros tipos de clock mostrados na família 2 possam ser gerados, sendo que a opção VLOCLK não está disponível. As velocidades de clock externo admissíveis para a família 4 vão de 450 khz a 8 Mhz. Apenas os dispositivos MSP430F47x admitem velocidades até 16 Mhz.

3.2. Sinais de clock internos Independente de qual fonte de clock foi utilizada pelo chip, sempre serão gerados três sinais de clock internamente:

• ACLK (Auxiliary clock): esta fonte de clock é selecionável por software quando as fontes são o LFXT1CLK ou o VLOCLK. ACLK pode ser dividido por 1, 2, 4, or 8. Esta é a fonte de clock utilizada por todos os módulos de periféricos.

• MCLK (Master clock): esta fonte de clock também é selecionável por software, para qualquer uma das quatro fontes de clock possíveis: LFXT1CLK, VLOCLK, XT2CLK ou DCOCLK. MCLK pode ser dividido por 1, 2, 4, ou 8. É utilizado para alimentar a CPU.

• SMCLK (Sub-main clock): também é selecionável por software para qualquer uma das quarto fontes de clock possíveis, divisível por 1, 2, 4, or 8. É utilizado individualmente para alimentar alguns periféricos.

Apenas na família 4, um quarto sinal de clock interno pode ser gerado, mas que é complementar aos já mostrados anteriormente:

• ACLK/n (Auxiliary clock buffed output): faz um buffer de saída do sinal gerado pelo ACLK. Dedica-se apenas ao uso externo ao chip, para gerar um sinal de sincronismo, por exemplo.

Na figura a seguir é possível visualizar o módulo que controla o clock do MSP430, para as famílias 43, 44 e 46. Depois é mostrado o módulo para a família 2.


Página 10 de 110


Página 11 de 110


Página 12 de 110

3.3. Os registradores que controlam os clocks

FAMÍLIA 2

FAMÍLIA 4

3.4. As freqüências possíveis no DCO FAMÍLIA 2


Página 13 de 110

FAMÍLIA 4


Página 14 de 110


Página 15 de 110

3.5. LPMs LOW POWER MODES

A existência de sinais de clock diferentes internamente permite que modos de consumo diferentes sejam utilizados de acordo com cada aplicação do usuário. Isto permite uma grande economia da energia consumida pelo chip. Isto pode ser visualizado na figura a seguir.

A entrada ou saída em cada um dos modos de operação em baixo consumo é feito através de bits localizados no registrador especial R2, como será descrito em detalhes ao longo deste treinamento.


Página 16 de 110

São ao todo cinco modos de operação em baixa potência, além do modo ativo, como pode ser visto nas tabelas das famílias 2 e 4, logo abaixo: FAMÍLIA 2

FAMÍLIA 4

A entrada ou saída de qualquer um destes modos pode ser feita através de mudanças nos bits do registrador R2, como pode ser visto nos exemplos abaixo: ; Enter LPM0 Example BIS #GIE+CPUOFF,SR ; Enter LPM0 ; Program stops here ; Exit LPM0 Interrupt Service Routine BIC #CPUOFF,0(SP) ; Exit LPM0 on RETI RETI


Página 17 de 110

; Enter LPM3 Example BIS #GIE+CPUOFF+SCG1+SCG0,SR ; Enter LPM3 ; Program stops here ; Exit LPM3 Interrupt Service Routine BIC #CPUOFF+SCG1+SCG0,0(SP) ; Exit LPM3 on RETI RETI Como em cada modo de potência apenas alguns clocks são desligados, pode-se deixar a CPU desligada e manter periféricos funcionando, o que comprova o baixo consumo do dispositivo.


Página 18 de 110

4. Os registradores de trabalho, ou registradores especiais Diferente de outros fabricantes de microcontroladores, a Texas colocou nas famílias MSP430 16 registradores de trabalho com acesso direto a CPU e aos barramentos de dados e memória, como pode ser visto na figura abaixo. Isto gera uma grande praticidade de uso do chip, com facilidades que serão discutidas ao longo deste treinamento. Vamos analisar cada um destes registradores em detalhes.


Página 19 de 110

4.1. Program counter (contador de programa)

Aponta qual será a próxima instrução dentro do programa a ser executada pela CPU.

Ele pode ser endereçado por qualquer um dos sete modos existentes no MSP430. Alguns exemplos são mostrados a seguir. MOV #LABEL,PC ;desvio para o endereço do LABEL MOV LABEL,PC ;desvio para o endereço indicado pelo LABEL

MOV @R14,PC ;desvio indireto indicado pelo R4

4.2. Stack Pointer (ponteiro da pilha)

A pilha é um recurso utilizado para armazenar informações enquanto são executadas rotinas de interrupção ou chamadas de sub-rotinas. Para tanto é necessário apontar qual posição da pilha será utilizada. Isto é feito através do registrador Stack Pointer.

MOV 2(SP),R6 ; Item I2 −> R6 MOV R7,0(SP) ; Overwrite TOS with R7 PUSH #0123h ; Put 0123h onto TOS

POP R8 ; R8 = 0123h


Página 20 de 110

4.3. Status Register (R2) O registrador de status contém os bits de controle aritmético, atualizados a cada operação realizada pela CPU. Além disto é nele que são ajustados os bits de controlam os modos de operação em baixa potência, como pode ser visto abaixo.

A descrição bit a bit de funcionamento e suas respectivas configurações são mostradas na tabela a seguir.

4.4. Constant Generator (R3) As seis constantes mais utilizadas durante toda a operação da CPU são geradas de modo automaticamente pelo gerador de constantes, que é composto pelos registradores R2 e R3, sem a necessidade de qualquer código adicional de programa. As constantes são selecionadas de acordo com o endereçamento do registrador fonte, como é mostrado na tabela a seguir.


Página 21 de 110

BITS DO STATUS REGISTER

CONSTANTES GERADAS AUTOMATICAMENTE


Página 22 de 110

São estas constantes que permitem que o set de instruções do MSP430, que tem originalmente apenas 27 instruções (RISC) possa ser expandido em mais 24, totalizando 51 instruções. Tudo isto sem a necessidade de acrescentar nenhuma outra linha de código. Alguns exemplos de como isto funciona são mostrados abaixo: INSTRUÇÃO PARA LIMPAR UM REGISTRADOR (CLR) CLR dst

Isto é emulado em uma instrução de duplo operando, com o mesmo comprimento, fazendo: MOV R3,dst ;onde R3 recebe o valor de #00

INSTRUÇÃO INCREMENTAR UM REGISTRADOR (CLR) INC dst

Isto é emulado em uma instrução de duplo operando, com o mesmo comprimento, fazendo: ADD 0(R3),dst ;onde R3 recebe o valor #01

4.5. General Purpouse Registers (R4 – R15)

Os demais registradores conectados diretamente a CPU (R4 a R15) são de propósito geral, podendo ser utilizados para qualquer função desejada pelo usuário, como armazenamento de constantes ou valores, ponteiros de endereçamento, indexadores de valores, etc. Alguns exemplos das operações que podem ser realizadas com estes registradores são mostradas na figura a seguir.


Página 23 de 110

5. Estrutura de memórias: RAM, ROM (Flash) Como pode ser visto no item 2 deste material, as memórias RAM, ROM (Flash) são dois trechos distintos dentro do hardware. Porém seu mapeamento é contínuo, incluindo os vetores de interrupção, de reset, periféricos e registradores com funções especiais.

5.1. Memórias no MSP430 O mapeamento de memória no MSP430 é igual para as famílias 2 e 4 e seguem a estrutura mostrada na figura a seguir.


Página 24 de 110

A quantidade de dados armazenada em cada espaço do mapa de memória é de 8 bits. Porém o MSP430 é um microcontrolador de 16 bits. Como resolver isto? O acesso ao mapa memória pode ser feito em Word (16 bits), byte (8 bits) ou em bit, como pode ser visto na figura a seguir.


Página 25 de 110

5.1.1. Memórias de programa (ROM – FLASH) O microcontrolador MSP430 armazena todo o programa que será executado em sua memória ROM/FLASH. Perceba que na arquitetura destes processadores não há memória do tipo EEPROM. Deste modo, dados permanentes, que não podem ser perdidos em caso de falta de energia elétrica, devem também ser armazenados na memória FLASH. O Hardware onde está a memória FLASH é mostrada na figura a seguir.


Página 26 de 110

Toda a memória FLASH do MSP430 é particionada em segmentos. O processo de gravação pode acontecer em trechos de Words, Bytes ou mesmo bits. Mas para apagamento isto só pode ocorrer por segmentos completos. O particionamento para uma memória de 4 Kbytes é mostrado na figura abaixo. Isto sempre ocorre em segmentos, sendo que cada segmento é sub dividido em 4 blocos.


Página 27 de 110

6. Reduced Instruction Set Code – RISC O MSP430, apesar de ter uma arquitetura do tipo von-Neumann, trabalha com um set de instruções reduzido (RISC). São apenas 27 instruções físicas (core instructions). Com o uso dos registradores que geram constantes (R2 e R3) é possível emular mais 24 instruções, totalizando 51 instruções. Basicamente as instruções são de três tipos:

• Dual-operand: dois operandos fonte e destino; • Single-operand: apenas um operando, que pode ser uma fonte ou um destino; • Jump: instruções de salto no programa.

Todas as instruções de operando simples ou duplo podem ser escritas em bytes (8 bits) ou words (16 bits). Na construção das instruções sempre é seguida a seguinte nomenclatura:

• src: o operador fonte é definido por As e S-reg; • dst: o operador destino é definido por Ad e D-reg; • As: determina qual modo de endereçamento utilizado pela instrução, especificando

quem é o registrador fonte; • S-reg: quem, dos 16 registradores diretos à CPU, é utilizado como fonte; • Ad: determina qual modo de endereçamento utilizado pela instrução, especificando

quem é o registrador destino; • D-reg: quem, dos 16 registradores diretos à CPU, é utilizado como destino; • B/W: indica se a instrução é orientada a byte (1) ou a word (0);


Página 28 de 110

6.1. Modos de endereçamento


Página 29 de 110

6.2. Formatos das instruções

6.3. As 51 instruções SOURCE AND DESTINATION INSTRUCTIONS


Página 30 de 110

DESTINATION ONLY INSTRUCTIONS

JUMPS INSTRUCTIONS


Página 31 de 110


Página 32 de 110

6.4. Ciclos de máquina e tamanho das instruções

INTERRUPÇÕES E RESET

INSTRUÇÕES DE FORMATO II (DESTINATION ONLY)

INSTRUÇÕES DE FORMATO III (JUMP) Todas as instruções desta categoria necessitam de um Word de comprimento e dois ciclos de máquina para serem executadas, independente da ação de salto acontecer ou não.


Página 33 de 110

INSTRUÇÕES DE FORMATO I (SOURCE AND DESTINATION)


Página 34 de 110

7. AMBIENTE IAR

• Como é feita a criação de projetos no IAR • Como editar arquivos de programa assembly (.ASM) • A importância do uso de comentários durante a programação • Estrutura de um programa .ASM • Vetores de Reset e de interrupção • Diretivas do IAR • O que é o arquivo include


Página 35 de 110

8. COMO ESTRUTURAR UM PROGRAMA EM C PARA MSP430? E-0-0

//****************************************************************************** // MSP430xG46x Demo - Software Toggle P5.1 // // Description: Toggle P5.1 by xor'ing P5.1 inside of a software loop. // ACLK = 32.768kHz, MCLK = SMCLK = default DCO // // MSP430xG461x // |-----------------| // /|\| | // | | | // --|RST | // | | // | P5.1|-->LED // // K. Quiring/M. Mitchell // Texas Instruments Inc. // October 2006 // Built with IAR Embedded Workbench Version: 3.41A //****************************************************************************** #include <msp430xG46x.h> void main(void) { volatile unsigned int i; WDTCTL = WDTPW+WDTHOLD; // Stop WDT P5DIR |= 0x02; // P5.1 output while(1) { P5OUT ^= 0x02; for(i=50000;i>0;i--); // Delay } }


Página 36 de 110

9. A PLACA DE EXERCÍCIOS: EXPERIMENTER BOARD


Página 37 de 110


Página 38 de 110


Página 39 de 110


Página 40 de 110

10. BREVE INTRODUÇÃO A LINGUAGEM C (http://pt.wikipedia.org/wiki/c_(linguagem_de_programaçao)) C é uma linguagem de programação compilada de propósito geral, estruturada, imperativa, procedural, de alto nível, e padronizada, criada em 1972, por Dennis Ritchie, no AT&T Bell Labs, para desenvolver o sistema operacional UNIX (que foi originalmente escrito em Assembly). A linguagem C é classificada de alto nível pela própria definição desse tipo de linguagem. A programação em linguagens de alto nível tem como característica não ser necessário conhecer o processador, ao contrário das linguagens de baixo nível. As linguagens de baixo nível estão fortemente ligadas ao processador. A linguagem C permite acesso de baixo nível com a utilização de código Assembly no meio do código fonte. Assim, o baixo nível é realizado por Assembly e não C. Desde então, espalhou-se por muitos outros sistemas, e tornou-se uma das linguagens de programação mais usadas, e influenciou muitas outras linguagens, especialmente C++, que foi originalmente desenvolvida como uma extensão para C.

10.1. História

Ken Thompson e Dennis Ritchie (da esquerda pra direita), os criadores das linguagens B e C, respectivamente. O desenvolvimento inicial de C, ocorreu no AT&T Bell Labs, entre 1969 e 1973. Deu-se o nome “C” à linguagem, porque muitas de suas características derivaram da linguagem B. C foi originalmente desenvolvido, para a implementação do sistema UNIX (originalmente escrito em PDP-7 Assembly, por Dennis Ritchie e Ken Thompson). Em 1973, com a adição do tipo struct, C tornou-se poderoso o bastante para a maioria das partes do Kernel do UNIX, serem reescritas em C. Este foi um dos primeiros sistemas que foram implementados em uma linguagem, que não o Assembly, sendo exemplos anteriores, os sistemas: Multics (escrito em PL/I) e TRIPOS (escrito em BCPL). Segundo Ritchie, o período mais criativo ocorreu em 1972.


Página 41 de 110

10.2. K&R C

Em 1978, Brian Kernighan e Dennis Ritchie publicaram a primeira edição do livro The C Programming Language. Esse livro, conhecido pelos programadores de C, como “K&R”, serviu durante muitos anos como uma especificação informal da linguagem. A versão da linguagem C que ele descreve é usualmente referida como “K&R C”. A segunda edição do livro, cobriu o padrão posterior, o ANSI C. K&R C introduziu as seguintes características na linguagem:

• Biblioteca padrão de E/S; • Tipos de dado struct; • Tipos de dado long int; • Tipos de dado unsigned int; • O operador =+ foi alterado para +=, e =- para -= (o analisador léxico do compilador

fazia confusão entre i =+ 10 e i = +10. O mesmo acontecia com =-). K&R C é freqüentemente considerado a parte mais básica da linguagem, cujo suporte deve ser assegurado por um compilador C. Durante muitos anos, mesmo após a introdução do padrão ANSI C, K&R C foi considerado o “menor denominador comum”, em que programadores de C se apoiavam quando uma portabilidade máxima era desejada, já que nem todos os compiladores eram atualizados o bastante para suportar o padrão ANSI C. Nos anos que se seguiram à publicação do K&R C, algumas características “não-oficiais” foram adicionadas à linguagem, suportadas por compiladores da AT&T e de outros vendedores. Estas incluíam:

• Funções void e tipos de dados void *; • Funções que retornam tipos struct ou union; • Campos de nome struct num espaço de nome separado para cada tipo struct; • Atribuição a tipos de dados struct; • Qualificadores const para criar um objecto só de leitura; • Biblioteca padrão, que incorpora grande parte da funcionalidade implementada por

vários vendedores; • Enumerações; • Cálculos de ponto-flutuante em precisão simples (no K&R C, os cálculos

intermediários eram feitos sempre em double, porque era mais eficiente na máquina onde a primeira implementação do C foi feita).


Página 42 de 110

10.3. ANSI C e ISO C

Durante os finais da década de 1970, a linguagem C começou a substituir a linguagem BASIC como a linguagem de programação de microcomputadores mais usada. Durante a década de 1980, foi adaptada para uso no PC IBM, e a sua popularidade começou a aumentar significativamente. Ao mesmo tempo, Bjarne Stroustrup, juntamente com outros nos laboratórios Bell, começou a trabalhar num projecto onde se adicionavam construções de linguagens de programação orientada por objectos à linguagem C. A linguagem que eles produziram, chamada C++, é nos dias de hoje a linguagem de programação de aplicações mais comum no sistema operativo Windows da companhia Microsoft; C permanece mais popular no mundo UNIX. Em 1983, o instituto norte-americano de padrões (ANSI) formou um comitê, X3J11, para estabelecer uma especificação do padrão da linguagem C. Após um processo longo e árduo, o padrão foi completo em 1989 e ratificado como ANSI X3.159-1989 “Programming Language C”. Esta versão da linguagem é freqüentemente referida como ANSI C. Em 1990, o padrão ANSI C, após sofrer umas modificações menores, foi adotado pela Organização Internacional de Padrões (ISO) como ISO/IEC 9899:1990, também conhecido como C89 ou C90. Um dos objetivos do processo de padronização ANSI C foi o de produzir um sobreconjunto do K&R C, incorporando muitas das características não-oficiais subseqüentemente introduzidas. Entretanto, muitos programas tinham sido escritos e que não compilavam em certas plataformas, ou com um certo compilador, devido ao uso de bibliotecas de funções não-padrão e ao fato de alguns compiladores não aderirem ao ANSI C.

10.4. C99 Após o processo da padronização ANSI, as especificações da linguagem C permaneceram relativamente estáticas por algum tempo, enquanto que a linguagem C++ continuou a evoluir. (em 1995, a Normative Amendment 1 criou uma versão nova da linguagem C mas esta versão raramente é tida em conta.) Contudo, o padrão foi submetido a uma revisão nos finais da década de 1990, levando à publicação da norma ISO 9899:1999 em 1999. Este padrão é geralmente referido como “C99”. O padrão foi adoptado como um padrão ANSI em Março de 2000. As novas características do C99 incluem:

• funções em linha • remoção de restrições sobre a localização da declaração de variáveis (como em C++) • adição de vários tipos de dados novos, incluindo o long long int (para minimizar

problemas na transição de 32-bits para 64-bits), um tipo de dados boolean explicito (chamado _Bool) e um tipo complex que representa números complexos


Página 43 de 110

• vetores de dados de comprimento variável (o vetor pode ter um tamanho diferente a

cada execução de uma função, mas não cresce depois de criado) • suporte oficial para comentários de uma linha iniciados por //, emprestados da

linguagem C++ • várias funções de biblioteca novas, tais como snprintf() • vários ficheiros-cabeçalho novos, tais como stdint.h

O interesse em suportar as características novas de C99 parece depender muito das entidades. Apesar do GCC e vários outros compiladores suportarem grande parte das novas características do C99, os compiladores mantidos pela Microsoft e pela Borland suportam pouquíssimos recursos do C99, e estas duas companhias não parecem estar muito interessadas em adicionar tais funcionalidades, ignorando por completo as normas internacionais. A Microsoft parece preferir dar mais ênfase ao C++.

10.5. Visão Geral C é uma linguagem imperativa e procedural, para implementação de sistemas. Seus pontos de design foram para ele ser compilado, fornecendo acesso de baixo nível à memória e baixos requerimentos do hardware. Também foi desenvolvido para ser uma linguagem de alto nível, para maior reaproveitamento do código. C foi útil para muitas aplicações que foram codificadas originalmente em Assembly. Essa propriedade não foi acidental; a linguagem C foi criada com o objetivo principal em mente: facilitar a criação de programas extensos com menos erros, recorrendo ao paradigma da programação algorítmica ou procedimental, mas sobrecarregando menos o autor do compilador, cujo trabalho complica-se ao ter de realizar as características complexas da linguagem. Para este fim, a linguagem C possui as seguintes características:

• Uma linguagem nuclear extremamente simples, com funcionalidades não-essenciais, tais como funções matemáticas ou manuseamento de arquivos, fornecida por um conjunto de bibliotecas de rotinas padronizada;

• A focalização no paradigma de programação procedimental; • Um sistema de tipos simples que evita várias operações que não fazem sentido • Uso de uma linguagem de pré-processamento, o pré-processador de C, para tarefas

tais como a definição de macros e a inclusão de múltiplos ficheiros de código fonte; • Ponteiros dão maior flexibilidade à linguagem; • Acesso de baixo-nível, através de inclusões de código Assembly no meio do

programa C;


Página 44 de 110

• Parâmetros que são sempre passados por valor para as funções e nunca por

referência (É possível simular a passagem por referência com o uso de ponteiros); • Definição do alcance lexical de variáveis; • Estruturas de variáveis, (structs), que permitem que dados relacionados sejam

combinados e manipulados como um todo. Algumas características úteis, que faltam em C, podem ser encontradas em outras linguagens, que incluem:

• Segurança de tipo; • Coletor de lixo (mais comum em linguagens interpretadas); • Vetores que crescem automaticamete; • Classes ou objectos com comportamento (ver orientação a objetos); • Closures (a closure is a function that is evaluated in an environment containing one or

more bound variables. When called, the function can access these variables); • Funções aninhadas; • Programação genérica; • Sobrecarga de operadores; • Meta-programação; • Apoio nativo de multithreading e comunicação por rede.

Apesar da lista de características úteis que C não possui, ser longa, isso não tem sido um impedimento à sua aceitação, pois isso permite que novos compiladores de C sejam escritos rapidamente para novas plataformas, e também permite que o programador permaneça sempre em controle do que o programa está a fazer. Isto é o que por várias vezes permite o código de C correr de uma forma mais eficiente que muitas outras linguagens. Tipicamente, só código de assembly “afinado à mão” é que corre mais rapidamente, pois possui um controle completo da máquina, mas avanços na área de compiladores juntamente com uma nova complexidade nos processadores modernos permitiram que a diferença tenha sido rapidamente eliminada. Uma consequência da aceitação geral da linguagem C é que freqüentemente os compiladores, bibliotecas e até intérpretes de outras linguagens de nível maior sejam eles próprios implementados em C. C tem como ponto forte, a sua eficiência, e é a linguagem de programação preferida para o desenvolvimento de sistemas e softwares de base, apesar de também ser usada para desenvolver programas de computador. É também muito usada no ensino de ciência da computação, mesmo não tendo sido projetada para estudantes e apresentando algumas dificuldades no seu uso. Outra característica importante de C, é sua proximidade do código de máquina, que permite que um projetista seja capaz de fazer algumas previsões de como o software irá se comportar, ao ser executado.


Página 45 de 110

C tem como ponto fraco, a falta de proteção que dá ao programador. Praticamente tudo que se expressa em um programa em C, pode ser executado, como por exemplo, pedir o vigésimo membro de um vetor com apenas dez membros. Os resultados são muitas vezes totalmente inesperados, e os erros, difíceis de encontrar.

10.6. Palavras reservadas na Linguagem C A linguagem C é do tipo “case sensitive”. E além disto, algumas palavras são reservadas, sendo seu uso limitado apenas as funções ou comandos que elas executam:

O compilador IAR tem também algumas palavras reservadas, o que veremos ao longo deste treinamento. 11. VARIÁVEIS, TIPOS DE DADOS E OPERADORES EM C

11.1. Tipos de dados Basicamente apenas 5 tipos de dados que são utilizadas em linguagem C:

• char – caractere – 8 bits, 1 byte; • int – inteiro – 16 bits, 2 bytes; • float – ponto flutuante – 32 bits, 4 bytes; • double – ponto flutuante de precisão dupla – 64 bits, 8 bytes; • void – sem valor.

Cada uma destes tipos pode ainda ter os seguintes modificadores:


Página 46 de 110

• signed – utilizará o último bit para sinalizar se um dado é positivo ou negativo. Com

isto, o dado sempre estará com um tamanho menor em um bit. • unsigned – não informa se o dado tem valor positivo ou negativo. Por conseqüência

todos os bits do dado podem ser utilizados como informação; • short – faz com que o dado passe a ter um tamanho menor do que especificado

em sua definição. Por exemplo: utilizar o shot int pode fazê-lo assumir o valor de apenas um bit, dependendo do compilador utilizado;

• long – faz com que o dado passe a ter um tamanho maior do que especificado em sua definição. Por exemplo: utilizar o long int pode fazê-lo assumir o valor de 65536 bits, dependendo do compilador utilizado

11.2. Declarando variáveis É necessário, durante o fluxo do programa, declarar as variáveis que serão utilizadas de acordo com os tipos de dados mostrados anterioremente. Isto pode ser feito das seguintes maneiras: TIPO nome_da_variável {,outras_variáveis};

unsigned int tempo;


Página 47 de 110

As variáveis podem ser inicializadas com um determinado valor durante a sua declaração: unsigned int tempo = 100;

11.2.1. Variáveis locais e globais

Dependendo do local onde é declarada a variável, esta pode assumir uma função global ou local:

• Variáveis globais são acessíveis de qualquer ponto do programa, por qualquer função, e devem ser declaradas no corpo principal do programa, fora de qualquer função, inclusive da main;

• Variáveis locais só podem ser acessadas dentro das funções onde foram criadas. Ao sair desta função, a linguagem C destrói uma variável local e, portanto ela não será acessível por outras funções.

O programa a seguir (E-0-1) dá uma demonstração de como as variáveis podem ser declaradas localmente ou globalmente: //******************************************************************************

// Exemplo de variáveis globais e locais

// Alessandro Ferreira da Cunha

// Tech Training - Engenharia e Treinamentos

// Dezembro 2008 – Extraído do Livro “PIC – Programação em C”, do Fábio Pereira

// Built with IAR Embedded Workbench Version: 4.11.2.9

//******************************************************************************

#include <msp430xG46x.h>

#include <stdio.h>

int somatorio; // VARIÁVEL GLOBAL! SERÁ ACESSADA POR TODAS AS FUNÇÕES

void soma (int valor) //AO ACESSAR ESTA FUNÇÃO, O PARÂMETRO VALOR RECEBE DADOS DE QUEM O CHAMOU

{

int conta; // VARIÁVEL LOCAL! SERÁ ACESSADA APENAS PELA FUNÇÃO SOMA

somatorio = somatorio + valor;

printf("0");

for (conta = 1;(conta<(valor+1));conta++)

{

printf("+%u",conta);

}

printf(" = %u\r\n",somatorio);

}

void main()

{

WDTCTL = WDTPW+WDTHOLD; // Stop WDT

int conta; // VARIÁVEL LOCAL! SERÁ ACESSADA APENAS PELA FUNÇÃO MAIN

somatorio = 0; // A VARIÁVEL GLOBAL É INICIALIZADA

for (conta=1;conta<20;conta++)

{

soma(conta); // É CHAMADA A FUNÇÃO SOMA, ONDE É PASSADO O VALOR DE CONTA

}

}


Página 48 de 110

• c = caractere; • s = string ou caractere; • u = inteiro sem sinal; • x = inteiro em formato hexadecimal com letras minúsculas; • X = inteiro em formato hexadecimal com letras maiúsculas; • d = inteiro decimal com sinal; • i = inteiro decimal com sinal; • o = octal sem sinal; • e = ponto flutuante em formato exponencial; • f = ponto flutuante em formado decimal; • Lx = hexadecimal longo (16 ou 32 bits) com letras minúsculas; • LX = hexadecimal longo (16 ou 32 bits) com letras maiúsculas; • Lu = decimal longo (16 ou 32 bits) sem sinal; • Ld = decimal longo (16 ou 32 bits) com sinal; • % = símbolo de porcentagem;

Para que todos os caracteres a serem impressos na janela Terminal I/O não fiquem na mesma linha, são utilizados os caracteres especiais de barra invertida, que são:

Alguns comentários importantes sobre o programa E-0-1:

• O comando printf chama uma biblioteca que fará o envio de dados pela porta serial do MSP430. No IAR será possível visualizar estes dados através do Terminal I/O, acessível em: View Terminal I/O, onde será aberta a janela mostrada ao lado. Para que ele funcione é necessário incluir a biblioteca padrão stdio.h

O formato do comando printf é:

printf (string, variável);

printf (“O número de tentativas foi %d”, contador);

Onde:

• string: é uma constate de caracteres, sempre declarado entre aspas;

• variável: é a declaração de uma ou mais variáveis que devem ser impressas juntamente com os caracteres. Para tanto é necessário seguir a formatação %wt, onde w é o número de caracteres que se deseja imprimir e t é uma das seguintes opções:

MATERIAL AUXILIAR PARA CURSO AVANÇADO I MSP430

Documents

Transcript of MATERIAL AUXILIAR PARA CURSO AVANÇADO I MSP430