Mobile
Quanto ao que a placa de Raspberry Pié diretamente, sabemos que ela está pronta para trabalhar com programação física de componentes eletrônicos usando seus pinos GPIO (entrada/saída de uso geral). Estes pinos de entrada/saída de uso geral são alguns dos que podem ser visualizados em duas linhas de 20 pinos. Na imagem a seguir podemos ver mais claramente o que cada pino corresponde.
Qualquer um dos pinos GPIO pode ser designado (no software) como um pino de entrada ou saída e usado para uma ampla gama de propósitos, como conectar um LED ou sensor.
Nota: A numeração do pino GPIO não está em ordem numérica; Os pinos GPIO 0 e 1 estão presentes na placa (pinos físicos 27 e 28), mas são reservados para uso avançado (veja abaixo).
Tensões
Dois pinos de 5V e dois pinos 3V3 (3.3V) estão presentes na placa, bem como vários pinos de terra (GND: 0V), que não são configuráveis. Os pinos restantes são todos pinos 3V3 de propósito geral, o que significa que as saídas são definidas para 3V3 e as entradas são tolerantes a 3V3.
Saídas
Um pino GPIO designado como um pino de saída pode ser definido como alto (3V3) ou baixo (0V).
Bilhetes
Um pino GPIO designado como um pino de entrada pode ser lido como alto (3V3) ou baixo (0V). Isso é facilitado com o uso de resistores internos pull-up ou pull-down. Os pinos GPIO2 e GPIO3 têm resistores pull-up fixos, mas para outros pinos isso pode ser configurado no software.
Mais
Além de dispositivos simples de entrada e saída, os pinos GPIO podem ser usados com uma variedade de funções alternativas, alguns estão disponíveis em todos os pinos, outros em pinos específicos.
· PWM: Pinos que suportam modulação da largura do pulso, usados para transmitir informações através de um canal de comunicação ou para controlar a quantidade de energia que é enviada para uma carga.
o software PWM disponível em todos os pinos
o Hardware PWM disponível em GPIO12, GPIO13, GPIO18, GPIO19
· SPI: O Bus SPI (Serial Periférico Interface) é um padrão de comunicação, usado principalmente para a transferência de informações entre circuitos integrados em equipamentos eletrônicos.
o SPI0: MOSI (GPIO10); MISO (GPIO9); SCLK (GPIO11); CE0 (GPIO8), CE1 (GPIO7)
o SPI1: MOSI (GPIO20); MISO (GPIO19); SCLK (GPIO21); CE0 (GPIO18); CE1 (GPIO17); CE2 (GPIO16)
· I2C: Circuito Interconteligado (I2C) é usado internamente para comunicação entre diferentes partes de um circuito, por exemplo, entre um controlador e circuitos periféricos integrados.
o Dados: (GPIO2); Relógio (GPIO3)
o Dados EEPROM: (GPIO0); Relógio EEPROM (GPIO1)
· Série: Portas de comunicação UART UART do Receptor Assíncronso Universal através do pino de transmissão TX e do pino de recebimento RX.
OU TX (GPIO14); RX (GPIO15)
Existem 2 maneiras de numerar os pinos de Raspberry Pi, no modo GPIO ou no modo BCM. Isso é importante na programação. A diferença entre essas notações é geralmente notada quando estamos controlando GPIOs com python ou outra linguagem e temos que entrar como usaremos o gpio no GPIO. PLACA OU GPIO. Bcm.
A opção GPIO. O CONSELHO especifica que está se referindo aos pinos pelo seu número, ou seja, os números impressos em nosso Raspberry Pi (por exemplo P1), na imagem abaixo mostramos-lhe pino 1 e pino 2, para continuar a numeração seria da esquerda para a direita, sendo o pino abaixo 1 pino 3, toda essa linha seria os pinos ímpares e o oposto dos pinos pares.
A opção GPIO. BCM refere-se aos pinos pelo seu número de "canal Broadcom SOC", estes não são correlativos como no modo BOARD, a imagem a seguir mostra tanto os PINs em BOARD quanto BCM das diferentes versões de Raspberry Pi, com os BCMs começando com GPIO e as unidades de controle sendo os pinos board. BMS seria por assim dizer, como numeração de processador e placas de conectores.
Para controlar o GPIO com Python, primeiro você deve importar uma biblioteca de código pré-escrita. O mais comum e difundido é o Rpi.GPIO, usado para criar milhares de projetos desde os primeiros dias do RPi.
Outra biblioteca interessante é o WiringPi,que torna os pinos mais "portáteis" de um código para outro, mais universais.
Para instalar a versão mais recente, colocamos as seguintes instruções no console:
cd /tmp
wget https://project-downloads.drogon.net/wiringpi-latest.deb
sudo dpkg -i fiaçãopi-mais recente.deb
Para ver esses pinos no Raspberry, podemos abrir o console de comando, e executar o comando: gpio readall
Como o nome sugere, ele lerá tudo o que pertence ao gpio, e nos mostrará a tabela de informações a seguir, onde você pode ver cada pino e características.
Outro comando que podemos estar interessados é: pinout. Com isso, ele nos mostrará informações mais visualmente:
Já sabemos quais são esses pinos, mas agora vamos explicar como usá-los e programar dispositivos. Você pode usar o mesmo console de comando para alterar as configurações do pino, por exemplo, ter a tensão de tração do pino 21 para ligar um LED que o tenha conectado.
Isso pode ser "programado" de várias maneiras e o mais simples é simplesmente usar comandos no console. Em primeiro lugar, conectaremos o LED ao RPi. Lembre-se que você sempre tem que ter uma resistência serial conectada, no nosso caso usaremos um Ω de 1k e um LED vermelho conectado ao pino gpio21 da seguinte forma:
O pino 40 vai para o resistor, isso vai para a acaode led, o cátodo led vai para GND, no pino 39.
Em seguida, iniciamos o RPi e abrimos o terminal de comando e executamos o comando:
ls /sys/class/gpio/
O diretório /sys é um dos muitos diretórios virtuais em nosso sistema. Não vamos encontrá-lo no cartão SD. O sistema apenas "finge" que tal diretório existe, de fato, todas as referências a arquivos nesse diretório são tratadas pelo kernel (núcleo do SISTEMA no Linux). O diretório /sys permite acessar informações sobre drivers de sistema Linux. Neste caso, olhamos para os controladores de classe GPIO, ou seja, as portas de entrada e saída.
Como você pode ver, já existem alguns arquivos neste diretório:
Por padrão, o acesso ao pino não é possível, por isso precisamos habilitá-lo. Usaremos um arquivo chamado exportação para este fim. A escrita para este arquivo fará com que o kernel nos forneça o pinout apropriado do processador. Queremos acessar o pino GPIO21, então digitamos o número 21 no arquivo /sys /class/gpio/export digitando:
echo 21 > /sys/class/gpio/export
Agora podemos verificar novamente o conteúdo do diretório /sys/class/gpio; encontraremos um novo subdiretório chamado gpio21. Seu conteúdo permitirá que você controle o comportamento do pino selecionado.
Por padrão, o pino exportado é definido como entrada (in ). Queremos controlar um diodo, então precisamos de uma saída. Precisamos mudar o endereço do pino. Para isso, basta escrever no arquivo / sys / classe / GPIO / gpio21 / direção:
eco out > /sys/class/gpio/gpio21/direction
A partir de agora, podemos controlar o diodo digitando os valores no arquivo de valores.
Para ligar o diodo, emitimos o comando:
echo 1 > /sys/class/gpio/gpio21/value
Portanto, para desligá-lo com 0:
echo 0 > /sys/class/gpio/gpio21/value
Quando terminarmos os experimentos, podemos limpar, ou seja, desativar o acesso ao pino GPIO21. Exportamos no início, então agora precisamos desfazer essa operação:
echo 21 > /sys/class/gpio/unexport
Como você pode ver no mundo linux, tudo é um arquivo. O diretório /sys se comporta como arquivos normais no cartão SD. Podemos usar ferramentas de console padrão ou nossos próprios programas para controlar dispositivos conectados. Curiosamente, executar as amostras não exigiu programação de nós, são apenas operações normais de arquivo. Claro, este não é um método eficaz, mas em muitos casos será suficiente.
Vale ressaltar que usando o diretório de acesso/sys/class/gpio você também pode controlar pinos em outras plataformas. Essa funcionalidade é fornecida pelo kernel Linux, não depende de Raspberry Pi.
Já aprendemos o método de comunicação direta com o kernel. Esta é uma opção interessante, mas não muito eficaz e não necessariamente conveniente em alguns casos. Felizmente, o Raspberry Pi vem com algumas bibliotecas e programas muito bons que permitem acessar os pinos de forma mais eficiente. Um deles é WiringPi.
Nesta parte do curso não vamos escrever programas (apenas scripts simples), então vamos usar um programa chamado gpio - com ele você pode facilmente usar linhas GPIO do console.
Mais informações sobre o programa podem ser encontradas na extensa documentação:
gpio homem
Podemos ver na seção SINOPSE as diferentes opções de comando.
Para usar comandos com WiringPi, primeiro verificaremos a versão desta biblioteca instalada. Para fazer isso, execute gpio -v . Se o número da versão for 2.46 ou superior, então tudo bem e você pode continuar. Se você for inferior, use esses comandos para instalar uma versão mais alta, como dissemos anteriormente:
cd/tmp
wget https://unicorn.drogon.net/fiação-2.46-1.deb
sudo dpkg -i fiaçãopi-2.46-1.deb
Agora vamos com um exemplo simples de alimentação em um LED com a mesma conexão do exemplo anterior, mas desta vez no pino 12 (modo BCM), que é o nosso pino físico 32 no conector.
Como mencionado, a biblioteca WiringPi usa numeração de pinos diferentes. No entanto, você pode forçar o uso dos mesmos números do diretório /sys. Vamos manter essa numeração agora.
Para começar, definimos o pino 12 como saída, emitindo o comando:
gpio -g modo 12 fora
A opção -g gpio nos faz usar numeração de pinos de CPU.
Agora podemos desligar e ligar o LED digitando após o número do pino seu status, lógico 0 ou lógico 1, respectivamente:
gpio -g escrever 12 0
gpio -g escrever 12 1
Temos a mesma funcionalidade de antes, mas não tivemos que referenciar os arquivos diretamente, o que tornou todo o "código" mais curto.
FiaçãoPi
Claro, para o teste podemos tentar usar a numeração da biblioteca de fiação. Voltamos para a mesa de pinos (gpio readall ) e procuramos nosso pino número 12. Dependendo da numeração interna da biblioteca, ela terá o número 26.
Então podemos emitir comandos:
modo gpio 26 fora
gpio escrever 26 0
gpio escrever 26 1
Podemos verificar como a operação será idêntica.
Agora podemos controlar saídas universais. No entanto, o método de emissão de comandos manualmente não é muito conveniente. Felizmente, não temos que digitar manualmente todos os comandos no terminal.
Podemos escrever scripts que serão executados como "programas simples".
Um script é simplesmente um arquivo de texto que contém os comandos que normalmente digitamos a partir do teclado em uma janela terminal. Graças a colocá-los no arquivo, não temos que reescrever tudo, basta chamar o arquivo correspondente.
Começaremos com o mesmo exemplo extremamente simples, ligando um LED. Teremos nosso primeiro script definir o pino apropriado como saída e defini-lo alto (ou seja, ligar o LED). Claro, não faz muito sentido fazer um "programa" para algo tão simples, mas com isso vamos praticar a criação e execução do próprio script.
Primeiro, precisamos criar um novo arquivo com a extensão"sh". Por exemplo, ele pode led.sh, para isso usaremos o editor nano:
nano led.sh
Em seu conteúdo, digitamos os comandos que normalmente entrariam no console, temos que precedê-los com uma única linha: .!/Bin/sh. Então, o script que liga o diodo conectado ao pino 21 seria assim:
!/bin/sh
gpio -g modo 21 fora
gpio -g escrever 21 1
Salve o arquivo ( CTRL + X ). Em seguida, devemos conceder ao nosso roteiro as permissões apropriadas para serem tratados como um "programa". Para isso usamos chmod:
sudo chmod +x led.sh
Para executar o script, emitimos o comando:
./led.sh
Agora o LED apenas ligará. Desligá-lo exigiria um script diferente, que você pode tentar por si mesmo. Agora vamos colocar outro exemplo mais funcional, fazer o LED piscar por conta própria. Criamos um novo arquivo blink.sh:
nano blink.sh
Em seu conteúdo colamos um ciclo simples de enquanto (no momento não vamos focar na sintaxe):
enquanto verdadeiro
Faça
dormir 1
gpio -g escrever 21 0
Não
Um loop de tempo, como a tradução sugere, é que algo se repete enquanto algo é mantido. Neste caso, no modo curto, podemos ver que, desde que seja "verdadeiro" fazer (fazer) as seguintes linhas. Então ele vai enrolar o que está entre o "fazer" e o "feito".
O código acima define o pino número 21 como saída. Em seguida, mude de estado a cada segundo (durma 1). Salve o arquivo ( CTRL + X), dê-lhe as permissões apropriadas (sudo chmod + x blink.sh ). O script pode ser interrompido por CTRL+C.
Agora você pode ver como o LED pisca a cada segundo quando executá-lo.
Com base nos exemplos aqui descritos, você já tem o conhecimento para poder criar, por exemplo, uma simulação de semáforos simples.