Comunicação Conselho a Conselho

Neste laboratório, você estabelecerá canais de comunicação baseados em UART entre as placas Pi 4 e HiFive 1.

Parte 0:Configurar as conexões UART (para TAs)

Nesta parte, conectaremos as placas HiFive1 e Raspberry Pi 4 por meio de dois canais UART.

(Observe que esta etapa será realizada pelos TAs.)

O Pi 4 possui 4 UARTs e usaremos dois deles (uart2 e uart3). Adicione a seguinte linha no final do arquivo /boot/config.txt para habilitar uart2 e uart3.

dtoverlay =uart2,115200 dtoverlay =uart3,115200

Após reinicializar o sistema, / dev / ttyAMA1 e / dev / ttyAMA2 serão criados.

Conecte o UART1 RX do HiFive (pino 7) ao UART2 TX do Raspberry Pi 4 (pino 27). Esta é a principal linha de comunicação entre o Pi 4 e o HiFive1. A partir do Pi 4, você pode acessar o canal via / dev / ttyAMA1.

Para depuração de HiFive 1, conecte HiFive1 UART0 TX (pino 1) ao Pi 4 UART3 RX (pino 29). A partir do Pi 4, ele pode ser acessado via / dev / ttyAMA2.

Em resumo, você poderá acessar os dois arquivos a seguir do Pi 4.

/ dev / ttyAMA1 Pi 4 → HiFive1:Envia o ângulo de direção para HiFive1 (uart1).

/ dev / ttyAMA2 HiFive1 → Pi 4:Recebe a saída do console HiFive1 (uart0)

Parte 1:Programação do HiFive1

Nesta parte do laboratório, você irá programar o HiFive1 para receber dados do Pi 4.

No seu PC (não Pi 4), baixe o esqueleto do projeto como segue.

$ Cd ~ / Documents / PlatformIO

$ Wget https://ittc.ku.edu/~heechul/courses/eecs388/l10-comm.tar.gz

$ Tar zxvf l10-comm.tar.gz

Adicione a pasta l10-interrupt no espaço de trabalho VSCode.

Sua tarefa é receber os dados do canal UART1 do HiFive1 e enviar os dados recebidos para o canal UART0. O que se segue é um pseudocódigo aproximado da tarefa.

enquanto (1) {

if (o UART1 está pronto?) {dados =lidos do UART1. imprimir dados para UART0.

}

} Para implementar a tarefa, pode ser necessário usar a API serial fornecida mostrada a seguir. Observe que devid é 0 para acessar UART0, enquanto é 1 para acessar UART1.

void ser_setup (int devid); int ser_isready (int devid);

void ser_write (int devid, char c);

void ser_printline (int devid, char * str); char ser_read (int devid);

int ser_readline (int devid, int n, char * str);

Em particular, você pode precisar usar a função ser_isready () para verificar se um determinado canal UART tem dados pendentes para ler. Para entender melhor o que as funções estão fazendo, verifique os arquivos eecs388_lib.h e eecs388_lib.c.

int ser_isready (int devid)

{

uint32_t regval =* (volátil uint32_t *) (UART_ADDR (devid) + UART_IP); return regval;

}

Assim que terminar de programar o HiFive1, mude para o Raspberry Pi 4 e abra dois terminais:um para enviar dados ao HiFive1 e outro para ver a saída da mensagem de depuração do HiFive1.

Terminal do remetente (term1)

$ Screen / dev / ttyAMA1 115200

Terminal de depuração (term2)

$ Screen / dev / ttyAMA2 115200

Agora, digite quaisquer strings no ‘term1’.

Se você programou seu HiFive 1 corretamente, deverá ver a mensagem que sai do terminal ‘term2’.

Parte 2:Programando o Raspberry Pi 4.

Em vez de usar terminais, agora você executa um programa python no Pi 4 para se comunicar com o HiFive1. Sua tarefa é estender o dnn.py do laboratório anterior para poder enviar a saída de direção ao canal serial / dev / ttyAMA1. O seguinte pseudocódigo fornece uma ideia geral das modificações que você precisará fazer no dnn.py:

Abra as conexões seriais para / dev / ttyAMA1 e / dev / ttyAMA2 enquanto True:

image =camera.read ()

angle =dnn_inference (image) Escreva ‘ângulo’ em / dev / ttyAMA1 Wait_till_next_period ()

Fechar conexões seriais

Para obter a funcionalidade acima, você precisa usar a API pySerial do Python, que pode ser usada importando o pacote serial:

import serial

Com ele, você deve criar dois canais seriais separados, um para escrever no HiFive1 sobre

/ dev / ttyAMA1 e outro para depuração em / dev / ttyAMA2. Observe que ambos os canais devem ser abertos com a taxa de transmissão de 115200 bps.

ser1 =serial.Serial (...) ser2 =serial.Serial (...)

Os ângulos recebidos do DNN à medida que ele processa os quadros podem ser enviados para o HiFive1 usando a função serial write ():

ser1.write (...)

No entanto, write () requer um valor de byte enquanto o ângulo produzido pelo DNN é um valor float32, então você terá que converter os dados do ângulo para enviá-los ao HiFive1. Finalmente, depois que todos os quadros são processados, as conexões seriais podem ser fechadas invocando a função close () serial:

ser1.close () ser2.close ()

Apêndice

Mapeamento GPIO de Pi 4.

Pinagem Raspberry Pi 4

Não apenas o Raspberry Pi 4 está repleto de novos recursos de hardware, mas também sob o capô, há algumas funções extras do GPIO para tornar a vida um pouco mais fácil, permitindo que os usuários expandam seus periféricos para seus projetos sem a necessidade de hardware adicional. Interfaces I2C, UART e SPI que podem ser usadas no Raspberry Pi 4.

Pinagem GPIO

Você pode encontrar uma lista completa de pinagens GPIO no próprio Raspberry PI 4, simplesmente vá para a linha de comando e digite pinagem .

Abaixo está uma lista de todos os novos recursos de pinagem extra do Raspberry Pi 4:

GPIO - Pinos de entrada e saída de uso geral

Esses pinos digitais podem ser programados para receber entradas digitais ou emitir um sinal digital. O Raspberry Pi usa uma lógica 3V3 em cada pino GPIO, o que significa que 3V3 é digital 1 (ON) e 0V é digital 0 (OFF). Portanto, você pode conectar um componente digital ao Raspberry Pi e fornecer um sinal 3V3 (LIGADO) a ele ou receber um sinal digital 3V3, desde que a corrente não seja superior a 16mA.

I2C - Circuito Inter-integrado

Este é um tipo de comunicação bastante comum entre dispositivos, funciona tendo um mestre e um escravo. O mestre, neste caso, é o próprio Raspberry Pi e os dispositivos escravos são periféricos de hardware que normalmente estenderiam a funcionalidade de seus projetos. O que é ótimo sobre o I2C é que você pode conectar centenas de dispositivos ao mesmo mestre usando a mesma interface de dois fios, desde que cada dispositivo tenha um endereço I2C diferente. Você pode acessar a interface e ver quais dispositivos estão conectados usando o seguinte comando do Linux:

sudo i2cdetect -y 1

Onde “1” é a interface mestre. O Raspberry Pi 4 tem 6 no total.

SPI - Interface Periférica Serial

SPI é outro tipo de protocolo de comunicação para comunicação entre dispositivos. Ele também usa uma configuração mestre / escravo, mas é usado principalmente em distâncias curtas entre um controlador principal (mestre) e dispositivos periféricos (escravos), como sensores. O SPI normalmente usa 3 fios para se comunicar com o Raspberry Pi; SCLK, MOSI e MISO. Antes de usar o SPI, você precisa ativá-lo no menu de configuração do Raspberry Pi:

UART - Receptor / transmissor assíncrono universal

Ao contrário de I2c e SPI, UART não é um protocolo. UART (Serial) é um circuito físico projetado para transmitir e receber dados seriais. O UART não requer um sinal de clock, por isso é assíncrono. Isso minimiza a necessidade dos fios para enviar e receber dados, mas também requer que alguns dados extras sejam enviados com os pacotes para verificação de erros, como um bit de início e um bit de parada. Normalmente, com relação ao Raspberry Pi, o UART é usado em uma configuração sem periféricos, o que significa que não há GUI ou outra interface. Em vez disso, você pode conectar o Raspberry Pi ao seu desktop / laptop ou outro dispositivo e comunicar-se com ele pelo UART usando a interface de linha de comando. Este método é para usuários mais avançados, pois requer um pouco mais de conhecimento para configurá-lo.

Outra aplicação típica entre os usuários do Raspberry Pi é conectar uma placa Arduino UNO ao Raspberry Pi, uma vez que o Pi tem funcionalidade analógica limitada.