Você está na página 1de 33

DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?

q=msp430

Compartilhar Denunciar abuso Próximo blog» Criar um blog Login

DQSoft
Ruminações de um "Old Timer" sobre software e hardware

Segunda-feira, Julho 20, 2009


Lunar Lander
Quando eu estava preparando o meu post sobre como controlar muitos LEDs, e
pensando num exemplo de displays de sete segmentos, me veio uma vaga ideia de
fazer uma versão de um antigo joguinho de pouso na lua (da infância dos micros
Receba o Feed pessoais). A ideia conceitual era a seguinte:

Postagens

Categorias
Acessórios (6)
ARM (5)
AutoID (20)
Avaliação (42)
Banco de Dados (3)
Blog (21)
C# (5)
Certificação (8)
Competições (22)
Criptografia (3)
DVD (8) Há pouco mais de duas semanas foi que me dei conta que no dia 20 de julho era
Ferramentas (28) aniversário de 40 anos do pouso na Lua. Resolvi então fazer uma primeira versão
google (10) para a data. O prazo curto me obrigou a adotar algumas simplificações e usar os
Gráficos (1) componentes que tinha à mão, mesmo quando não eram os mais adequados.
Hardware (70)
HQ (10)
O tosco resultado final foi o seguinte:
Humor (4)
Jogos (19)
Linguagens (19)
Links (4)
Linux (4)
Listas (5)
Livros (49)
Microsoft (48)
Música (28)
Outros (57)
Portáteis (4)
Processadores (56)
Programação (148)
Protocolos (6)
Segurança (10)
Vida Digital (35)
Video (3)

Arquivo do blog O Jogo


► 2010 (19)
▼ 2009 (178) O jogo Lunar Lander consiste em pousar suavemente uma espaçonave na Lua,
► Dezembro (16) controlando a queima do pouco combustível disponível.

1 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

► Novembro (8)
► Outubro (17) Procurando nos tubos da internet, achei uma versão extremamente legível, apesar
► Setembro (21) de estar em uma linguagem que não conheço: http://eleven.sourceforge.net
► Agosto (20) /demo/lander.html. Esta versão se baseia em programas escritos em BASIC por
▼ Julho (18) Dave Ahl (que eu conhecia dos anos 80, quando comprava a revista Creative
Compactação - Parte 3 Computing). As versões de DaveAhl estão disponíveis aqui.
Falhas de Segurança em
Biblioteca Microsoft Eu segui bem de perto a versão em Eleven, deixando de lado aperfeiçoamentos
Requer... como variar a massa da nave à medida em que o combustível é queimado. Adotei
Detalhes da Proposta da também os mesmos valores; futuramente vou dar uma ajustada.
Microsoft à EC
Microsoft Cede e Oferecerá
O Algorítimo
Lista de Browsers
Preparação e Metas para o
Google Code Jam 2009
O algorítimo é trivial, com velocidade e posição sendo calculados
Google Code Jam 2009
incrementalmente:
Lunar Lander - The Real Thing
a aceleração da nave é a gravidade menos a queima de combustível.
Lunar Lander
a nova velocidade é a velocidade atual mais a aceleração vezes o tempo.
Outras Opções de Compra de
a nova altitude é a média entre a velocidade atual e a nova vezes o tempo.
Componentes via Interne...
JavaScript Should Be
Sendo o tempo entre os cálculos fixos, basta acertar as escalas para fazer as
Considered Harmfull?
contas usando somente soma e subtração.
Compactação - Parte 2
Assista a Palestras de Richard
Feynman
O Display
Compactação - Parte 1
DVD: Jackie Brown
Usei quatro displays duplos de sete segmentos que eu tinha guardado desde o final
Netbooks, Sub-notebooks,
dos anos 70. Cada display possui 18 pinos, correspondentes aos anodos dos oitos
Network Computer e o LEDs (sete segmentos mais o ponto) e o catodo comum aos LEDs de cada dígito.
Goog...
Controlando MUITOS Leds Os segmentos iguais dos dígitos foram interligados entre si e conectados, através
Windows Vista: Divagações de um resistor, às saídas de um shift register 74HC595. A seleção do dígito é feita
Sobre Um Não-Desastre por um decodificador 3-para-8 (inicialmente um 74LS138 e depois um 74HC138), que
Virus Paraliza DQSoft por Uma aciona um transistor conectado ao catodo. Eu aproveitei uns transistores antigos
Semana! que eu tinha, mas esta parte não ficou boa; o resultado foi um brilho fraco do
► Junho (12) display. Faltou tempo e coragem para rever esta parte do circuito.
► Maio (15)
► Abril (15) Montei o display em uma placa separada, para maior flexibilidade:
► Março (9)
► Fevereiro (12)
► Janeiro (15)
► 2008 (132)
► 2007 (67)
► 2006 (68)
► 2005 (12)

Quem sou eu
Daniel Quadros

As conexões foram feitas com fio de wire-wrap soldado, o que deu bem mais
trabalho que eu previa. O resultado é ligeiramente assustador, e o motivo pelo
qual eu não tentei trocar os transistores:
Contato
Visualizar meu perfil completo

Minha lista de
blogs
Geringonças e Gambiarras
Como saber se o hardware

2 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

do seu PC é compatível com


HDCP.
18 horas atrás
O conector na parte de baixo recebe
Efetividade.net
Multifuncional wireless HP
a alimentação
C4780: impressão sem fio,
scanner e copiadora os três sinais de seleção de dígito
3 dias atrás os quatro sinais de controle do shift register (dado, clock de shift, clock de
cópia do shift para a saída e o clear do shift)
Caloni.com.br
Restauranto o registro
3 dias atrás
Um primeiro teste, acionando os sinais por meio de botões, permitiu corrigir os
pequenos erros de montagem.
Os Cientistas
O início
6 meses atrás
O Microcontrolador

Estou Lendo Devido ao uso do 74LS138 o display exigia 5V o que dificultava o uso do MSP430 (já
troquei por um 74HC138 para algum dia operar com 3V). Por este motivo resolvi
usar um PIC 16F628A (uma escolha mal pensada, como veremos adiante). Esta
parte foi montada numa breadboard.

O PIC é o integrado no alto, próximo ao centro. A peça marrom claro à esquerda é


um ressonador de 4MHz, que fornece o clock para o PIC. O LED foi usado
inicialmente para testes. Na parte inferior estão o botão para acionar o
retrofoguete e o potenciômetro que controla a quantidade de combustível a
Seguidores queimar por unidade de tempo. O conector de telefone, no alto à direita permite
ligar o gravador para regravar o firmware sem retirar o PIC do circuito (ainda bem,
Seguir pois foram algumas dezenas de gravações).
Google Friend Connect

Seguidores (23) Tudo correu bem, até o momento de ligar o potenciômetro. Foi neste ponto que
percebi que este modelo de PIC não tem ADC (conversor Analógico para Decimal).
Por outro lado, ele tem um comparador analógico e uma fonte de referência
programável, o jeito foi ficar variando a referência e detectar quando ela ela
ultrapassa a tensão no potenciômetro.

O comparador deste PIC é muito pouco flexível. A única opção para usar a
referência interna obriga a usar dois comparadores, consumindo dois pinos do PIC.
Após realocar os pinos de E/S tudo parou de funcionar. Lendo com mais atenção a
documentação do PIC, descobri que um dos pinos de E/S tem comportamento
diferente dos demais. Era justo neste pino que eu tinha ligado o sinal de Clear do
shift register, resultando em um display sempre apagado. Além disso, parece que o
comparador ocupa não somente os dois pinos configurados como entrada mas
também os outros dois que podem ser configurados como entrada (preciso
Visitas investigar um pouco mais). Com o prazo e os pinos acabando, movi dois sinais para
os pinos de programação. Felizmente as duas funções conviveram
harmoniosamente.

O Firmware

3 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Como está virando rotina nos meus projetos até agora, o coração do firmware é a
interrupção do timer, que ocorre a cada milissegundo. Neste interrupção são
feitos:
Reprodução
A atualização da altitude, velocidade e combustível. Seguindo os números
do programa que tomei como base, a atualização deveria ser a cada 10
A reprodução deste material é milissegundos. Para ficar mais fácil de acompanhar os números, dobrei este
governada pela Creative tempo (ou seja, o jogador trabalho com o sistema em "slow motion"). Todos
Commons Attribution 2.5 os valores são inteiros; a altitude é um inteiro de 32 bits e os demais de 16
Brazil License. bits.
A leitura do comparador e reprogramação da tensão de referência para
acompanhar o potenciômetro. Para minha surpresa, este código funcionou
quase que de primeira. Por simplificação o potenciômetro seleciona apenas
cinco níveis de queima (0, 25%, 50%, 75% e 100% da taxa de queima máxima).
A atualização dos segmentos a apresentar. Para isto é preciso converter os
valores inteiros nos dígitos correspondentes, o que requer divisão.
Entretanto as divisões são demoradas demais para ficar na interrupção. O
jeito foi a cada 100 milissegundos a interrupção acionar um flag para que o
programa principal faça as cálculos. Ao final dos cálculos o programa
principal acionar um flag para a próxima interrupção usar o resultado. Os
segmentos são armazenados em 8 bytes, com cada byte correspondendo a
um dígito do display e cada bit a um segmento. Uma tabela auxiliar contém
os valores correspondentes a cada dígito.
A varredura dos dígitos. A cada 3 milissegundos é selecionado o dígito
seguinte e carregado o shift register com o valor correspondente aos seus
segmentos.

Resultado Final

O Lunar Lander Mark I está funcionando! Falta vários acertos, tanto de hardware
(como melhorar a luminosidade) como de software (como tratar o caso da
velocidade ficar negativa), mas já dá para brincar.

Mais para frente, quando tiver um resultado um pouco melhor, eu publico o


circuito e o código.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Programação

Sábado, Junho 13, 2009


Spoke-o-dometer - Parte 9
Este post e os dois seguintes concluem esta série sobre um velocímetro que vai
montado diretamente no aro da bicicleta e apresenta mensagens se valendo da
persistência da visão. Neste post vou mostrar o hardware e o código final; no post

4 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

seguinte vou explicar a programação dos periféricos do microcontrolador e no


último explicar a lógica usada para calcular e apresentar a velocidade.

O Hardware

O projeto de hardware resistiu inalterado desde o começo. Repetindo o circuito


(clique para ampliar):

A foto abaixo mostra a montagem:

O Software

Segue abaixo a listagem completa do software, que vou explicar nos post
seguintes.

5 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

view plain copy to clipboard print ?

01. /*
02. Spoke-o-dometer
03. Teste 5 - Versão Completa
04.
05. Daniel & Flávio Quadros - abril/junho, 2009
06. */
07.
08. #include <msp430.h>
09.
10. // Constantes lógicas
11. #define FALSE 0
12. #define TRUE 1
13.
14. // Tipo byte
15. typedef unsigned char byte;
16.
17. // Circunferência aprox. da roda em milimetros
18. #define CIRCUNF 2090L
19.
20. // Valor para contar 100us c/ clock de 1MHz
21. #define TEMPO_100uS 99 // (100us * 1MHz) - 1
22.
23. // Gerador de Caracteres
24. // Cada caracter corresponde a 5 bytes
25. // Cada byte corresponde a uma coluna
26. static const byte gc[16][5] =
27. {
28. 0x7C, 0x82, 0x82, 0x82, 0x7C, // 0
29. 0x02, 0x42, 0xFE, 0x02, 0x02, // 1
30. 0x46, 0x8A, 0x92, 0xA2, 0x42, // 2
31. 0x44, 0x82, 0x92, 0x92, 0x6C, // 3
32. 0xF0, 0x10, 0x10, 0x10, 0xFE, // 4
33. 0xF2, 0x92, 0x92, 0x92, 0x8C, // 5
34. 0x6C, 0x92, 0x92, 0x92, 0x0C, // 6
35. 0x80, 0x86, 0x98, 0xA0, 0xC0, // 7
36. 0x6C, 0x92, 0x92, 0x92, 0x6C, // 8
37. 0x60, 0x92, 0x92, 0x92, 0x6C, // 9
38. 0x00, 0x00, 0x00, 0x00, 0x00, // SPACE (10)
39. 0x00, 0x04, 0x06, 0x00, 0x00, // , (11)
40. 0x7E, 0x08, 0x14, 0x22, 0x00, // k (12)
41. 0x1E, 0x10, 0x0C, 0x10, 0x1E, // m (13)
42. 0x03, 0x0C, 0x18, 0x30, 0x60, // / (14)
43. 0x7E, 0x08, 0x08, 0x06, 0x00 // h (15)
44. };
45.
46. #define CHAR_SPACE 10;
47. #define CHAR_COMMA 11;
48. #define CHAR_K 12;
49. #define CHAR_M 13;
50. #define CHAR_SLASH 14;
51. #define CHAR_H 15;
52.
53.
54. // Limites para detectar passagem pelo ímã
55. #define VREPOUSO 88 // 01011000
56. #define VPOS_1 120 // 01111000
57. #define VPOS_2 100 // 01111000
58. #define VNEG_1 56 // 00111000
59. #define VNEG_2 76 // 00111000
60.
61. static byte bAmostrando = FALSE; // TRUE enquanto agu
arda ADC
62. static byte bDetectou = FALSE; // TRUE qdo detecta
o imã
63.
64.
65. // Contagem do tempo de uma volta e
66. // controle da escrita da mensagem
67.
68. #define NFRAMES 360 // frames por volta

69. #define POS_MSG 45 // inicio da mensage


m
70. #define SPACE 3 // frames de espaço
entre letras

6 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

O Resultado

O vídeo abaixo mostra o Spoke-o-dometer em funcionamento:

Posted by Daniel Quadros at 12:00 0 comentário(s)


Categorias: Hardware, Programação

Quarta-feira, Junho 10, 2009


Spoke-o-dometer - Parte 8
Tendo passado mais de um mês desde o post anterior da série, me parece
apropriado dar alguma notícia. Mais que o bug no compilador, falta de tempo e
foco é o que impediu de concluir este projeto.

O meu filho avançou no código, colocando o cálculo e a apresentação da


velocidade em km/h. Durante esta mexida dele, deu para perceber algumas
limitações e erros do código apresentado anteriormente.

O código é movido a uma interrupção periódica de timer, que era gerada a partir
de um clock interno de 12KHz. O primeiro problema é que eu estava calculando
errado o valor de contagem (TEMPO_xxx). Após detectar divergência com uma
leitura de velocidade na base do cronometro, revi com atenção a documentação
do MSP430 e percebi que ele conta um a mais que o valor programado. Assim, uma
contagem de 6 gera uma temporização de 583 useg ao invés de 500 useg.

Um problema mais crítico é que à medida que a velocidade sobe temos menos
ticks por volta. Na hora de dividir a volta em "frames" a imprecisão aumenta,
fazendo a largura dos caracteres variarem. A solução para isto vai ser usar um
clock mais alto; isto aumentará o consumo do circuito mas dará uma precisão
muito maior. Isto exige rever a programação do hardware e fazer alguns cálculos
para garantir que os números vão caber nas variáveis.

Por último, estou usando o tempo de uma volta para apresentar a mensagem na
volta seguinte, o que causa problemas quando estamos acelerando ou freando.
Para melhorar isto pretendo considerar também a variação de tempos de uma
volta para outra.

Tudo isto exige algum estudo, mexidas no código e testes. Estou contando com o
feriado desta semana para chegar a uma versão "final", que vou publicar junto com
uma tentativa mais decente de explicar o funcionamento do código.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Programação

7 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Quarta-feira, Maio 06, 2009


Spoke-o-dometer - Parte 7
Continuando a nossa série, vamos ver se conseguimos mostrar alguns caracteres
com o circuito. Neste ponto vou tentar mostrar apenas números.

O Gerador de Caracteres

Lembrando, o nosso circuito possui 7 LEDs que correspondem a uma coluna no


nosso gerador de caracteres. Optei pelo formato 5x7 (5 colunas x 7 linhas) para a
matriz de caracteres, que era bastante tradicional nos primeiros terminais de
vídeos e assemelhados.

A figura abaixo mostra os desenhos que fiz para os dígitos:

No meu circuito, os LEDs correspondem (de cima para baixo) a P2.7, P2.6, P1.5,
P1.4, P1.3, P1.2 e P1.1. Isto facilita guardar cada coluna em um byte, seguindo a
mesma ordem de bits:

view plain copy to clipboard print ?

01. static const byte gc[10][5] =


02. {
03. 0x7C, 0x82, 0x82, 0x82, 0x7C, // 0
04. 0x02, 0x42, 0xFE, 0x02, 0x02, // 1
05. 0x46, 0x8A, 0x92, 0xA2, 0x42, // 2
06. 0x44, 0x82, 0x92, 0x92, 0x6C, // 3
07. 0xF0, 0x10, 0x10, 0x10, 0xFE, // 4
08. 0xF2, 0x92, 0x92, 0x92, 0x8C, // 5
09. 0x6C, 0x92, 0x92, 0x92, 0x0C, // 6
10. 0x80, 0x86, 0x98, 0xA0, 0xC0, // 7
11. 0x6C, 0x92, 0x92, 0x92, 0x6C, // 8
12. 0x60, 0x92, 0x92, 0x92, 0x6C // 9
13. };

Timing

Neste teste, resolvi aumentar o clock via DCO para 8MHz e usar uma interrupção
periódica a cada 0,5 ms (o meu tick). A rotina de interrupção conta os ticks entre
as detecções do imã (ou seja, mede o tempo de uma volta). Esta contagem é
dividida em 360 frames (360 para ficar fácil pensar em graus). Cada coluna de
caracter é apresentada por um frame; após cada caracter os LEDs ficam apagados
por 3 frames, para dar uma separação entre os caracteres.

Os LEDs ficam também apagados nos 45 frames após o imã (para colocar a imagem
numa posição fora do quadro) e ao final da mensagem.

Uma última complicação é que na posição em que eu montei os caracteres


precisam ser escritos de "trás para frente" (da última coluna do último caracter
para a primeira coluna do primeiro caracter). Por simplificação a "mensagem" é
fixa e deverá já estar com os caracteres em ordem invertida (mais exatamente, a
mensagem é "9876543210" o que aparece no programa como "0123456789".

O Código

O código nesta etapa ficou assim:

8 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

view plain copy to clipboard print ?

01. /*
02. Spoke-o-dometer
03. Teste3 - Teste de Display
04.
05. Daniel Quadros - abril, 2009
06. */
07.
08. #include <msp430.h>
09.
10. // Valor para contar 500us c/ clock de 12KHz
11. #define TEMPO_500uS 6 // 0,5ms * 12KHz
12.
13. // Limites para detectar passagem pelo imã
14. #define VREPOUSO 88 // 01011000
15. #define VPOS_1 120 // 01111000
16. #define VPOS_2 100 // 01111000
17. #define VNEG_1 56 // 00111000
18. #define VNEG_2 76 // 00111000
19.
20. #define FALSE 0
21. #define TRUE 1
22.
23. typedef unsigned char byte;
24.
25. // Gerador de Caracter (versão numérica)
26. // Cada caracter corresponde a 5 bytes
27. // Cada byte corresponde a uma coluna
28. static const byte gc[10][5] =
29. {
30. 0x7C, 0x82, 0x82, 0x82, 0x7C, // 0
31. 0x02, 0x42, 0xFE, 0x02, 0x02, // 1
32. 0x46, 0x8A, 0x92, 0xA2, 0x42, // 2
33. 0x44, 0x82, 0x92, 0x92, 0x6C, // 3
34. 0xF0, 0x10, 0x10, 0x10, 0xFE, // 4
35. 0xF2, 0x92, 0x92, 0x92, 0x8C, // 5
36. 0x6C, 0x92, 0x92, 0x92, 0x0C, // 6
37. 0x80, 0x86, 0x98, 0xA0, 0xC0, // 7
38. 0x6C, 0x92, 0x92, 0x92, 0x6C, // 8
39. 0x60, 0x92, 0x92, 0x92, 0x6C // 9
40. };
41.
42. static byte bDetectou = FALSE; // TRUE qdo detecta o imã
43.
44. static unsigned long tickVolta;
45. static unsigned long tickFrame = 0;
46. static unsigned long contFrame;
47. static byte col;
48. char *pMsg;
49.
50. #define NFRAMES 360
51. #define POS 45
52. #define SPACE 3
53.
54.
55.
56. // Programa Principal
57. void main (void)
58. {
59. unsigned int cont = 0;
60.
61. // Desliga Watchdog
62. WDTCTL = WDTPW + WDTSSEL + WDTHOLD;
63.
64. // Altera a configuração de clock para ativar o VLOCLK
65. BCSCTL3 |= LFXT1S1;
66.
67. // Programa entradas e saídas
68. P1SEL = 0xC0; // P1.0 a P1.5 -> LEDs
69. // P1.6 e P1.7 são A3+ e A3-
70. P1DIR = 0x3F;
71. P1OUT = 0; // Todos as saídas em zero
72.
73. P2SEL = 0; // Todos os pinos como I/O
74. P2DIR = 0xFF; // Todos os pinos como saída
75. P2OUT = 0; // Todos as saídas em zero

9 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

O Resultado

Ainda está longe do que eu espero chegar, mas o vídeo abaixo é uma bela "prova
de conceito".

Posted by Daniel Quadros at 07:00 2 comentário(s)


Categorias: Hardware, Processadores, Programação

Sexta-feira, Abril 24, 2009


Spoke-o-dometer - Parte 6
Nesta parte vamos testar o circuito na roda de uma bicicleta. Mas antes vamos
usar as informações do teste anterior para codificar a detecção de imã.

Detectando o Imã

Relembrando, o sensor usado fornece uma tensão proporcional ao campo


magnético a que é submetido. Longe do imã, temos uma tensão de 4.5/2 V. À
medida que o sensor se aproximar de um imã esta tensão irá baixar ou subir,
dependendo do polo. Pelo teste anterior, a leitura do SD16 com o sensor longe do
imã é de 88 (considerando somente o byte mais significativo do resultado).

Uma primeira ideia seria usar um limite único para detectar o imã. Por exemplo,
considerar que quando o valor passar de 110 estamos próximos do imã. Entretanto,
é provável que as leituras oscilem o que poderia causar uma sequência de
detecções em uma única passagem pelo imã.

O mais seguro é colocar uma histerese no teste. Por exemplo, considerar que
estamos próximos do imã quando o valor passar de 120 e só voltar a considerar que
estamos longe quando o valor cair abaixo de 100. Desta forma, mesmo que o valor
passe de 120, baixe para 110 e depois volte para 120 consideramos uma única
detecção.

Para ficarmos independentes da polaridade do imã, usamos também dois valores


abaixo do de repouso (neste teste, vamos detectar o imã quando o valor ficar
abaixo de 56 e considerar que nos afastamos dele quando o valor ficar acima de
76).

Fixando o Circuito e o Imã

O circuito é fixado na válvula do pneu. A posição do imã é relativamente crítica,


neste teste ele ficou preso ao freio.

10 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

O imã é o "botão" metálico na parte inferior central da foto. As pilhas (que não
aprecem na foto), estão diametralmente opostas ao circuito porém mais próximas
do centro.

O Software de Teste

O software de teste implementa a histerese mencionada acima. A cada detecção é


incrementado um contador, que é apresentado nos LEDs.

11 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

view plain copy to clipboard print ?

01. /*
02. Spoke-o-dometer
03. Teste3 - Teste do sensor em movimento
04.
05. Daniel Quadros - abril, 2009
06. */
07.
08. #include <msp430.h>
09.
10. // Valor para contar 1ms c/ clock de 12KHz
11. #define TEMPO_1MS 12 // 1ms * 12KHz
12.
13. // Limites para detectar passagem pelo imã
14. #define VREPOUSO 88 // 01011000
15. #define VPOS_1 120 // 01111000
16. #define VPOS_2 100 // 01111000
17. #define VNEG_1 56 // 00111000
18. #define VNEG_2 76 // 00111000
19.
20. #define FALSE 0
21. #define TRUE 1
22.
23. typedef unsigned char byte;
24.
25. static byte bDetectou = FALSE; // TRUE qdo detecta o imã
26. static unsigned int cont = 0;
27.
28. // Rotinas Locais
29. static void Led (unsigned int valor);
30.
31. // Programa Principal
32. void main (void)
33. {
34. // Desliga Watchdog
35. WDTCTL = WDTPW + WDTSSEL + WDTHOLD;
36.
37. // Altera a configuração de clock para ativar o VLOCLK
38. BCSCTL3 |= LFXT1S1;
39.
40. // Programa entradas e saídas
41. P1SEL = 0xC0; // P1.0 a P1.5 -> LEDs
42. // P1.6 e P1.7 são A3+ e A3-
43. P1DIR = 0x3F;
44. P1OUT = 0; // Todos as saídas em zero
45.
46. P2SEL = 0; // Todos os pinos como I/O
47. P2DIR = 0xFF; // Todos os pinos como saída
48. P2OUT = 0; // Todos as saídas em zero
49.
50. // Programa o ADC
51. // MSP430F2013 -> SD16
52. SD16CTL = SD16VMIDON + SD16REFON + SD16SSEL_1; // 1.2V re
f, SMCLK
53. SD16INCTL0 = SD16INCH_3; // PGA = 1
x, Diff inputs A3- & A3+
54. SD16CCTL0 = SD16SNGL + SD16UNI + SD16IE; // Single
conversion, Unipolar, 256 SR, Int enable
55. SD16CTL &= ~SD16VMIDON; // VMID of
f: used to settle ref cap
56. SD16AE = SD16AE6 + SD16AE7; // P1.6 &
P1.7: A3+/- SD16_A inputs
57.
58. // Dá um tempinho para estabilizar a alimentação
59. while (cont < 0xFF)
60. cont++;
61. cont = 0;
62.
63. // Alimentação já deve estar estável, vamos ligar o DCO
64. BCSCTL1 = CALBC1_1MHZ;
65. DCOCTL = CALDCO_1MHZ;
66.
67. // Programar a interrupção de tempo real p/ cada 10ms
68. TACCR0 = TEMPO_1MS;
69. TACTL = TASSEL_1 + MC_1 + TAIE; // ACLK, up mode, interrup
t

12 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Para finalizar, o vídeo abaixo mostra o teste em ação:

Na próxima parte (se tudo correr bem) vamos começar a mostrar mensagens.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Quarta-feira, Abril 22, 2009


Spoke-o-dometer - Parte 5
Nesta parte vamos testar o sensor. Para isto vamos examinar um pouco como
funcionam o sensor e o conversor analógico SD16_A do MSP430. E, é claro, ver o
código.

O Efeito Hall

O efeito Hall é o surgimento de uma diferença de pontecial elétrico em um


condutor elétrico, transversa a uma corrente elétrica no condutor e a campo
magnético perpendicular à corrente (tradução minha para a introdução em inglês
de http://en.wikipedia.org/wiki/Hall_effect).

Simplificando, se pegamos um condutor elétrico alimentado por uma fonte e o


submetemos a um campo magnético, surge no condutor uma diferença de
potencial entre as bordas perpendiculares à corrente e ao campo magnético.

Sensor de Efeito Hall

O sensor de efeito Hall utiliza o efeito Hall descrito acima em um semicondutor


para detectar um campo magnético. Em alguns sensores, como o que estou usando,
obtem-se uma tensão proporcional ao campo magnético. Em outros obtem-se
apenas uma indicação de presença ou ausência do campo magnético (o que
bastaria para o meu projeto).

Alguns detalhes adicionais podem ser vistos (em inglês) na wikipedia (em
http://en.wikipedia.org/wiki/Hall_effect_sensor); tem uma animação bonitinha.

O ADC SD16_A

Como descrito (para variar) na Wikipedia inglesa (http://en.wikipedia.org


/wiki/Analog-to-digital_converter#ADC_structures) existem várias formas de
implementar um Conversor Anaógico Digital (ADC). O objetivo é sempre fornecer
um número proporcional a uma tensão.

O funcionamento de um ADC usando modulação Sigma Delta pode ser visto (em
inglês) em http://en.wikipedia.org/wiki/Sigma-

13 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

delta_modulation#Analog_to_Digital_Conversion. Se eu entendi direito, a tensão de


entrada (sinal analógico) é usada para gerar pulsos de largura constante espaçados
por um tempo proporcional à tensão de entrada (esta é a parte delta). Estes pulsos
são contados em um tempo fixo (esta é a parte sigma), fornecendo assim um valor
digital proporcional à tensão de entrada. Isto permite construir ADCs com precisão
muito boa (o que não deixa de ser um desperdício para o meu projeto).

A programação do SD16_A do MSP430F2113 pode ser encontrada no MSP430x2xx


Family User's Guide. Eu me basei no Application Note SLAA283A (que você pode
baixar daqui).

A programação é feita escrevendo em quatro registradores do SD16_A:

SD16CTL: aqui selecionamos o clock e areferência. No nosso caso vamos


usar como clock o SMCLK que virá do DCO. Como o limite do SD16_A é
1.1MHz, segui o Application Note e usei o DCO a 1MHz sem divisão. A
referência que vamos usar é a interna (1.2V). Seguindo a recomendação do
fabricante, o VMID buffer é ligado e pouco depois desligado para estabilizar
o capacitor da referência.
SD16INCTL0: controle da entrada. Mantemos o default de esperar quatro
amostragens antes de interromper, usamos um ganho de 1 e escolhemos a
entrada A3.
SD16CCTL0: outro registrador de controle. Selecionamos o modo Single
onde se dispara uma conversão e uma interrupção é gerada quando a
conversão foi completada (a interrupção também é habilitada neste
registrador). Pedimos o resultado na forma Unipolar, onde o resultado é um
valor de 0 a 0xFFFF. Por último, usamos uma taxa de oversampling de 256.
SD16AE: Habilita os pinos de entrada analógica (no nosso caos, P1.6 e P1.7).

Feita a programação, para fazer uma leitura do sinal analógico entre os pinos P1.6
e P1.7, basta iniciar uma conversão e aguardar a interrupção (não esquecendo de
manter o DCO e SMCLK rodando). Quando a interrupção ocorrer, o resultado está
em SD16MEM0.

O Programa de Teste

O programa de teste usa os LEDs para mostrar (em binário) a tensão na saída do
sensor. Para testar o sensor basta aproximar ou afastar um imã e observar o valor
nos LEDs. Aproveitando a idéia da Application Note, o programa economia energia
deixando o clock e a referência ligados somente enquanto efetua uma conversão.

14 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

view plain copy to clipboard print ?

01. /*
02. Spoke-o-dometer
03. Teste1 - teste do sensor
04.
05. Daniel Quadros - abril, 2009
06. */
07.
08. #include <msp430.h>
09.
10. // Valor para contar 100ms c/ clock de 12KHz
11. #define TEMPO_100MS 1200 // 100ms * 12KHz
12.
13. typedef unsigned char byte;
14.
15. // Rotinas Locais
16. static void Led (unsigned int valor);
17.
18. // Programa Principal
19. void main (void)
20. {
21. int cont = 0;
22.
23. // Desliga Watchdog
24. WDTCTL = WDTPW + WDTSSEL + WDTHOLD;
25.
26. // Altera a configuração de clock para ativar o VLOCLK
27. BCSCTL3 |= LFXT1S1;
28.
29. // Programa entradas e saídas
30. P1SEL = 0xC0; // P1.0 a P1.5 -> LEDs
31. // P1.6 e P1.7 são A3+ e A3-

32. P1DIR = 0x3F;


33. P1OUT = 0; // Todos as saídas em zero
34.
35. P2SEL = 0; // Todos os pinos como I/O
36. P2DIR = 0xFF; // Todos os pinos como saída

37. P2OUT = 0; // Todos as saídas em zero


38.
39. // Programa o ADC
40. // MSP430F2013 -> SD16
41. SD16CTL = SD16VMIDON + SD16REFON + SD16SSEL_1; // 1.2V r
ef, SMCLK
42. SD16INCTL0 = SD16INCH_3; // PGA =
1x, Diff inputs A3- & A3+
43. SD16CCTL0 = SD16SNGL + SD16UNI + SD16IE; // Single
conversion, Unipolar, 256 SR, Int enable
44. SD16CTL &= ~SD16VMIDON; // VMID o
ff: used to settle ref cap
45. SD16AE = SD16AE6 + SD16AE7; // P1.6 &
P1.7: A3+/- SD16_A inputs
46.
47. // Dá um tempinho para estabilizar a alimentação
48. while (cont < 0xFF)
49. cont++;
50.
51. // Alimentação já deve estar estável, vamos ligar o DCO
52. BCSCTL1 = CALBC1_1MHZ;
53. DCOCTL = CALDCO_1MHZ;
54.
55. // Programar a interrupção de tempo real p/ cada 100ms
56. TACCR0 = TEMPO_100MS;
57. TACTL = TASSEL_1 + MC_1 + TAIE; // ACLK, up mode, interru
pt
58.
59. // O nosso programa principal vai ficar dormindo,
60. // todo o tratamento será feito na interrupção
61. _BIS_SR(LPM3_bits + GIE); // Dorme tratando interr
upção
62.
63. // Nuca vai chegar aqui
64. while (1)
65. ;
66. }

15 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

No próximo post vamos prender o nosso circuito à roda da bicicleta e ver o


funcionamento do sensor em uma situação mais real.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Segunda-feira, Abril 20, 2009


Spoke-o-dometer - Parte 4
Feita a montagem do circuito, é hora de um primeiro teste. O objetivo deste teste
e verificar que o microcontrolador está rodando e que os LEDs foram ligados
corretamente.

O código (compilado com o IAR) é simples:

16 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

view plain copy to clipboard print ?

01. /*
02. Spoke-o-dometer
03. Teste1 - teste dos LEDs
04.
05. Daniel Quadros - abril, 2009
06. */
07.
08. #include <msp430.h>
09.
10. // Valor para contar 200ms c/ clock de 12KHz
11. #define TEMPO_200MS 2400 // 200ms * 12KHz
12.
13. typedef unsigned char byte;
14.
15. static int iLed; // indica qual LED piscar
16.
17. // Rotinas Locais
18. static void Led (int iLed, int valor);
19.
20. // Programa Principal
21. void main (void)
22. {
23. int cont = 0;
24.
25. // Desliga Watchdog
26. WDTCTL = WDTPW + WDTSSEL + WDTHOLD;
27.
28. // Altera a configuração de clock para ativar o VLOCLK
29. BCSCTL3 |= LFXT1S1;
30.
31. // Programa entradas e saídas
32. P1SEL = 0xC0; // P1.0 a P1.5 -> LEDs
33. // P1.6 e P1.7 são A3+ e A3-
34. P1DIR = 0x3F;
35. P1OUT = 0; // Todos as saídas em zero
36.
37. P2SEL = 0; // Todos os pinos como I/O
38. P2DIR = 0xFF; // Todos os pinos como saída
39. P2OUT = 0; // Todos as saídas em zero
40.
41. // Inicia os nossos controles
42. iLed = 0;
43.
44. // Dá um tempinho para estabilizar a alimentação
45. while (cont < 0xFF)
46. cont++;
47.
48. // Alimentação já deve estar estável, vamos ligar o DCO
49. BCSCTL1 = CALBC1_12MHZ;
50. DCOCTL = CALDCO_12MHZ;
51.
52. // Programar a interrupção de tempo real p/ cada 200ms
53. TACCR0 = TEMPO_200MS;
54. TACTL = TASSEL_1 + MC_1 + TAIE; // ACLK, up mode, interrup
t
55.
56. // O nosso programa principal vai ficar dormindo,
57. // todo o tratamento será feito na interrupção
58. _BIS_SR(LPM3_bits + GIE); // Dorme tratando interrupçã
o
59.
60. // Nuca vai chegar aqui
61. while (1)
62. ;
63. }
64.
65. // Tratamento da interrupção do Timer A
66. #pragma vector=TIMERA1_VECTOR
67. __interrupt void Timer_A_TO(void)
68. {
69. switch (TAIV)
70. {
71. case 10: // overflow
72. Led (iLed, 0); // apaga LED anterior
73. iLed = (iLed+1) & 7; // passa para o seguinte

17 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

O vídeo abaixo mostra o resultado (depois que corrigi as besteiras que eu fiz):

No próximo post, o primeiro teste do sensor.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Quarta-feira, Abril 15, 2009


Spoke-o-dometer - Parte 2
Nesta segunda parte vou começara a falar do hardware do meu Spoke-o-dometer.
Me baseei fortemente no que está descrito em http://www.openobject.org
/opensourceurbanism/Spoke-o-dometer_Overview.

O Sensor

O sensor será usado para detectar quando o circuito (que está preso à roda) passar
por um determinado ponto. Isto permite tanto determinar a velocidade da roda
(medindo o tempo de cada volta) como posicionar a mensagem (medindo o tempo
a partir da detecção feita pelo sensor).

Eu já tinha pesquisado este tipo de sensor quando comecei o meu projeto


(inacabado) de velocímetro e comprado alguns sensores de efeito Hall modelo
A1321 da Allegro (que comprei na Farnell e cujo datasheet está aqui). De uma
forma bem simplificada, um sensor efeito Hall gera uma tensão proporcional ao
campo magnético a que for submetido. É uma alternativa bem mais precisa e
resistente ao ambiente que, por exemplo, usar um reed switch ou um sensor ótico.

O sensor fica montado no circuito e um ima é preso no quadro da bicicleta. Quando


o circuito passar pelo ima a variação de tensão no sensor será detectada pelo
microcontrolador.

O sensor escolhido requer uma tensão de 4.5 a 5.5V. A saída é normalmente (sem
campo magnético) metade desta tensão, conforme a polaridade do campo
magnético a tensão irá variar de 0 até a tensão de alimentação.

Os LEDs

Em princípio qualquer LED serviria para o projeto. Aproveitei uns LEDs que eu
tinha comprado em uma promoção; são LEDs pequenos (3 mm), opacos e de cor
vermelha. O projeto que tomei como exemplo utiliza LEDs maiores, transparentes
e de cor vermelha, que provavelmente dariam uma maior visibilidade.

Como no projeto de referência, usei 7 LEDs. Isto permite usar um gerador padrão
de caracteres de 5x7.

18 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

O Microcontrolador

Os requisitos técnicos para o microcontrolador são:

Um timer para contagem de tempo


Um conversor analógico digital (ADC) para medir a tensão na saída do sensor
Sete saídas digitais para controlar os LEDs

Uma montagem compacta e leve é preferencial para este projeto. Por este motivo
resolvi aproveitar a minúscula placa que vem com o programador eZ430-F2013
(que eu comentei aqui), soldando a ela um conector padrão:

A placa pode também ser comprada separada do programador, em pacotes de três


(apesar da página no link não mencionar que cada item contém três placas). Um
detalhe é que o processador na placa que vem com o programador (MSP430F2013) é
diferente do que vem na placa avulsa (MSP430F2012). A diferença está justamente
no ADC, que é mais sofisticado no 2013. Entretanto, o ADC do 2012 é mais que
suficiente para o que queremos.

Uma outra vantagem de usar o MSP430 é a possibilidade de aproveitar depois um o


outro kit que eu tenho, o EZ430-RF2500. Este kit acrescenta um rádio 2.4GHz, o
que possibilita transmitir as informações para um display no guidão ou para uma
estação na calçada.

O MSP430 trabalha com alimentação de 3V.

A Alimentação

O consumo do circuito será principalmente devido aos LEDs. Inicialmente estou


optando por pilhas alcalinas tamanho AA. Não é uma opção compacta ou leve, mas
deve durar durante o desenvolvimento, independente dos meus bugs de hw e sw.

Estou usando três pilhas em série, para obter os 4.5V para o sensor. A alimentação
do resto do circuito é feita com 3.0V, portanto puxo uma ligação entre a segunda e
a terceira pilha.

No próximo post vou mostrar o circuito elétrico e a minha montagem.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Sábado, Janeiro 03, 2009


Controlando um LED com um MSP430 - Parte
IV
É hora de finalizar esta série de posts, com algumas considerações de ordem
prática.

Onde Encontrar os Compnentes


Nas boas casas do ramo (alguém ainda fala isto?). Um lugar que eu sei que tem é

19 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

na Farnell. Agradeço se algum dos meus leitores puderem indicar outras empresas
que vendam componentes pela internet.

Montagem do Circuito

Praticamente qualquer tipo de montagem pode ser usado, no caso fiz em uma
breadboard:

Reparar na parte inferior esquerda o conector de programação. O pino 1 é o mais à


esquerda.

Preparando o Programador

Como mencionei na primeira parte, fiz um adaptação técnica no EZ430-F2013 para


poder usar um conector normal no circuito. A figura abaixo (clique para ampliar)
de ser suficiente para quem quiser fazer o mesmo (atenção: esta gambiarra pode
danificar o programador, invalida a garantia, etc. Faça por sua própria conta e
risco).

Lembrando novamente, não conectei os pinos 1 que correspondem à alimentação


do circuito. Se preferir você pode conectar porém neste caso a bateria do circuito
deve ser desconectada quando o programador for conectado.

Compilando e Testando o Programa C

Quando você executa o IAR Embedded Workbench, ele vai apresentar o diálogo
Embedded Workbench Startup; selecione Create new project in curent workspace.
Selecione C main, clique em ok e selecione o diretório e nome do projeto. Troque
o código apresentado pelo que mostrei na segunda parte da série.

A parte mais importante é acertar as opções do projeto, o que você faz através de
Project Options:

Em General Options, Target, selecione o device MSP430F2011.


Em Debugger, Setup, escolha o driver FET Debugger.
Confira em FET Debugger, Setup, que está selecionado o Texas instrument
USB-IF e que target VCC é 3.0V.

Selecione Project Rebuild All. Na primeira vez vai pedir o nome do Workspace. Se
você (e eu) fizemos tudo certo, vai indicar zero errors e zero warnings.

20 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Conecte o programador a uma porta USB, ligue o conector ao circuito e selecione


Project Debug. O código deve ser gravado no MSP430 e o depurador vai parar na
primeira linha do código. Pressione F5 para executar o código, pressione o botão e
observe o LED.

Compilando e Testando o Programa Assembly

Quando você executa o IAR Embedded Workbench, ele vai apresentar o diálogo
Embedded Workbench Startup; selecione Create new project in curent workspace.
Selecione asm asm, clique em ok e selecione o diretório e nome do projeto.
Troque o código apresentado pelo que mostrei na terceira parte da série.

Novamente é preciso acertar as opções do projeto, o que você faz através de


Project Options:

Em General Options, Target, selecione o device MSP430F2011.


Em Debugger, Setup, escolha o driver FET Debugger.
Confira em FET Debugger, Setup, que está selecionado o Texas instrument
USB-IF e que target VCC é 3.0V.

Selecione Project Rebuild All. Na primeira vez vai pedir o nome do Workspace. Se
você (e eu) fizemos tudo certo, vai indicar zero errors e zero warnings.

Conecte o programador a uma porta USB, ligue o conector ao circuito e selecione


Project Debug. O código deve ser gravado no MSP430 e o depurador vai parar na
primeira linha do código. Pressione F5 para executar o código, pressione o botão e
observe o LED.

Para Quem Prefere Pronto

Baixe daqui os workspaces, projetos e fontes.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Quinta-feira, Janeiro 01, 2009


Controlando um LED com um MSP430 - Parte
III
Como curiosidade vamos ver como fica o software do nosso projeto em Assembly.

A programação em Assembly no MSP430 é simplificada por uma série de fatores:

mapeamento contínuo da memória através de endereços de 16 bits;


conjunto de instruções bastante conciso ;
um conjunto completo de modos de endereçamento, incluindo operando
imediato (de 8 ou 16 bits) e referências diretas ou inderetas à memória para
os dois operandos;
uma boa quantidade de registradores de uso geral.

No caso do meu programa não foi preciso nem usar os registradores de uso geral,
foi possível acessar sempre a memória diretamente.

Como no caso do programa em C, usei como ambiente de desenvolvimento o IAR


Embedded Workbench Kickstart.

O programa ficou assim:


#include "msp430.h"

NAME main ; nome do modulo

; Vetor de Interrupções
ORG 0FFFEh ; reset

21 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

DC16 init

ORG 0FFF0h ; timer2A


DC16 t2int

; Bits correspondentes aos pinos de E/S


#define BOTAO 01h
#define LED 40h

; Valor para contar 50ms c/ clock de 12KHz


#define TEMPO_50MS 600

RSEG CSTACK ; declara segmento da pilha

RSEG DATA16_N ; segmento de dados

; Controle do LED
ModoLed: DS8 1
#define LED_APAGADO 0
#define LED_ACESO 1
#define LED_PISCANDO 2

; Controle do Botao
ModoBotao: DS8 1
#define BOTAO_ANTERIOR 01h
#define BOTAO_APERTADO 02h

; Código

RSEG CODE ; programa vai no segmento 'CODE

init:
MOV #SFE(CSTACK), SP ; inicia a pilha
MOV.W #WDTPW+WDTHOLD,&WDTCTL ; para o WDT

BIS.B #LFXT1S1,&BCSCTL3 ; ativa VLOCLK

MOV.B #0, &P1SEL ; todos os pinos como I/O


MOV.B #0FFh & ~BOTAO, &P1DIR ; somente o botão é entrada
MOV.B #BOTAO, &P1REN ; usar resistor no botão
MOV.B #BOTAO, &P1OUT ; usar resistor no botão

MOV.B #0, &P2SEL ; todos os pinos como I/O


MOV.B #0FFh, &P2DIR ; todos os pinos como saída
MOV.B #0, &P2OUT ; todas as saidas em zero

MOV.B #0, ModoBotao ; botao solto


MOV.B #LED_APAGADO, ModoLed ; led apagado

MOV.B &CALBC1_12MHZ, &BCSCTL1 ; configura o DCO


MOV.B &CALDCO_12MHZ, &DCOCTL

MOV #TEMPO_50MS, &TACCR0 ; interrupção a cada 50ms


MOV #TASSEL_1 + MC_1 + TAIE, &TACTL

main:
BIS #GIE+CPUOFF+SCG1+SCG0,SR ; LPM3

; não deve chegar até aqui...


JMP main ; loop sem fim

; interrupção do timer2A
t2int:
CMP #10,&TAIV
JNZ t2int_fim

CMP #LED_PISCANDO, ModoLed


JNZ trata_botao
XOR.B #LED, &P2OUT ; pisca o LED

trata_botao:
BIT.B #BOTAO, &P1IN
JNZ botao_solto

BIT.B #BOTAO_ANTERIOR, ModoBotao


JNZ continua_apertado

22 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

BIS.B #BOTAO_ANTERIOR, ModoBotao ; aguarda confirmação


JMP t2int_fim

continua_apertado:
BIT.B #BOTAO_APERTADO, ModoBotao
JNZ t2int_fim

BIS.B #BOTAO_APERTADO, ModoBotao ; confirmamos aperto

CMP.B #LED_APAGADO, ModoLed


JNZ led_nao_apagado

MOV.B #LED_ACESO, ModoLed


BIS.B #LED, &P2OUT ; acende o LED
JMP t2int_fim
led_nao_apagado:
CMP.B #LED_ACESO, ModoLed
JNZ led_piscando

MOV.B #LED_PISCANDO, ModoLed ; piscar o LED


JMP t2int_fim
led_piscando:
MOV.B #LED_APAGADO, ModoLed
BIC.B #LED, &P2OUT ; apaga o LED
JMP t2int_fim
botao_solto:
BIT.B #BOTAO_ANTERIOR, ModoBotao
JZ continua_solto
BIC.B #BOTAO_ANTERIOR, ModoBotao ; aguarda confirmação
JMP t2int_fim
continua_solto:
BIC.B #BOTAO_APERTADO, ModoBotao ; confirmado

t2int_fim:
RETI

END

Na quarta e última parte veremos como montar o circuito, compilar o código e


gravá-lo no microcontrolador.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Quarta-feira, Dezembro 31, 2008


Controlando um LED com um MSP430 - Parte
II
Nesta parte vamos ver o software do nosso projeto.

Como ambiente de desenvolvimento vou usar o IAR Embedded Workbench


Kickstart, que é fornecido junto com o programador EZ430-F2013 e pode também
ser baixado gratuitamente do site da Texas. Esta versão grátis é limitada para
gerar programas de até 4KBytes; como o modelo que estamos usando possui
somente 2K de Flash, é mais que suficiente.

Existem, é claro, várias maneiras de estruturar o nossa programa. Optei por


programar o timer para gerar interrupções a cada 50 milisegundos e colocar toda a
lógica dentro do tratamento desta interrupção. Desta forma, na maior parte do
tempo o processador estará parado em modo de economia de energia.

Para controlar o botão usei uma variável de tipo byte, onde 1 bit indica o estado
do botão na leitura anterior e outro o estado após o debounce. Este segundo bit só
é alterado após duas leituras consecutivas iguais.

Uma segunda variável do tipo byte armazena o estado do LED: apagado, aceso
continuamente ou piscando. A cada pressionamento do botão o estado muda

23 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

ciclicamente.

Sem mais delongas, eis o código em C:

24 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

view plain copy to clipboard print ?

01. #include <msp430.h>


02.
03. typedef unsigned char byte;
04.
05. // Bits correspondentes aos pinos de E/S
06. #define BOTAO 0x01
07. #define LED 0x40
08.
09. // Valor para contar 50ms c/ clock de 12KHz
10. #define TEMPO_50MS 600 // 50ms * 12KHz
11.
12. // Controle do LED
13. static enum { APAGADO, ACESO, PISCANDO } ModoLed;
14.
15. // Controles do estado do botão
16. #define BOTAO_ANTERIOR 0x01 // este bit indica o estado ante
rior
17. #define BOTAO_APERTADO 0x02 // este bit tem o valor c/ "debo
unce"
18. static byte ModoBotao;
19.
20. void main (void)
21. {
22. // Desliga Watchdog
23. WDTCTL = WDTPW + WDTSSEL + WDTHOLD;
24.
25. // Altera a configuração de clock para ativar o VLOCLK
26. BCSCTL3 |= LFXT1S1;
27.
28. // Programa entradas e saídas
29. P1SEL = 0; // Todos os pinos como I/O
30. P1DIR = 0xFF & ~BOTAO; // Somente o botão é entrada

31. P1REN = BOTAO; // Usar resistor no botão


32. P1OUT = BOTAO; // Resistor é pullup
33.
34. P2SEL = 0; // Todos os pinos como I/O
35. P2DIR = 0xFF; // Todos os pinos como saída

36. P2OUT = 0; // Todos as saídas em zero


37.
38. // Inicia os nossos controles
39. ModoBotao = 0;
40. ModoLed = APAGADO;
41.
42. // Alimentação já deve estar estável, vamos ligar o DCO
43. BCSCTL1 = CALBC1_12MHZ;
44. DCOCTL = CALDCO_12MHZ;
45.
46. // Programar a interrupção de tempo real p/ cada 50ms
47. TACCR0 = TEMPO_50MS;
48. TACTL = TASSEL_1 + MC_1 + TAIE; // ACLK, up mode, interru
pt
49.
50. // O nosso programa principal vai ficar dormindo,
51. // todo o tratamento será feito na interrupção
52. _BIS_SR(LPM3_bits + GIE); // Dorme tratando interrupç
ão
53.
54. // Nuca vai chegar aqui
55. while (1)
56. ;
57. }
58.
59. // Tratamento da interrupção do Timer A
60. #pragma vector=TIMERA1_VECTOR
61. __interrupt void Timer_A_TO(void)
62. {
63. switch (TAIV)
64. {
65. case 10: // overflow
66.
67. // Trata o LED
68. if (ModoLed == PISCANDO)
69. P2OUT ^= LED;

25 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Alguns comentários sobre o código:

O include msp430.h define as constantes relativas ao microcontrolador. O


modelo específico de microcontrolador é definido nas opções do projeto.
O MSP430 inicia a execução com o watchdog ativo, portanto é necessário
desativá-lo ou desarmá-lo periodicamente.
Para o timer estou utilizando o VCLOCK, que é um clock interno lento
(12KHz) e de baixo consumo. É somente este clock que vai estar ativo
enquanto o processador aguarda uma interrupção. O VCLOCK não é muito
preciso; para ter um clock preciso de baixo consumo é necessário colocar
um cristal externo de 32KHz.
Quando o processador está rodando é usado o DCO, que é um clock interno
rápido (12MHz). Como parte do processo de fabricação são gravados na Flash
parâmetros de calibração do DCO, desta forma esta clock é razoavelmente
preciso.
O MSP430 possui uma grande versatilidade nos pinos de entrada e saída
digital. A recomendação da Texas é que os pinos não usados sejam
programados como saída.
O timer no MSP420F2011 é também muito flexível o que, neste caso, pode
deixar a programação um pouco complicada. No caso é usado o up mode, no
qual o timer conta de 0 até o valor em TACCR0. Ao atingir esta valor, o
contador volta a zero e uma interrupção é gerada.
A função _BIS_SR permite ligar bits do registrador de status. No caso são
ligados os bits que colocam o processador para dormir com economia de
energia (Low Power Mode 3) e o bit que permite interrupções. O resultado é
que o processador fica parado na instrução seguinte, tratando interrupções.
Quando uma interrupção ocorre, o registrador de status é salvo na pilha e o
processador entra no modo normal de execução (LPM0). Ao final da
interrupção o registrador de status é restaurado da pilha. Para o
processamento continuar no programa principal uma interrupção precisaria
alterar o registrador de status na pilha antes de retornar, o que não é feito
neste programa.
A pragma_vetor define que a rotina seguinte é uma rotina de tratamento de
interrupção. O compilador cuida de colocar o endereço da rotina no vetor
de interrupções e de colocar os preâmbulos e postâmbulos adequados no
código.
A interrupção do timer pode ser gerada por vários motivos, o registrador
TAIV informa qual o motivo. No caso só estamos interessados na interrupção
gerada quando o contador dá a volta.

Na próxima parte vamos ver este mesmo código em Assembly; na quarta e última
parte veremos como montar o circuito, compilar o código e gravá-lo no
microcontrolador.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Segunda-feira, Dezembro 29, 2008


Controlando um LED com um MSP430 - Parte I
A exemplo do que fiz com o microcontrolador PIC, nesta série vamos ver como
controlar um LED desta vez usando um microcontrolador MSP430 da Texas.

O Objetivo

O objetivo desta série é mostrar o projeto do hardware e software de um pequeno


dispositivo que ilustra como controlar um LED usando um MSP430. O dispositivo
possui um LED e um botão que será usado para controlar o estado do LED (apagado,
piscando ou aceso).

O Projeto de hardware

26 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Neste projeto vou usar o MSP430F2011; é simples alterar tanto o hardware como o
software para outros modelos.

O MSP430F2011 tem as seguintes vantagens para este projeto:

pode operar com alimentação de 1.8 a 3.6V, o que simplifica a operação


com baterias e pilhas
disponível em encapsulamento DIP de 14 pinos, o que simplifica a montagem
possui dois osciladores internos, um que opera até 16 MHz e outro de
aproximadamente 12KHz, dispensando a conexão de um cristal ou
ressonador
memória Flash para o programa, o que simplifica a gravação e regravação
gravador e depurador de baixo custo (EZ430-F2013)

O primeiro passo para o projeto de hardware é examinar o datasheet do


microcontrolador, que pode ser baixado do site da Texas.

No datasheet verificamos que o clock máximo varia de 6 a 16MHz dependendo da


alimentação. Minha opção foi operar com o oscilador interno (DCO) a 12MHz
usando uma bateria de 3V (Duracell DL2032 ou equivalente). O positivo da bateria
deve ser conectado ao pino 1 (VCC) do MSP430 e o negativo ao pino 14 (VSS).

O pino 10 (RST) deve ser ligado a VCC através de um resistor de 47K. Este pino é
responsável pelo reset do microcontrolador e será usado também na programação
da Flash.

O LED e o botão são conectados a pinos de entrada/saída de uso geral, que no


MASP430F2011 são qualquer um dos pinos de 2 a 9 ou um dos pinos 12 e 13. Escolhi
o pino 13 (P2.6) para o LED e o pino 2 (P1.0) para o botão, para facilitar a minha
montagem.

O LED, como diz a sigla, é um diodo emissor de luz. Quando submetido a uma
tensão direta acima de sua tensão de queda ele emite uma luz com intensidade
proporcional à corrente. Existem vários modelos de LEDs, que emitem as mais
diversas cores. A tensão de queda é tipicamente de 2V e uma intensidade boa para
um LED montado em painel pode ser obtida com uma corrente de 10 mA.

Voltando ao datasheet do MSP430, verificamos que um pino de entrada/saída é


capaz de gerar ou absorver uma corrente de até 40mA e tem uma tensão de 0,6V
(nível zero) ou VCC-0.6V (nível um). A capacidade de corrente do MSP430 permite
ligar um LED diretamente das duas maneiras abaixo:

Na primeira maneira, com o LED ligado entre o pino do MSP430 e VSS, o valor do
resistor em série (conforme a lei de Ohm) deve ser

(VCC - 0.6 - 2,0)/0,01 = 40 ohms

Analogamente, com o LED ligando entre o pino do MSP430 e VCC, o valor do


resistor deve ser

(VCC - 0.6 - 2,0)/0,01 = 40 ohms

27 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

No primeiro caso, o LED acende quando o pino do MSP430 está no nível um, no
segundo quando está no nível zero. No meu circuito adotei a primeira maneira
com um resistor de 39 ohms (o que gera uma corrente de ligeiramente acima de
10mA).

Para a ligação do botão vamos usar o resistor de pullup interno do MSP430. Desta
forma, o botão pode ser ligado diretamente ao VSS e erá lido como nível zero
quando fechado e como nível um quando aberto.

Para facilitar a gravação, vamos colocar um conector de programação no circuito.


Para a programação com o eZ430-F2013, usando a alimentação do circuito, basta
conectar dois pinos (e mais o VSS):

pino 11 TEST
pino 10 RST

O ideal seria usar um conector igual ao do programador, porém ele é difícil de ser
encontrado e tem um espaçamento muito pequeno para montagens convencionais.
A solução é soldar um cabo no conector e colocar um conector mais comum na
outra ponta:

O pino 1 do conector poderia ser usado para alimentar o circuito, neste caso seria
preciso desconectar a bateria durante a programação. Para simplificar deixei este
pino aberto nas duas pontas.

A lista de componentes para o circuito fica sendo:

1 MSP430F2011 (encapsulamento N)
1 LED
1 Botão de contato momentâneo
1 Resistor de 39 Ohms 1/8 W
1 Resistor de 47 KOhms 1/8 W
1 Bateria de 3V
1 Suporte para a bateria

O circuito completo fica (clique para ampliar):

No próximo post da série vamos ver o software.

28 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Quinta-feira, Outubro 09, 2008


Microcontroladores - Final
Concluindo (finalmente!) esta série de posts (mas não encerrando o assunto que
certamente voltará a ser visto neste blog), vamos a uma série de links.

Da palestra que deu início à série:

o inevitável powerpoint
o enfadonho vídeo

A série completa: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Final

Os links para os sites dos fabricantes:www.microchip.com

www.intel.com/design/mcs51/
www.ti.com/msp430
www.atmel.com
www.st.com/mcu/

Posted by Daniel Quadros at 07:24 0 comentário(s)


Categorias: Processadores

Quarta-feira, Outubro 01, 2008


Microcontroladores - Parte 16
Neste post vamos comentar rapidamente uma questão frequente: e o uso de C++
na programação de microcontroladores?

A programação em C++ em microcontroladores mais potentes, como os baseados


na arquitetura ARM, é bastante tranquila. No modelos maiores de
microcontroladores com arquitetura Von Newman, como o MSP430, é possível o uso
de C++ (com alguns cuidados).

Nos microcontroladores com arquiteturas Harvard e/ou fortes limites de memória,


a situação é complicada:

Métodos virtuais e polimorfismo são normalmente implementados através


de uma tabela de endereços de rotinas (a vtable). Arquiteturas Harvard
tendem a dificultar este tipo de chamada indireta.
A programação em C++ costuma exigir mais espaço na pilha, que é muito
limitada nos microcontroladores mais simples.
Pouca quantidade de memória dificulta o uso de alocação dinâmica de
memória, como o heap do C++ usado para alocação de objetos através de
new. Aliás, a alocação dinâmica de memória costuma se evitada na
programação embarcada, pois as consequências de um leak de memória
serão catastróficas.

Aproveitando: no evento C & C++ para Sistemas Embarcados tem uma palestra sobre o uso de C++.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Linguagens, Programação

Sábado, Setembro 06, 2008


Microcontroladores - parte 12
Continuando com os exemplos, vamos examinar o MSP430 da
Texas (que eu já comentei antes).

A família MSP430 tem uma arquitetura tradicional (Von Neuman)

29 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

de 16 bits (registradores e unidade lógica/aritmética de 16 bits).

O microcontrolador na foto, o MSP430F2011, tem as seguintes características:

Clock de 10Hz a 20KHz


Flash de 2KBytes (para o programa) mais 4 segmentos de 64 bytes
(normalmente usados para configurações e outros dados não voláteis)
Ram de 128bytes
Até 10 E/S digitais
WDT
2 Timers

Toda a memória é acessada direta ou indiretamente através de um endereço de 16


bits:

Na figura acima, Info são os quatro segmentos de flash, Bootloader é uma área fixa
de fábrica (Rom) que contém um bootloader serial e Periféricos são registradores
de controle do funcionamento dos periféricos do microcontrolador.

A estrutura de registradores é bastante versátil, com 16 registradores de 16 bits:

Os registradores R0, R1 e R2 tem funções específicas (ponteiro de instruções,


ponteiro da pilha e status). O registrador R3 é um pseudo-registrador que permite
gerar algumas constantes comuns (como 0, 1 e 2).

Um dos ambientes disponíveis para programação C é o IAR Embedded Workbench


(uma versão limitada é fornecida pela Texas junto com um dispositivo de
programação e debug de baixo custo).

O IAR Embedded Workbench dispõe de uma IDE bem razoável, assembler,


compilador, linker, locate e debug. Uma diferença em relação aos que vimos
anteriormente é o suporte a C++.

Como de costume o IAR Embedded Workbench possui uma biblioteca padrão C e

30 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

mais rotinas específicas para uso dos recursos do MSP430.

Posted by Daniel Quadros at 07:00 0 comentário(s)


Categorias: Hardware, Processadores, Programação

Sexta-feira, Janeiro 04, 2008


Microcontrolador Texas MSP430
O MSP430 é uma entrada relativamente recente no mercado de
microcontroladores. Com consumo muito baixo e uma arquitetura de 16 bits
voltada para linguagens de alto nível, ele é uma alternativa muito interessante às
consagradas famílias PIC e 8051.

As informações que se seguem vem da documentação do MSP430 (que pode ser


obtida aqui), do material fornecido no MSP430 Day e da minha experiência de
desenvolvimento de software para os modelos MSP430F2011 e MSP430F2121.
Arquitetura do MSP430

Os microcontroladores PIC e 8051 possuem arquiteturas esquisitas, dividindo a


memória em regiões distintas que precisam ser acessadas por instruções
especializadas. O resultado é uma dificuldade tanto para a programação assembler
como para a construção de compiladores.

O MSP possui uma estrutura de 16 bits, tanto na capacidade de processamento da


unidade lógica aritmética como nos registradores de trabalho e no endereçamento
de memória. Ram, Flash e controle dos periféricos compartilham este mesmo
espaço de endereçamento e são manipulados pelas mesmas instruções de acesso á
memória.

Uma diferença em relação ao PIC é que o MSP430 não possui memória EEProm
interna. Por outro lado ele dispõe de 4 áreas de 64 bytes de memória Flash que
podem ser usadas para salvar parâmetros de forma não volátil.

O MSP dispõe de 16 registradores de 16 bits (R0 a R15), dos quais 12 são de uso
geral (R4 a R15). R0 é o contador de programa, R1 é o ponteiro da pilha e R2 é o
status do processador. R2 e R3 são geradores de constantes (usados como operando
geram os valores 0, 1, 2, 4, 8 e 0xFFFF).

Modelos mais recentes expandem a arquitetura para endereços de 20 bits, para


suportar um quantidade maior de memória.

Sistema Flexível de Clock

O MSP430 possui diversas opções de clock, que podem inclusive ser mudadas
durante a execução para reduzir o consumo em momentos de espera e aumentar o
desempenho na hora de processar.

Dependendo do modelo, existem até 4 fontes possíveis para o sinal de clock:

VLOCLK: clock interno de 12KHz de baixíssimo consumo.


LFXT1CLK: clock lento gerado por um cristal ou ressonador externo,
tipicamente um cristal padrão de relógio de 32.768KHz (que fornece uma
base de tempo de 1 segundo bastante precisa).
XT2CLK: clock rápido gerado por um cristal ou ressonador externo.
DCOCLK: clock interno gerado por um digital controlled oscillator (DCO) de
até 16MHz com alguns valores pré-calibrados na fábrica para baixo erro.

Os sinais destas fontes podem ser dirigidos para três usos:

ACLK: clock auxiliar para os dispositivos (por exemplo o temporizador),


pode ser VLOCLK ou LFXT1CLK, dividido por 1, 2, 4 ou 8.
MCLK: clock mestre, usado pela CPU. Pode vir de qualquer uma das fontes

31 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

dividida por 1, 2, 4 ou 8.
SMCLK: clock sub-principal (!), pode ser usado nos dispositivos. Também
pode vir de qualquer uma das fontes dividida por 1, 2, 4 ou 8.

Baixo consumo

Com todos os clocks parados (LPM4 - Low Power Mode 4), o MSP430 consome apenas
0,1 uA para manter o conteúdo da Ram.

Numa situação mais comum (LPM3), é mantido ligado apenas o ACLK para permitir
acordar o processador após um determinado período de tempo. Neste caso o
consumo fica em 0,9 uA (para alimentação em 3V).

Em todos os modos de baixo consumo o processador está parado mas é acordado


rapidamente (menos de 1 uSeg para o DCO voltar a oscilar na família MSP430F2xx)
quando recebe uma interrupção.

Periféricos Internos

Os vários modelos de MSP430 possuem internamente os periféricos tradicionais de


microcontroladores:

Entradas e Saídas Digitais: todos os modelos possuem e/s digital com


capacidade de interrupção (por borda de subida ou descida), pull-up e
pull-down configuráveis.
Watchdog Timer (WDT): também presente em todos os modelos, resseta o
processador se não for periodicamente desarmado (usado para colocar o
processador em uma situação conhecida no caso de alguma falha de
programação).
Timers: o MSP430 difere um pouco de outros micontroladores pelo fato de
cada timer ter um único registrador de contagem e múltiplos registradores
de comparação/captura. No modo continuous o registrador de contagem é
continuamente incrementado por um dos clock (dando a volta quando atinge
0xFFFF) e interrupções de tempo real são geradas quando o registrador de
contagem atingem o valor de um dos registradores de comparação. No modo
up a contagem vai de 0 até o valor de um dos registradores de comparação,
este modo pode ser usado para gerar um sinal PWM em um pino. Na
operação de captura uma interrupção é gerada quando ocorre a mudança de
sinal em um pino, neste instante o valor no registrador de contagem é
copiado para o registrador de captura.
Comparador Analógico: compara o sinal presente em um pino com uma
referência interna ou externa. Útil, por exemplo, para detectar bateria
baixa.
Conversor A/D: não disponível em todos os modelos, codifica o nível de um
sinal analógico em um valor digital de 10 ou 12 bits (dependendo do
modelo).
USART: não diponível nos modelos mais simples, implementa comunicação
serial síncrona ou assíncrona.

Os modelos mais sofisticados possuem capacidade de DMA (tansferência


automática entre um bloco de memória e um dispositivo), interface I2C, um
multiplicador por hardware (útil para endereçar vetores de estruturas) e conversor
digital analógico. Alguns modelos incluem um sensor de temperatura.

A família MSP430x4xx inclui ainda um controlador de LCD.

Programação e Debug a Baixo Custo

Os modelos MSP430F20xx
permitem programação e debug
através de um dispositivo

32 de 33 11/2/2010 17:40
DQSoft: Resultados da pesquisa msp430 http://dqsoft.blogspot.com/search?q=msp430

semelhante a um pen-drive
(eZ430-F2013), através de uma
conexão chamada pela Texas de
Spy-By-Wire. O custo deste
dispositivo nos EUA é de apenas
U$20, no Brasil ele pode ser
encontrado por R$100. A única
restrição que encontrei foi o
baixo número de breakpoints
por hardware.

Uma vantagem adicional é que o programador vem com uma versão limitada do
IAR Embedded Workbench Kickstart. Trata-se de uma IDE e compilador C bastante
razoáveis. A limitação do compilador gratuito é de 4K de código, mais que sufiente
para aplicações simples.

Se os até 2K de Flash dos modelos MSP430F20xx forem insuficientes e você optar


pelos modelos MSP430F21xx, você vai precisar de um programador JTAG. O
MSP-FET430UIF suporta todos os modelos e custa US$100 nos EUA (R$720 no Brasil!).
Ele vem com o mesmo pacote de software que o eZ430-F2013.

Uma limitação nos dois casos é a ausência de um software de gravação standalone


(por exemplo para uso na produção). Nos dois casos a gravação é feita disparando
o Debug na IDE.

Baixo Custo (Em Termos)

Uma limitação para o hobista é que a maioria dos modelos está disponível apenas
em encapsulamento do tipo surface-mounted. Apenas os modelos MSP430F20xx
estão disponíveis no encapsulamento PDIP).

No folheto que está no site da Texas estão os preços sugeridos para revenda nos
EUA, para mil peças. O modelo mais barato (MSP430F2001) estava a $0,55 quando
consultei. Entretanto, este modelo tem apenas 1K de Flash e 128 bytes de Ram, o
que limita muito suas aplicações principalmente quando programado em C. O
MSP430F2121, com 4K de Flash e 256 bytes de Ram, estava a $1,35.

No Brasil, para compras unitárias, o preço é mais alto. O modelo NSP430F2013 (2K
de Flash, 128 bytes de Ram, USART) tem preço EUA $1,65, no Brasil é vendido por
R$12,23 (preço verificado na Farnell).

Futuramente vou apresentar uma adaptação do meu artigo de conexão de um LED


ao PIC para o MSP430.

Posted by Daniel Quadros at 07:58 0 comentário(s)


Categorias: Hardware, Processadores

Postagens mais recentes Início Postagens mais antigas

Assinar: Postagens (Atom)

33 de 33 11/2/2010 17:40