XYZ Turbo

Nas duas primeiras postagens sobre AVR mostrei configurações de portas e timer trabalhando no modo CTC , nesta postagem mostrarei o timer trabalhando como PWM (Pulse-width modulation). O PWM é amplamente usado em micro controladores para controle de motores, lampadas, temperatura e inúmeros dispositivos. Se você chegou aqui direto, é aconselhável ler o  post sobre portas  primeiro e depois o post sobre timers , para entender como fazer o controle de registradores e como timers trabalham.

  Na primeira postagem sobre programação AVR mostrei como os registradores trabalham e como setar portas. Nesta postagem irei mostrar como os Timers trabalham, Timers são o coração dos micro controladores, com eles é possível ter controle de tempo e controlar portas PWM  o que gera uma imensa flexibilidade de trabalho Se você chegou aqui direto, é aconselhável ler o post sobre portas primeiro para entender como fazer o controle de registradores.

  A maioria dos Arduinos, principalmente os primeiros lançamentos usam um micro controlador da linha ATMega em suas placas. O que a Arduino fez foi deixar a placa com pinos de fácil acesso, criar um bootloader onde é possível carregar o firmware de forma fácil via USB-Serial e criar uma interface IDE com bibliotecas de fácil entendimento. Mas lá no fundo de todo processo o que está rodando são programações AVR. Na programação AVR fora do Arduino,  o processo de carga de firmware é feito via serial SPI . Vou mostrar aqui em três, quatro ou até mais postagens do básico de uma programação em AVR, será  aquele norte para qualquer um que queira se aventurar e depois poder aprofundar sozinho, porém usando uma placa e IDE Arduino para ficar um pouco mais fácil.

  Algum tempo atrás fiz uns testes em um 74HC595 em conjunto com um microcontrolador ATmega 328. Utilizando a mesma lógica que foi baseada neste tutorial, refiz o processo utilizando um Arduino. O 74HC595 pode ser utilizado para expandir as portas digitais do Arduino, ele recebe um byte (8bits) serial e escreve em 8 saídas paralela. Para fazer isto ele utiliza apenas 3 portas do Arduino, não importando a quantidade de portas que se deseja na saída. É possível colocar na saída quantas portas desejar, cascateando um CI em outro.

Na postagem anterior detalhei como fazer acessos de entrada / saída na GPIO em baixo nível. Existem algumas bibliotecas na internet que facilitam este acesso e não deixam de ser um acesso em baixo nível trabalhando através de funções. Neste caso eu destaco duas, uma mais simples e outra mais completa, a do site Muddy Engineer e a mais famosa do Mike McCauley que curiosamente leva o nome do processador do RPi BCM2835.

Quando comprei meu primeiro Raspberry Pi e fiz alguns testes com a GPIO minha ideia era acessar a GPIO em baixo nível. Como em microcontroladores, no Raspberry Pi a programação em baixo nível é feita por acesso a registradores, que é o acesso a memoria. Porem em microcontroladores é possível ter acesso a recursos de CPU, no Raspberry o acesso fica restrito a periféricos, incluindo a GPIO. Mas qual é a diferença em programar em baixo nível ou através de bibliotecas? No Raspberry Pi as bibliotecas mais famosas são em Python, a gpiozero e a RPi.GPIO.

Esta ultima parte do projeto foi basicamente toda a montagem. Começando pelos botões, usei uma placa universal soldando os micro switch e depois aterrando os pinos de cada um. O próximo passo foi soldar um fio em cada pino deles para seu respectivo pino da GPIO, para quando fossem acionados fazer o terra e assim o Pi Zero reconhecer como comando. Nas fotos abaixo segue o teclado com os micro switch e ele no lugar já com os fios soldados no Pi Zero.

Nesta segunda parte do projeto fiz os testes de usar os botões com micro switch pela GPIO, saída de áudio também pela GPIO e imprimi o case. O case ficou perfeito para a tela que tenho, encaixou com precisão milimetrica, imprimi também (em laranja) um apoio para a tela que servirá de apoio para a placa de controle da tela e será onde parte do case traseiro será parafusado. Abaixo segue algumas fotos da impressão:

Para comemorar os 30 anos do Game Boy resolvi iniciar um projeto que já tinha em mente fazia algum tempo. A ideia básica é usar um case parecido com o do Game Boy impresso em impressora 3D e colocar um Pi Zero rodando emuladores através do Retropie. Conversando sobre eletrônica Quando comecei a mexer com eletrônica lá pelos fins dos anos 80, fazer um projeto significava desenhar a placa de CI, corroer a placa, soldar todos os componentes, medir, ajustar, medir de novo, queimar componente, trocar componente e assim chegar a um projeto final. Isso se já achasse o projeto do circuito pronto, caso contrario ainda teria que desenvolver o circuito também. Hoje a eletrônica está completamente modular, em cima de uma ideia você pode comprar pequenas placas montadas com o que você precisa e basta uni-las para seu projeto. E é exatamente isso que irei fazer aqui.

Desde que imprimi e passei a usar este case para meu Retropie fiquei pensando em uma forma de fazer com que o botão power ficasse funcional. A ideia era modificar o desenho de forma que o botão movesse para atuar uma chave. Porém por fim, acabei optando por uma ideia melhor, onde não precisei fazer modificação no case. Usando um 555 no modo mono estável fiz uma chave de toque. Circuito

O RPi não possui entradas analógicas, não sendo possível ler diretamente valores analógicos. Uma forma de fazer leituras analógicas é usar um ADC como o MCP3008 mostrado aqui . Outra forma nem tanto precisa, porém mais simples e barata, é usar um capacitor em conjunto com o circuito. O funcionamento consiste em um contador definido pela carga do capacitor até ele chegar à tensão de 1,4V. Porque a partir de 1,4V o RPi considera nível alto na entrada. Com isto temos um parâmetro para trabalhar, que vai de 0 a X, onde o valor de X dependerá do circuito montado. Aumentando o valor do capacitor teremos um tempo de resposta menor, porem uma resolução maior e com um de menor valor temos um tempo de resposta rápido, mas com a resolução menor. No exemplo foi usado um capacitor de 1uF e um potenciômetro de 50k ohms onde o valor lido foi de 0 a 2700 aproximadamente. No exemplo abaixo, o loop (while True:) roda a função RCtime, onde inicialmente o pino 24 estará como uma saída em nível baixo fecha...

Nas postagens anteriores, mostrei como trabalhar com entradas e saídas na GPIO do RPi através do modulo GPIO.RPi e Python. Nas saídas podemos também trabalhar com PWM . No RPi se compararmos com o Arduino, temos um controle melhor, já que podemos alterar afreqüência também. Para começar, primeiro precisamos criar a instancia PWM com: p = GPIO.PWM (channel, frequency) Onde channel será o pino usado e frequency a freqüência PWM em HZ. Para iniciar o PWM usamos: p.start(dc) Onde dc é o duty cycle (ciclo de trabalho) que varia de 0 a 100. Para parar o PWM usamos: p.stop() Para alterar a freqüência usamos: p.ChangeFrequency(freq) Onde freq é a freqüência usada. Para alterar o ciclo de trabalho usamos: p.ChangeDutyCycle(dc) Onde novamente dc é o ciclo de trabalho de 0 a 100.

Comentei aqui que é possível ligar o RPi fechando temporariamente o pino 5 (GPIO3) para o terra. Com um simples programa em Python e o modulo RPi.GPIO instalado, podemos desligá-lo também da mesma forma. Vimos aqui , aqui e aqui como trabalhar com a interface GPIO. Utilizando o modulo subprocess.call em conjunto com as instruções de porta de entrada da GPIO, podemos fazer um programa como o abaixo. Onde através do modulo subprocess.call podemos rodar um comando bash pelo Python. Neste caso chamaremos o comando halt que desliga o RPi.

No post anterior vimos como trabalhar com entradas da GPIO em polling. Aqui veremos como fazer o mesmo porém com interrupções, o que não ocupa muito recurso do processador. Não esquecer que as entradas trabalham apenas com 3,3v, portando não confundam em ligar nas entradas 5V, que também estão disponíveis na GPIO. Para o RPi temos interrupções por detecção de borda (subida, descida e mudança). Em um primeiro exemplo usaremos um try/except, onde o programa fica em espera por alguma ação. A ação no caso será a wait_for_edge ou aguardando pela borda, neste exemplo ele fica esperando uma borda de subida (GPIO.EDGE) Apertando o botão ele mostra na tela "Entrada em nível alto" e sai. Ou pressionando CRTL+C sai do programa direto. O circuito usado é o abaixo: Aqui o programa:  

Depois dos testes com saídas , iniciei os testes com as entradas. Para quem chegou direto aqui, recomendo antes ler os testes com saídas . Uma informação importante é que as entradas trabalham apenas com 3,3v, portando não confundam em ligar nas entradas 5V, que também estão disponíveis na GPIO. Irei dividir o assunto de entradas em mais de uma parte para o texto não ficar muito extenso. Primeiro precisamos saber que caso algum pino seja designado como entrada ele precisa ter algo conectado, caso contrario a entrada irá “flutuar”, reportando erros de leitura. Uma forma de não deixar a entrada flutuando é usar um resistor de pull-up ou pull-down. No RPi isto pode ser feito via hardware ou software. Via hardware basta ligar um resistor de 10k ohms do pino desejado para o 3,3V (pull-up) ou para o terra (pull-down). Via software basta na hora de definir as entradas colocar pull_up_down=GPIO.PUD_UP ou pull_up_down=GPIO.PUD_DOWN. Para definir as entradas é usada a mesma função que definimos ...

Primeiro, descobri que após desligar o RPi, ele fica em um estado stand by. Caso queira ligar ele novamente sem retirar e recolocar o cabo usb, basta fechar um curto rápido nos pinos 5 e 6 da GPIO. Após os testes iniciais , parti para o que realmente me interessa que é a interface GPIO. A programação da interface é feita em Python, e para isso é necessário instalar a biblioteca RPi.GPIO. Ela funciona de forma bem parecida com a programação em C do Arduino. Para a instalação use os comandos: sudo apt-get update sudo apt-get install python-dev sudo apt-get install python-rpi.gpio