In dit lab bouw je op UART gebaseerde communicatiekanalen tussen de Pi 4 en de HiFive 1 boards.

Deel 0:de UART-verbindingen instellen (voor TA's)

In dit deel zullen we de HiFive1- en de Raspberry Pi 4-kaarten verbinden via twee UART-kanalen.

(Merk op dat deze stap wordt uitgevoerd door de TA's.)

De Pi 4 heeft 4 UART's en we zullen er twee gebruiken (uart2 en uart3). Voeg de volgende regel toe aan het einde van het bestand /boot/config.txt om uart2 en uart3 in te schakelen.

dtoverlay=uart2,115200 dtoverlay=uart3,115200

Nadat het systeem opnieuw is opgestart, worden /dev/ttyAMA1 en /dev/ttyAMA2 aangemaakt.

Sluit HiFive's UART1 RX (pin7) aan op Raspberry Pi 4's UART2 TX (pin 27). Dit is de belangrijkste communicatielijn tussen de Pi 4 en de HiFive1. Vanaf de Pi 4 heb je toegang tot het kanaal via /dev/ttyAMA1.

Voor het debuggen van HiFive 1 sluit u HiFive1's UART0 TX (pin1) aan op Pi 4's UART3 RX (pin 29). Vanaf de Pi 4 is het toegankelijk via /dev/ttyAMA2.

Samengevat heb je vanaf de Pi 4 toegang tot de volgende twee bestanden.

/dev/ttyAMA1             Pi 4 → HiFive1:stuurhoek naar HiFive1 (uart1) sturen.

/dev/ttyAMA2             HiFive1 → Pi 4:Ontvang HiFive1's console (uart0) output

Deel 1:De HiFive1 programmeren

In dit deel van het lab programmeer je de HiFive1 om gegevens van de Pi 4 te ontvangen.

Op uw pc (niet Pi 4), download het projectskelet als volgt.

$  cd  ~/Documents/PlatformIO

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

$  tar  zxvf  l10-comm.tar.gz

Voeg de map l10-interrupt toe aan de VSCode-werkruimte.

Uw taak is om de gegevens van het UART1-kanaal van HiFive1 te ontvangen en de ontvangen gegevens naar het UART0-kanaal te verzenden. Het volgende is een ruwe pseudo-code van de taak.

terwijl  (1)  {

if  (is  UART1  ready?)  { data  = read  from  UART1. print  gegevens  naar  UART0.

}

} Om de taak te implementeren, moet u mogelijk de meegeleverde seriële API gebruiken die hieronder wordt weergegeven. Merk op dat devid 0 is voor toegang tot UART0, terwijl het 1 is voor toegang tot UART1.

ongeldig 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);

In het bijzonder moet u mogelijk de functie ser_isready() gebruiken om te controleren of een bepaald UART-kanaal gegevens in behandeling heeft om te lezen. Om beter te begrijpen wat de functies doen, controleert u de bestanden eecs388_lib.h en eecs388_lib.c.

int     ser_isready(int devid)

{

uint32_t regval =*(vluchtige uint32_t *)(UART_ADDR(devid) + UART_IP); retourregval;

}

Zodra u klaar bent met het programmeren van de HiFive1, schakelt u over naar de Raspberry Pi 4 en open twee terminals:een voor het verzenden van gegevens naar de HiFive1 en een voor het bekijken van de uitvoer van het foutopsporingsbericht van de HiFive1.

Terminal van de afzender (term1)

$  scherm  /dev/ttyAMA1  115200

Debug-terminal (term2)

$  scherm  /dev/ttyAMA2  115200

Typ nu alle tekenreeksen op de 'term1'.

Als u uw HiFive 1 correct hebt geprogrammeerd, zou u het bericht moeten zien komen uit de 'term2'-terminal.

Deel 2:Programmeren van de Raspberry Pi 4.

In plaats van terminals te gebruiken, voer je nu een python-programma uit op de Pi 4 om te communiceren met de HiFive1. Het is jouw taak om de dnn.py uit het vorige lab uit te breiden om de stuuroutput naar het /dev/ttyAMA1 seriële kanaal te kunnen sturen. De volgende pseudocode geeft een algemeen idee van de wijzigingen die u moet aanbrengen in dnn.py:

Open seriële verbindingen naar /dev/ttyAMA1 en /dev/ttyAMA2 While True:

afbeelding  = camera.read()

angle  = dnn_inference(image) Schrijf  ‘angle’  naar  /dev/ttyAMA1 Wait_till_next_period()

Sluit  seriële  verbindingen

Om de bovenstaande functionaliteit te bereiken, moet u de pySerial API van Python gebruiken die kan worden gebruikt door het seriële pakket te importeren:

serienummer importeren

Hiermee zou u twee aparte seriële kanalen moeten creëren, één voor het schrijven naar de HiFive1 via

/dev/ttyAMA1 en een andere voor het debuggen van /dev/ttyAMA2. Merk op dat beide kanalen moeten worden geopend met de baudrate 115200 bps.

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

De hoeken die worden ontvangen van de DNN terwijl deze frames verwerkt, kunnen vervolgens naar de HiFive1 worden verzonden met behulp van de seriële schrijffunctie () :

ser1.write(…)

Write() vereist echter een bytewaarde, terwijl de hoek die door de DNN wordt geproduceerd een float32-waarde is, dus u zult de hoekgegevens moeten converteren om deze naar de HiFive1 te verzenden. Ten slotte, nadat alle frames zijn verwerkt, kunnen de seriële verbindingen worden gesloten door de functie serial close() aan te roepen:

ser1.close() ser2.close()

Bijlage

GPIO-toewijzing van Pi 4.

Raspberry Pi 4 pinout

De Raspberry Pi 4 barst niet alleen van de nieuwe hardwarefuncties, maar onder de motorkap bevinden zich enkele extra GPIO-functies om het leven een beetje gemakkelijker te maken, zodat gebruikers hun randapparatuur kunnen uitbreiden naar hun projecten zonder dat er extra hardware nodig is. I2C-, UART- en SPI-interfaces die kunnen worden gebruikt op de Raspberry Pi 4.

GPIO-pinouts

Je kunt een volledige lijst met GPIO-pinouts vinden op de Raspberry PI 4 zelf, ga gewoon naar de opdrachtregel en typ pinout in .

Hieronder vindt u een lijst met alle nieuwe Raspberry Pi 4 extra pinout-functies:

GPIO – Invoer Uitvoerpennen voor algemeen gebruik

Deze digitale pinnen kunnen worden geprogrammeerd om digitale ingangen te ontvangen of een digitaal signaal uit te voeren. De Raspberry Pi gebruikt een 3V3-logica op elke GPIO-pin, wat betekent dat 3V3 een digitale 1 (AAN) is en 0V een digitale 0 (UIT). Daarom kun je een digitale component aansluiten op de Raspberry Pi en er ofwel een 3V3 (ON) signaal aan geven of een 3V3 digitaal signaal ontvangen, mits de stroom niet meer dan 16mA is.

I2C – Inter-geïntegreerd circuit

Dit is een vrij algemeen type communicatie tussen apparaten, het werkt door een master en een slave te hebben. De master is in dit geval de Raspberry Pi zelf en de slave-apparaten zijn hardware-randapparatuur die normaal gesproken de functionaliteit van uw projecten zou uitbreiden. Het mooie van I2C is dat je honderden apparaten op dezelfde master kunt aansluiten met dezelfde tweedraads interface, op voorwaarde dat elk apparaat een ander I2C-adres heeft. U kunt toegang krijgen tot de interface en zien welke apparaten zijn aangesloten door het volgende linux-commando te gebruiken:

sudo i2cdetect -y 1

Waarbij "1" de hoofdinterface is. De Raspberry Pi 4 heeft er in totaal 6.

SPI – seriële perifere interface

SPI is een ander type communicatieprotocol voor communicatie tussen apparaten. Het maakt ook gebruik van een master/slave-opstelling, maar wordt voornamelijk gebruikt op korte afstanden tussen een hoofd- (master) controller en randapparatuur (slaves) zoals sensoren. SPI gebruikt meestal 3-draden om met de Raspberry Pi te communiceren; SCLK, MOSI en MISO. Voordat u SPI gebruikt, moet u het inschakelen in het Raspberry Pi-configuratiemenu:

UART – Universele asynchrone ontvanger/zender

In tegenstelling tot I2c en SPI is UART geen protocol. UART (Serial) is een fysiek circuit dat is ontworpen voor het verzenden en ontvangen van seriële gegevens. UART heeft geen kloksignaal nodig, daarom is het asynchroon. Dit minimaliseert de benodigde kabels voor het verzenden en ontvangen van gegevens, maar het vereist ook wat extra gegevens die met de pakketten worden verzonden voor foutcontrole, zoals een startbit en een stopbit. Meestal met betrekking tot de Raspberry Pi wordt UART gebruikt in een headless setup, wat betekent dat er geen GUI of andere interface is. In plaats daarvan kunt u de Raspberry Pi aansluiten op uw desktop/laptop of ander apparaat en ermee communiceren via UART met behulp van de opdrachtregelinterface. Deze methode is voor de meer gevorderde gebruikers omdat er wat meer kennis voor nodig is bij het instellen ervan.

Een andere toepassing die typisch is voor Raspberry Pi-gebruikers, is om een ​​Arduino UNO-bord op de Raspberry Pi aan te sluiten, aangezien de Pi beperkte analoge functionaliteit heeft.