Mensagem

"Sonhar mais um sonho impossível, lutar quando é fácil ceder, vencer o inimigo invencível, negar quando a regra é vender."
Miguel de Cervantes.

"Os microprocessadores RISC funcionam a partir do princípio genial de se encarregar das coisas mais fáceis e deixar todas as partes difíceis para outras pessoas resolverem."
Douglas Adams.

Cálculo de Campo Elétrico e Potencial 2D com FEM - Phyton

   Seguindo com o desenvolvimento de um programa para o ensino do eletromagnetismo, apresento o código Phyton para estudo de campos elétricos e potencial elétrico através do uso do Método dos Elementos Finitos (FEM). 

arquivo main.py

arquivo electricPotFEM.py

                    Capacitor com dielétrico diferente no centro


                    Efeito das pontas

Cálculo do Campo Elétrico e Potencial de Cargas Elétricas (2D) - Phyton

   Comecei a estudar e programar Phyton e nada melhor que iniciar com um bom desafio. O objetivo é um aplicativo interativo para o ensino de eletromagnetismo e eventual uso em projetos reais. Esse é um pequeno passo de muitos, assim espero. Contribuições, sugestões e críticas, por gentileza, envie um email para cborges13@gmail.com. 

arquivo main.py 

arquivo point_charge.py


Atualização da Biblioteca para o LCD 16x2

   Depois de algum tempo segue atualização da biblioteca do livro AVR e Arduino: Técnicas de Projeto. Incorporei novas funções e simplifiquei outras, bem como melhorei a padronização do código.
    Código e projeto no AVR Studio 6.2, com exemplos de uso das funções, arquivos AQUI.


Protocolo 1 Wire usando UART com o STM32

   O protocolo 1 wire é muito interessante para uso de somente um pino de I/O de um microcontrolado. Protocolo simples e baseado em janelas de tempo entre os sinais. Todavia, o uso de atrasos para escrita e leitura do pino pode resultar em perda de desempenho e complicar a vida do programador. Isso ocorrerá se a temporização for feita através da execução de laços vazios.
   Visando superar essas complicações e otimizar a programação e desempenho do microcontrolador, a Maxim (compradora da Dallas Semiconductor Corp. , que criou o protocolo), apresenta uma nota de aplicação para realizar a comunicação 1 wire empregando o protocolo serial simples (UART). 

   O detalhe está em trocar a taxa de transmissão entre 9600 e 115200 bps. No Reset usa-se 9600 e envia-se o dado 0xF0. Para escrita e leitura, 115200 bps. Na escrita de 1 lógico envia-se 0xFF, de 0, 0x00. Na leitura se envia 0xFF para cada bit a ser lido, retorno 0xFF significa bit 1. O uso da UART é, portanto, simples e prático.
   A comunicação deve ser configurada para 8 bits de dados, um bit de parada, sem bit de paridade.

   A seguir código exemplo para o DS80B20 (sensor de temperatura), empregado para um Corte-M0+ da STM, baseado na camada de abstração de hardware (HAL). Os detalhes foram suprimidos, pois a ideia é apresentar o algoritmo básico.


//--------------------------------------------------------------------------
// 1 WIRE functions - UART 2
//--------------------------------------------------------------------------
// 1 WIRE functions - UART 2
void reset_1w()
{
unsigned char  buff[2];
buff[0]=0xF0;

huart2.Init.BaudRate = 9600; // para o reset a taxa deve ser 9600
HAL_UART_Init(&huart2);

HAL_UART_Transmit(&huart2, buff, 1, HAL_MAX_DELAY);

huart2.Init.BaudRate = 115200; // 115200 para rescrita e leitura
HAL_UART_Init(&huart2);
}
//--------------------------------------------------------------------------
void write_byte_1w(unsigned char data)
{
uint32_t i;

for(i=0; i<8; i++)
{
if(tst_bit(data,i))
USART2->TDR = 0xFF; // logico 1 envia FF
else
USART2->TDR = 0x00; // logico 0 envia 00

HAL_UART_Receive(&huart2, (uint8_t *)aRxBuffer, 1,0xFFFF);
}
}
//---------------------------------------------------------------------------
unsigned char read_byte_1w()
{
unsigned int i;
unsigned char dado = 0; // todos os bits são zero por default

for (i=0;i<8;i++)
{
   USART2->TDR = 0xFF; // para ler um bit envia FF

   HAL_UART_Receive(&huart2, (uint8_t *)aRxBuffer, 1,0xFFFF);

   if(aRxBuffer[0] == 0xFF) //se for igual a FF o bit é um, zero se contrário
      set_bit(dado,i);

}
return (dado);
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------


//DS18B20 - uma conversão

reset_1w(); //reset do sensor (a resposta de presença é retornada mas não avaliada).
write_byte_1w(0xCC); //comando para pular ROM (só 1 dispositivo no barramento).
write_byte_1w(0x44); //manda iniciar a conversão
HAL_Delay(750);
reset_1w();
write_byte_1w(0xCC);
write_byte_1w(0xBE); //avisa que quer ler a memória

temp_LSB = read_byte_1w();//só interesse em ler os dois bytes da temperatura
temp_MSB = read_byte_1w();


temp_16bits = (temp_MSB<<8) | (temp_LSB);

if (temp_MSB > 7)
{
  temp_16bits = 0xFFFF - temp_16bits + 1; 
  sinal = '-';
}
else
  sinal = '+';

  temperatura = (5*temp_16bits)/8;


STM32F103C8 - Attolic TrueStudio. Acabou pra ti, ATMEL!

   Atualmente os microcontroladores da ST estão com alta popularidade, bombando com os projetistas. Essa fama se deve principalmente ao preço e as ferramentas de desenvolvimento disponíveis. Uns U$ 2 pela placa de desenvolvimento (conhecida por Blue Pill) e U$5 pelo gravador depurador (ST-Link V2)! Dá um banho no Arduino Due e no ICE!  Só o ICE (depurador e gravador da Atmel) custa + de U$ 100 (claro que faz muitas coisas) e o Due (U$ 12) possui mais poder de processamento, mas para nós mortais, querendo programar um mísero ARMzinho...

Resultado de imagem para STM32F103C8 blue pill



Resumo das Principais Características do STM32F103C8:
  • Processador de 32 bits (ARM - Cortex-M3).
  • 64 kB de memória Flash.
  • 20 kB de memória RAM.
  • 72 MHz de frequência de operação máxima.
  • Controlador DMA para 7 canais
  • 7 Timers de 32 bits com várias funções + Systick Timer
  • RTC
  • USB 2.0
  • 3 UARTs
  • 2  I2Cs
  • CAN
  • 2  SPIs
  • 2 ADCs de 12 bits de 1 Msps (com sensor de temperatura interno), 10 canais.
  • 37 GPI/Os.
  • Modos para economia de energia.

   Agora a ST disponibilizou a pouco uma IDE de desenvolvimento totalmente grátis, o Atollic TrueStudio (que é baseado no Eclipse) e roda infinitamente melhor que o Atmel Studio. Todavia, a maioria dos projetistas adota o Eclipse como IDE. Fora isso, a ST ainda disponibiliza o CubeMX, programa para configuração dos periféricos do microcontrolador, que, como todo programador sabe, no ARM é o "cão chupando manga", o que facilita sobremaneira o início da programação. E sua camada de abstração de hardware (HAL) parece muito mais simpática e fácil de usar que a ASF (Atmel Software Framework ). No Cube basta alguns cliques nos pinos e a seleção do que se deseja é muito fácil. Detalhe: agora que a Atmel foi adquirida pela Microchip, será que terá maior didática e ferramentas baratas e eficientes?
   Bom, a seguir disponibilizo alguns programas teste para ajudar algum iniciante e meus alunos. Ressalva que não estão 100%, foram exemplos feitos rapidamente. Os programas foram desenvolvidos no Atollic e alguns com a ajuda do Cube.

Pisca LED: possui funções de atraso feitas com assembly, como atraso_ms( ) e atraso_us( ); apresentada a função de atraso feita com o timer Systick (em ms); também função para contagem de ciclos gastos em determinado trecho do código empregando o DWT (Data Watchpoint Trace). Obs.: as funções feitas em assembly apresentam contagem de ciclos dobrados para frequência de trabalho acima de 24MHz (se deve a forma de implementação do STM32F103C8).

Pisca_LED_HAL: pisca LED utilizando o Hardware Abstraction Layer  do STM.

UART: teste simples para uso da interrupção da UART3, inclui biblioteca de funções para trabalho com a UART.

USB_HAL: programa para enviar dados pela USB do STM32, configurado para se tornar uma porta Comm virtual.

FreeRTOS_HAL: exemplos de uso do Free RTOS, empregando o CubeMX. Os exemplos são baseados na apostila Using Free RTOS Real Time Kernel de autoria de Richard Barry. Apresenta funções para gerar interrupção por software empregando alguma interrupção não empregada efetivamente (emprega CMSIS), e função para a geração de números pseudo-aleatórios com o algoritmo LFSR.

FreeRTOS_LCD5110_Joystick: emprego do Free RTOS para acionamento do LCD Nokia5110 e de um Joystick, com um botão e dois eixos. Leitura do ADC utilizando DMA.

Existem inúmeros vídeos e material didático disponíveis na internet, explicando detalhadamente o uso do CubeMX e  do Atollic True Studio. Referências técnicas podem ser encontradas no site da ST: www.st.com


Borges Invaders: game com o Due e o FreeRTOS

  Já faz um bom tempo que gostaria de fazer esse joguinho, então a oportunidade se fez. Uma nave contra invasores vindos do espaço. Podiam ser amigos, mas aí não teria o cheiro do passado e estaria muito politicamente correto.
 Resolvi utilizar recursos simples, então optei por um display matricial 84x48 (NOKIA 5110) e um pequeno joystick com um botão, e o Arduino Due (Cortex-M3) rodando a 84 MHz. Não fiz som, não estava com muita vontade de programar essa funcionalidade, fico devendo. O game não tem final, você nunca morre, pode jogar até não poder mais, vida infinita ... então, não tem game over!
  A idéia era usar um RTOS para facilitar a programação e melhorar o seu entendimento. Optei pelo FreeRTOS por ser facilmente empregado no ATmel Studio (minha ferramenta de ensino).
 O programa não é uma maravilha, daria para otimizar e melhorar bastante, mas como uma primeira brincadeira está aceitável. Como várias tarefas no FreeRTOS empregam variáveis comuns, utilizei variáveis globais, dentro do escopo das tarefas, para acesso compartilhado, e não empreguei ferramentas de sincronização e acesso exclusivo. Dentro da proposta e desempenho do jogo, foi o suficiente. O legal de utilizar o ATSAM do Due é que ele possui um gerador de números aleatórios muito fácil de utilizar e fundamental para a programação do jogo.
  A dificuldade maior foi ajustar a biblioteca básica do LCD para possuir funções gráficas, a função principal é o desenha_pixel( ) e depois a que permite desenhar uma figura (já definida) em qualquer parte do LCD, incluindo qualquer parte da figura. Aproveitei e criei uma função para imprimir o menor tamanho de número possível no LCD, para mostrar a pontuação do jogo. Também, existem muitas outras funções, mas não as utilizei.
  Aqui, o projeto completo, com o programa feito no ATmel Studio 7.0.



ARM CORTEX-M3 ATSAM3X8E - Arduino Due

    OBSERVAÇÃO: not for Dummies!

   Para aplicações relativamente simples um microcontrolado de 8 bits é suficiente. Entretanto, quando se necessita mais desempenho, memória e periféricos, é preciso um microcontrolador mais turbinado e com motor mais potente. Minha escolha foi o Arduino Due devido aos inúmeros Shields disponíveis e por poder ser programado no Atmel Studio, incluindo o FreeRTOS e todas as ferramentas necessárias para um desenvolvimento profissional de firmware.
   Comecei a programação com alguns programas básicos para entender a complexidade dos registradores de configuração do ATSAM3X. O datasheet da Atmel é algo terrível, pesadelo para estudar e compreender (a Atmel deveria evitar que estagiários escrevessem datasheets!). Assim, resolvi disponibilizar os códigos desenvolvidos e materiais de suporte para ajudar os iniciantes.
   Bueno, vamos ao que importa:

   PRINCIPAIS CARACTERÍSTICAS DO ARDUINO DUE

  • Pinagem compativel com o Arduino Uno (Shields compatíveis), cuidado deve ser tomado pois o Due trabalha com 3.3V (5V pode danificá-lo permanentemente).
  • Entrada de alimentação externa 9 VDC.
  • Gravação através de conversor serial-usb com bootloader (similar ao Uno).
  • Conector SPI.
  • Conector JTAG para programação e depuração.
  • Botão de reset.
  • Botão para apagamento da memória do microcontrolador.
  • Possui um microcontrolador ATSAM3X8E.
  • 54 pinos de I/O.
  • 12 entradas analógicas (ADC).
  • 4 UARTs.
  • 1 USB OTG.
  • 2 saídas DAC.

     PINAGEM  aqui. (obrigado Rob Gray, te pago uma gelada quando te encontrar)

   
   PRINCIPAIS CARACTERÍSTICAS DO ATSAM3X8E
  • Processador de 32 bits (ARM - Cortex-M3).
  • 512 kB de memória Flash.
  • 96 kB de memória RAM.
  • 84 MHz de frequência de operação máxima.
  • Oscilador interno (PLL) para geração precisa de sinais de frequência para os seu trabalho.
  • Controlador DMA
  • 9 Timers de 32 bits com modos de comparação, captura e PWM.
  • RTC
  • USB 2.0 On To Go
  • 4 UARTs
  • 2 I2C
  • 2 CAN
  • 1 Ethernet MAC10/100 com DMA dedicado.
  • 16 canais AD de 12 bits de 1 Msps (com sensor de temperatura interno).
  • 2 canais DA de 12 bits 1 MSPs.
  • 1 Gerador de Números Aleatórios Verdadeiro.
  • 103 I/Os com capacidade de interrupção, filtro para debouncing e glitch, coletor aberto, pull-up.
  • Modos para economia de energia.


   CONFIGURANDO O ATMEL STUDIO PARA GRAVAR O ARDUINO DUE

   Uma característica interessante do Atmel Studio é poder gravar o Due através de sua IDE. São necessários alguns passos de configuração (nada muito complicado) e o programa bossac.exe encontrado nas pastas de instalação da IDE do Arduino. Aqui link explicativo (figuras auxiliares abaixo).




    Programa e exemplo do arquivo bat, aqui (eu coloquei a pasta bossa no C:\ e não usei a localização da IDE do Arduino).


  CÓDIGOS EXEMPLOS EM C PARA O ARDUINO DUE (sob a licença Beerware)


  • Programa Pisca LED: pisca o LED ligado ao pino 13 (PB27). Apresenta as rotinas de atraso, tão importantes em programação: atraso_ms( ), atraso_us( ) e atraso_loops( ). Código das funções em assembly, funções aferidas com o uso de um osciloscópio.
  • Programa para controle de LCDs 16x2 (controlador HD44780 pino RW aterrado): Apresenta as funções para inicialização e trabalho com esses LCD, incluindo a função para conversão de um número inteiro em seus dígitos individuais.
  • Programa teste do RTC (Relógio de Tempo Real): uso do RTC interno do ATSAM, ajuste de horas com a leitura de botões, tempo apresentado em um LCD 16x2.
  • Programa para uso da UART ligado ao conversor USB/serial do Arduino Due: teste e funções de transmissão e recepção de dados, incluindo um buffer de recepção com tamanho ajustável. As mensagens podem ser recebidas em qualquer terminal virtual em um PC.
  • Programa teste do ADC usando um sensor LM35 e o sensor interno de temperatura: leitura da tensão gerada por um LM35 e pelo sensor interno do ATSAM, resultado enviado ao computador usando a UART. (Obs.: cuidado, ao habilitar o sensor interno de temperatura AD15, o pino PB27 é desabilitado!!! Pergunte à ATMEL o porquê ..., parece que alguns chips já foram corrigidos!? Referência nula a esse problema apresentada pela ATMEL!)
  • Programa para teste do uso dos TIMERs (TCs): emprega a interrupção do TC0 e seus 3 canais. O estudo inicial dos TCs é confuso e este programa ajuda a entender como utilizá-los. O LED ligado ao pino PB27 troca de estado a cada estouro do TC correspondente.
  • Programa para o uso do MAX7219 (driver para displays de 7 segmentos): testado com um módulo made in China. Este CI é bem interessante.
  • Programa para o LCD NOKIA 5110 (gráfico 48x84 pixels): funções de trabalho para esse display fácil de utilizar e barato, adaptação do código para a IDE do Arduino da Sparkfun. Permite escrever mensagens e imprimir figuras. Inclui programa para gerar os dados da imagem e arquivos auxiliares. Fiz algumas funções para gráficos, só fiz o preenchimento para o retângulo. Produzir uma biblioteca gráfica é relativamente complicado, então aproveite.
         //Funções do Borges:
        desenha_pixel(...)
        desenha_linha(...)
        desenha_circulo(...)
        desenha_retangulo(...)
        desenha_triangulo(...)
        desenha_figura(...)

        escreve_Nr_Peq(...)
      

Tutorial de Como Utilizar um Multímetro

  Esse material encontrei no baú do passado, explica o funcionamento básico de um multímetro. Finalmente, o ator dá seu show!




Criando Componentes no PROTEUS e uma PCI Simples

 Nos vídeos que seguem apresento de forma sucinta como desenhar uma placa de circuito impresso no software PROTEUS. Abaixo link para download de material explicativo de como desenhar uma PCI.



DOWNLOAD PROJETO DE PCIs



Sensor de Temperatura LM35 na IDE do Arduino

   Tenho visto algumas coisas bizarras relativas a programação do LM35 na IDE do Arduino. Então, resolvi apresentar um código mais elegantes aos robistas.
   O primeiro ponto é a tensão de referência que deve ser empregada pelo conversor AD do ATmega328 (o microcontrolador do Arduino), que deve ser ajustada para 1,1V e não 5V como visto por aí. Melhorando a resolução da conversão significativamente.
   O segundo ponto é a equação de transformação que deve converter o número digital puro do AD para o valor de temperatura, utilizar ponto flutuante é deveras péssimo em termos de desempenho e consumo de memória.
   Os detalhes técnicos podem ser encontrados no meu livro AVR e Arduino: Técnicas de Projeto, Seção 19.4, para aqueles que apenas gostariam de usar o código, segue comentado.

   
//LEITURA DE TEMPERATURA COM O LM35
//sensor no pino A4

unsigned int valor_temp=0;

void setup()
{
   Serial.begin(9600); 

  //definicao da tensão de final de escala para a conversao (1.1V)
   analogReference(INTERNAL);   
}

void loop()
{
   //equacao de conversao otimizada 
   valor_temp = analogRead(A4) + analogRead(A4)*19/256;   

   Serial.print("Temperatura = ");
   Serial.print(valor_temp/10); 
   Serial.print(".");
   Serial.print(valor_temp%10); 
   Serial.write(186);
   Serial.println("C");

  delay(1000);
}

/* O LM35 apresenta uma saída de 10mV/°C. O valor de leitura do AD é dado por ADC = Vin*1024/Vref, como Vref = 1,1V, para converter o valor do AD para graus Celsius, é necessário multiplicar o valor ADC por 1100/1024 (considerando uma casa decimal antes da vírgula). Utilizando a simplificação matemática e mantendo a variável temperatura com 16 bits, resulta: 1100/1024 = 1 + 19/256 */

Gerando Tons DTMF com o Arduino

   A pedido, analisei brevemente o application note AVR314:DTMF Generator, da Atmel, que explica como usar um AVR para gerar tons DTMF. Pesquisando na rede encontrei alguns códigos que me auxiliaram. Dessa forma, fiz apenas uma organização e adequação desses programas para o ATmega328P do Arduino. Nao fiz nenhuma análise do sinal produzido, apenas um teste rápido para verificar o funcionamento do código.

   O programa foi desenvolvido em C no Atmel Studio e empreguei o meu Shield com teclado em conjunto com um buzzer para o teste

DOWNLOAD AQUI - DTMF_Generator

Técnicas de Multiplexação

   Neste post, algumas técnicas importantes de multiplexação são apresentadas. Elas são utilizadas para diminuir o número de componentes externos ao microcontrolador e/ou número de I/Os necessários. Trata-se de técnicas de multiplexação de sinais para emprego em displays, acionamento de conjuntos de LEDs (matriz e cubo) e outros dispositivos eletrônicos.
   Quando são necessários vários pinos de I/O para o acionamento de um determinado circuito e o microcontrolador não os dispõem, é fundamental o emprego da multiplexação: técnica para transitar com vários dados em uma mesma via ou barramento. A multiplexação também é empregada para diminuir o número de vias e pode diminuir a complexidade física das placas de circuito impresso. 
   A ideia da multiplexação é dividir as atividades no tempo, empregando o mesmo meio físico para isso. A desoneração do hardware é substituída por um aumento na complexidade do software de controle e no tempo de execução das tarefas. Entretanto, devido à considerável velocidade de processamento dos sistemas envolvidos, geralmente isto não é um problema. As melhores técnicas de multiplexação empregam o menor número possível de componentes externos para cumprir as funções que devem ser desempenhadas pelo hardware.
   A seguir disponibilizo o capítulo 11 do livro AVR e Arduino: Técnicas de Projeto. Existem outras técnicas de multiplexação que podem utilizar o conversor AD, o comparador Analógico, ou um sinal PWM de um microcontrolador, mas isso é um assunto para outra ocasião.


DOWNLOAD AQUI -> Técnicas de Multiplexação.



RTOS

   Este post trata de uma importante ferramenta de programação para desenvolvimento de projetos de mais alto nível, os sistemas operacionais de tempo real - RTOS, compatíveis principalmente com arquiteturas de 32 bits. Entretanto, com o desenvolvimento de novos firmwares e com a maior disponibilidade de memória, os microcontroladores de 8 bits podem suportar sistemas operacionais mínimos e ainda apresentar desempenho satisfatório. A utilização de um RTOS se justifica pelas facilidade de programação, permitindo a solução de problemas complexos, difíceis de tratar com a programação convencional. Assim, com algum sacrifício de desempenho, pode-se utilizar um RTOS em um microcontrolador de 8 bits. O uso de um RTOS com esses microcontroladores não é usual dado a limitação da CPU. Todavia, é possível utilizar sistemas mínimos que podem produzir desempenho satisfatório dependendo dos tempos de acionamento e processamento necessários para uma determinada tarefa.
   A seguir disponibilizo o capítulo 21 do livro AVR e Arduino: Técnicas de Projeto, utilizando o BRTOS para o ATmega328. Esse capítulo formaliza as definições e traz exemplos de uso da programação C com o ATMEL Studio.


DOWNLOAD AQUI ->  RTOS


O Importantíssimo Trabalho com Bits

   A programação de um microcontrolador exige o bom trabalho com bits. Dessa forma, a otimização do programa pode ser feita em qualquer acesso aos registradores de I/O (trabalho). 
   Quando se programa em C é fundamental conhecer como trabalhar com bits, assim estou disponibilizando o material básico que utilizo com meus alunos, parte do capítulo 4 do livro AVR e Arduino: Técnicas de Projeto, (O Importantíssimo Trabalho com Bits).
   Em resumo são 4 macros: set_bit( ), clr_bit( ), cpl_bit( ) e tst_bit( ). O compilador GCC para o AVR faz um bom trabalho com elas e gera o menor número de instruções Assembly possível.
   A programação microcontrolada também exige o uso direto de registradores com mascára de bits, conforme lógica de programação. Isto é visível nos programas disponibilizados no livro supracitado. Por exemplo: PORTD |= 0x0F  preserva os 4 MSBs do PORTD e ativa somente os 4 LSBs. Ao contrário de PORTD &=0x0F, que limpa os 4 MSBs. 
   Dependendo da lógica necessária, podem ser necessárias várias funções lógicas para alterar um determinado bit/conjunto em um registrador/variável.

Teclado Matricial

   Uma forma muito comum de entrada de dados em um sistema microcontrolado é através de teclas (botões ou chaves tácteis). Quando o número delas é pequeno, cada uma pode ser associada a um pino de I/O do microcontrolador. Entretanto, quando o seu número é grande, não é conveniente utilizar muitos pinos de I/O. Um teclado convencional emprega 3 × 4 teclas (12) ou 4 × 4 teclas (16) (fig. 1). Ao invés de se empregar 12 ou 16 pinos para a leitura desses teclados, empregam-se 7 ou 8 pinos, respectivamente.


Fig. 1 – Teclado matricial hexadecimal: 4 × 4.

   Para a leitura de teclados com várias teclas, é necessário empregar o conceito de matriz, em que os botões são arranjados em colunas e linhas, conforme é mostrado na fig. 1; o teclado é lido utilizando-se uma varredura. O pressionar de uma tecla produzirá um curto-circuito entre uma coluna e uma linha e o sinal da coluna se refletirá na linha ou vice-versa. A ideia é trocar sucessivamente o nível lógico das colunas, a chamada varredura, e verificar se esse nível lógico aparece nas linhas (ou vice-versa). Se, por exemplo, a varredura for feita nas colunas e houver alteração no sinal lógico de alguma linha, significa que alguma tecla foi pressionada e, então, com base na coluna habilitada, sabe-se qual tecla foi pressionada. Nesse tipo de varredura, o emprego de resistores de pull-up ou pull-down nas vias de entrada é fundamental, visto que para a leitura as entradas sempre devem estar em um nível lógico conhecido. Na fig. 2, dois teclados com resistores de pull-up e pull-down são ilustrados, onde o sinal de varredura é aplicado às colunas, as saídas do sistema de controle.

Fig. 2 – Teclados com resistores de pull-up (a) e pull-down (b) para as entradas do sistema de controle. A varredura é feita nas colunas.

   Nos microcontroladores ATmega, a conexão de um teclado é facilmente obtida, pois existem resistores de pull-up habilitáveis em todos os pinos de I/O. Assim, um possível circuito para o trabalho com um teclado é apresentado na fig. 3. Um código exemplo de uma função para leitura desse teclado pode ser encontrado nos programas do meu livro (aqui neste post).

Fig. 3 – Teclado 4 × 4 controlado pelo ATmega328.

Obs.: Este material foi adaptado do capítulo 8 do livro AVR e Arduino: Técnicas de Projeto. 

Fonte Analógica de Tensão

Este é o projeto de um fonte linear simples, baseada em circuitos integrados reguladores para uma corrente máxima de 1A. São empregados os CIs 7805, 7812, 7912 e LM317, para as tensões respectivas de: 5V, 12V, -12V e variável. Na montagem da PCI os reguladores podem ser empregados conforme conveniência, por exemplo, se desejado, a fonte pode ter somente uma saída de tensão ajustável. Nesse caso, é necessário utilizar os componentes para essa regulagem de tensão.

Downloads: circuito, lista de componentes, PCI_botton (pdf), PCI_silk (pdf) e PCI_completa (gerber).

As fotografias da montagem podem ser vistas abaixo. Foi complicado colocar todos os componentes na caixa patola, principalmente os dissipadores de calor. A furação e adequação da caixa aos diferentes componentes também foi bastante trabalhosa. 

Deve-se tomar cuidado na montagem dos dissipadores, pois os reguladores 7912 e LM317 não possuem sua carcaça metálica ligada ao terra, o que exige o uso de isoladores entre eles e o dissipador de calor.

Para evitar torções desnecessárias e possível quebra, na montagem é interessante realizar a solda dos fios na posição que ficarão dentro da caixa. O uso de "espaguete" termo retrátil ajuda na organização da fiação.

Utilizei um galvanômetro para a visualização da tensão variável. Para limitar a corrente do galvanômetro empreguei uma resistência de 30kOhms em série com um dos seus terminais. Foi necessário desenhar a escala conforme posição do potenciômetro de ajuste.

 Montagem da PCI com detalhe dos dissipadores.

 Vista áerea do cabeamento do transformador.
 PCI, chave ON/OFF e conectores 12V e -12V.
 PCI fixada.

 Vista do cabeamento, abaixo da PCI.
 Ligação dos terminais frontais (5V e variável).
 Já com o LED sinalizador montado.
 Com o porta fusível.
Com o galvanômetro.
Gran Finale.



 
Faltaram os pézinhos de silicone e os rótulos das tensões. Fica para segunda-feira.


Programação C para Arduino

Na data de 26/05/2013 fiz uma breve introdução à programação C para Arduino no The Developer´s Conference (TDC2013), aqui em Florianópolis. A apresentação é apenas um indicativo do que foi falado. Download na figura abaixo.



uGame

   Este projeto foi desenvolvido para a programação básica de jogos, foi baseado em um projeto que encontrei em um site japones (http://nicotak.com/avr/ledgame.html). O hardware emprega 4 matrizes de 8x8 LEDs (pixel quadrado) e o 74HC595 para a expansão de I/O, o circuito pode ser visto aqui. Infelizmente a placa de circuito impresso foi desenvolvida com um erro na posição das matrizes de LEDs (tenho certa culpa no processo). Dessa forma, necessitei fazer uma placa de correção. Assim, não estou disponibilizando o seu desenho (se alguém o desejar, é só me escrever).

   Fiz um programa básico onde realizo a varredura da matriz de LEDs dentro de uma interrupção do timer do ATmega328 (microcontrolador utilizado), o que resultou em torno de 750 bytes de programação.

   A matriz de LEDs é mapeada no programa por um vetor de 16 posições com 16 bits cada (unsigned int), o que permite a qualquer momento escrever em qualquer pixel da matriz. Por incrível que possa parecer, dada a estrutura da matriz, utilizar variáveis de 16 bits em detrimento as de 8 bits (no caso do ATmega), resultou em um código mais eficiente.

   Também fiz algumas rotinas de som, o que permite tocar algumas notas músicais de forma simples.

   Como gosto de aproveitar o hardware, acabei incluindo um sensor de tempertura (LM35). Dessa forma, utilizo um filtro de média móvel de 64 amostras para a suavização da leitura.

   O programa demo é quase uma pintura, pelo menos nas funcionalidades básicas, vale a pena analisá-lo (download aqui).

   Desenvolvi o jogo da cobra, adaptação daquele antigo jogo de celular onde uma cobrinha vai comento os pixels e aumentado de tamanho. Nessa parte da programação, a coisa já ficou mais confusa e menos otimizada. Criei um vetor que armazena as coodenadas XY da cabeça da cobra a cada passo e permite aumentar e movimentar a cobra. No vídeo abaixo é possível ver a funcionalidade do jogo.

   Em resumo, a necessidade de desenvolver algoritmos diferentes de acordo com o jogo é bem desafiadora, e sem dúvida, é necessário um bom projeto para um jogo bem programado. 

   Um aprendizado dessa brincadeira: quanto mais elegante forem as funcões desenvolvidas, mais fácil é criar o restante da programação, a lógica do jogo.