Programação simultânea Attiny85 ou abóbora com olhos multicoloridos: 7 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Por jumbleviewJumbleview.infoFollow Mais do autor:

Sobre: Eu trabalho como engenheiro de software em uma das empresas da Bay Area (Califórnia). Sempre que tenho um tempo, gosto de programar microcontroladores, construir brinquedos mecânicos e fazer alguns projetos de reforma. Mais sobre o jumbleview »

Este projeto mostra como controlar dois LEDs de ânodo comum de três cores de 10 mm (olhos multicoloridos de Pumpkin Halloween Glitter) com chip Attiny85. O objetivo do projeto é introduzir o leitor na arte da programação simultânea e no uso da biblioteca de protothreads de Adam Dunkels. Este projeto pressupõe que o leitor conheça os controladores AVR de 8 bits, possa escrever algum programa C e tenha alguma experiência com o Atmel Studio.

Código do projeto publicado no GitHub:

Suprimentos

Antes de programar, ainda é necessário construir o circuito. Aqui estão os componentes:

• Controlador Attiny85 (qualquer fornecedor eletrônico).
• Dois LEDs de três cores de 10 mm com ânodo comum. LEDs Adafruit
• Resistores 100 Ohm, 120 Ohm, 150 Ohm 0,125 ou 0,250 Wt (qualquer fornecedor eletrônico).
• Cabeçalho de seis pinos para interface AVR ISP. Pode ser feito com este cabeçalho Adafruit
• Um pouco de placa de pão ou placa de modelo impresso. Eu usei este
• Interface AVR ISP MKII e Atmel Studio 6.1 (a versão posterior também deve funcionar).

Etapa 1: Circut

O design usa cinco pinos de chip:

• Dois pinos usados para controlar os ânodos: cada ânodo de LED conectado ao pino dedicado.
• Três pinos ligados (através de resistores) aos cátodos de LEDs (cátodo da mesma cor de cada led ligado ao mesmo pino)

Alguém poderia perguntar: por que não usar todos os seis pinos de entrada / saída do chip para que os ânodos de LED sejam conectados diretamente a +5 v e cada cátodo tenha seu pino dedicado? Isso tornará a programação direta. Infelizmente, aí está o problema: o pino PB5 (RESET) é um pino fraco capaz de fornecer apenas ~ 2 mA de corrente, embora seja necessário ter ~ 20 mA.

Claro que se pode construir um amplificador de transistor para este pino fraco, mas eu mesmo sempre que possível prefiro resolver o problema através do código.

Etapa 2: Diagrama de tempo

O diagrama de tempo nos ajuda a entender o que precisamos programar.

As duas primeiras linhas do diagrama mostram a mudança de tensão nos ânodos de LED. A tensão nos pinos conectados a ânodos de LED oscila com frequência de ~ 250 Hz. Esta oscilação de tensão para o LED esquerdo é oposta à oscilação do LED direito. Quando a tensão no ânodo é alta, o LED correspondente pode acender. Quando está baixo, o LED correspondente fica escuro. Isso significa que cada LED pode ficar brilhante durante um intervalo de 2 milissegundos e escurecer durante outros 2 milissegundos. Como o olho humano tem alguma inércia, o piscar de 250 Hz não é perceptível pelo observador. As três linhas inferiores do diagrama mostram a mudança de voltagem nos pinos conectados aos cátodos dos LEDs. Vejamos a primeira coluna do diagrama. Mostra o caso em que o LED esquerdo está na cor vermelha e o LED direito na cor verde. Aqui, os cátodos RED permanecem baixos enquanto o ânodo esquerdo está alto, o cátodo VERDE permanece baixo enquanto o ânodo direito está alto e o cátodo AZUL permanece baixo o tempo todo. Outras colunas no diagrama mostram combinações de voltagem de cátodo e ânodo para várias cores.

Como podemos ver, há interdependência no estado dos pinos. Sem alguma estrutura, não seria fácil resolver. E é aí que a biblioteca protothread se torna útil.

Etapa 3: Programação. Macros e Definições

Exemplo em etapas de programação representam uma versão ligeiramente simplificada. O programa é reduzido e algumas definições simbólicas são substituídas por constantes explícitas.

Vamos começar do início. O programa inclui arquivos que vêm com o Atmel Studio, bem como o cabeçalho da biblioteca protothread. Em seguida, existem duas macros para manipular os níveis dos pinos e algumas definições para dar nomes lógicos aos sinais dos pinos. Até agora, nada de especial.

Etapa 4: Programação. Loop Principal

Então, vamos dar uma olhada no final para ver o que o procedimento principal contém.

A função main após fazer alguma inicialização permanece em loop eterno. Nesse ciclo, ele executa as próximas etapas:

• Invoca a rotina de protothread para o LED esquerdo. Ele muda a tensão de alguns pinos.
• Faça dois milissegundos de atraso. Não há mudança na tensão do pino.
• Invoca protothread para o LED certo. Ele muda alguma tensão do pino.
• Faça 2 atrasos de MS. Não há mudança na tensão do pino.

Etapa 5: Programação. Funções Auxiliares

Antes de começarmos a discutir os protothreads, precisamos examinar algumas funções auxiliares. Primeiro, existem funções para definir uma cor específica. Eles são diretos. Existem tantas funções como o número de cores suportadas (sete) e mais uma função para definir o LED escuro (NoColor).

E há mais uma função que será chamada diretamente pela rotina protothread. Seu nome é DoAndCountdown ().

Tecnicamente falando, o uso de tal função não é obrigatório, mas achei conveniente. Possui três argumentos:

• Ponteiro para definir a cor do LED de função (como RedColor ou GreenColor ou etc.)
• Valor inicial do contador reverso: número de quantas vezes essa função deve ser chamada em um estágio de protothread específico.
• Ponteiro para reverter o contador. Assume-se que quando há mudança na cor, esse contador reverso é 0, então, na primeira iteração, o código de iteração será atribuído a esse valor inicial do contador. Após cada iteração, o contador é diminuído.

A função DoAndCountdown () retorna o valor do contador reverso.

Etapa 6: Programação. Rotinas de Protothread

E aqui está o núcleo do framework: rotina protothread. Por uma questão de simplicidade, o exemplo está limitado apenas a três etapas: para alterar a cor para VERMELHO, VERDE e AZUL.

A função é invocada com dois argumentos:

• Ponteiro para a estrutura do protothread. Essa estrutura foi inicializada por main antes do início do loop principal.
• Ponteiro para reverter o contador. Ele foi definido como 0 por principal antes do início do loop principal.

A função define as tensões para tornar o LED esquerdo ativo e, em seguida, inicia o segmento de protothread. Este segmento está entre as macros PT_BEGIN e PT_END. Dentro há alguns códigos que no nosso caso apenas repete macros PT_WAIT_UNTIL. Esta macros executa a seguir:

• Invocação da função DoAndCountdown. Isso define a voltagem nos cátodos de LED para emitir uma cor específica.
• Resultado retornado comparado com 0. Se a condição for 'falsa', a função protothread retorna imediatamente e fornece controle para o loop principal.
• Quando o protothread é invocado na próxima vez, ele executa novamente o código antes de PT_BEGIN e, em seguida, pula diretamente para dentro das macros PT_WAIT_UNTIL das quais retornou da última vez.
• Essas ações se repetem até que o resultado de DoAndCountdown seja 0. Nesse caso, não há retorno, o programa permanece em protothread e executa a próxima linha do código. No nosso caso, é o próximo PT_WAIT_UNTIL, mas, de modo geral, pode ser quase qualquer código C.
• Na execução inicial do segundo contador reverso PT_WAIT_UNTIL é 0, então o procedimento DoAndCountdown () define-o para o valor inicial. As segundas macros serão novamente executadas 250 vezes até que o contador de reversão chegue a 0.
• O estado da struct pt é redefinido assim que o controle atinge as macros PT_END. Quando a função protothread invocada na próxima vez que o segmento protothread for iniciado, execute a linha do código logo após PT_BEGIN.

Existe uma rotina de protothread semelhante para o LED certo. Em nosso exemplo, ele apenas impõe uma ordem diferente de cores, mas se pudermos fazer isso de maneira completamente diferente: não há um acoplamento forte entre a rotina de LED esquerdo e direito.

Etapa 7: internos

O programa inteiro tem menos de 200 linhas de código (com comentários e linhas vazias) e ocupa menos de 20% da memória de código Attiny85. Se necessário, é possível utilizar aqui várias outras rotinas de protothread e atribuir uma lógica muito mais complicada a elas.

A biblioteca Protothreads é a forma mais simples de programação simultânea de computador. A programação simultânea é uma abordagem que permite dividir o programa em partes lógicas: às vezes são chamadas de co-rotinas, às vezes de thread, às vezes de tarefas. O princípio é que cada uma dessas tarefas pode compartilhar o mesmo poder de processador, enquanto mantém o código mais ou menos linear e independente de outras partes. As tarefas do ponto de vista lógico podem ser executadas simultaneamente.

Para controles de sistemas avançados de tais tarefas realizadas pelo kernel do sistema operacional ou pelo tempo de execução da linguagem embutido no executável pelo compilador. Mas, no caso de protothreads, o programador de aplicativos o controla manualmente usando a biblioteca de macros protothreads em rotinas de tarefas e invocando tais rotinas (geralmente fora do loop principal).

Você provavelmente quer saber como o protothread realmente funciona? Onde a magia está escondida? Protothreads contam com um recurso especial da linguagem C: o fato de que a instrução switch case C pode ser embutida em if ou em algum outro bloco (como while ou for). Detalhes que você pode encontrar no site de Adam Dunkels

Os componentes internos da eletrônica deste projeto são muito simples. A foto acima dá uma pista. Tenho certeza de que você pode fazer melhor.