Serialny interfejs peryferyjny w Arduino

Arduino to elektroniczna tablica rozwoju, która działa za pomocą mikrokontrolera. Przetwarza instrukcje i generuje pożądane wyjście. Komunikacja odgrywa ważną rolę podczas przetwarzania kodu Arduino. Aby to zrobić Arduino ma wiele protokołów komunikacyjnych, takich jak USART, I2C i SPI. Aby szczegółowo przeczytać więcej o protokołach komunikacyjnych, kliknij tutaj. Dzisiaj omówimy, w jaki sposób SPI (szeregowy interfejs peryferyjny) jest używany w Arduino.

Szeregowy interfejs peryferyjny (SPI)

Serial Peripheral Interface (SPI) to synchroniczny protokół danych szeregowych używany przez mikrokontrolery Arduino do celów komunikacyjnych z jednym lub więcej urządzeniami peryferyjnymi szybko na krótkich odległości. Można go również wykorzystać do komunikacji między dwoma mikrokontrolerami.

SPI to pełna komunikacja dupleksowa, co oznacza, że ​​może wysyłać i czytać dane w tym samym czasie. Spośród wszystkich trzech protokołów komunikacyjnych (USART, SPI i I2C) w Arduino SPI jest najszybszy. SPI ma aplikacje, w których wymagana jest wysoka szybkość danych, takie jak wyświetlanie tekstu na ekranach lub pisanie danych na karcie SD.

SPI działa przy użyciu czterech linii:

• SCK: Sygnał zegara które synchronizują transfer danych między urządzeniami głównymi i niewolnikami.
• Miso: (Master in Slave Out) lub MISO to linia danych dla niewolnika, która może wysyłać dane z powrotem do Master.
• MOSI: (Opanuj niewolnik) lub MOSI to linia danych dla głównego wysyłania danych do urządzeń niewolników i peryferyjnych.
• SS: (Wybierz niewolnika) Jest to linia używana przez Master do wyboru określonego urządzenia niewolnika. Informuje urządzenie niewolników, które dane zostaną wysłane lub odbierane.

Aktualizacja: Zgodnie z oficjalną dokumentacją Arduino SPI w Arduino nie obsługuje już tych terminologii. Poniżej tabela pokazuje nowe terminologie:

SPI Pinout w Arduino Uno

Protokół SPI jest obsługiwany przez wiele tablic Arduino tutaj, omówiliśmy wsparcie Arduino UNO dla SPI. Poniżej znajdują się szpilki używane przez Arduino UNO do seryjnej komunikacji peryferyjnej.

SPI w konfiguracji niewolników głównych

Podłączenie urządzenia głównego z pojedynczym niewolnikiem jest proste. Po podłączeniu zarówno urządzenia głównego, jak i niewolnikach, jak pokazano na obrazie poniżej. Najpierw musimy ustawić SS (linia wyboru niewolnika) na urządzeniu głównym na niskie. Pozostanie niski podczas transmisji danych. Niska linia SS przygotowuje niewolnika do wysyłania lub odbierania danych. Gdy SS będzie niski Master, urządzenie może wysyłać dane za pomocą linii MOSI i może wytwarzać sygnały zegara do komunikacji synchronicznej za pomocą pinu SCLK.

SPI w jednym głównym konfiguracji wielu niewolników

SPI obsługuje również wiele urządzeń niewolników, dla każdego niewolnika używana jest osobna linia SS (niewolnik). W przeciwieństwie do jednego niewolnika tutaj Master potrzebuje osobnej linii SS dla każdego niewolnika. Praca konfiguracji pojedynczych i wielu urządzeń niewolników jest w jakiś sposób podobna. Urządzenie główne pociągnij linię SS konkretnego niewolnika do niskiego poziomu, który informuje urządzenie niewolnikowe, że Master wysyła lub odbiera dane od tego niewolnika.

Następujący obraz ilustruje konfigurację pojedynczego master.

Konfiguracja łańcucha Daisy to kolejny sposób podłączenia wielu urządzeń niewolników. Gdzie Master nie potrzebuje wielu linii SS dla każdego niewolnika w rzeczywistości linia SS jest podłączona do pierwszego urządzenia. Gdy urządzenie główne wyciągnie linię SS do niskiego poziomu, wysyła sygnały do ​​wszystkich urządzeń niewolników, aby były gotowe do komunikacji w pin MOSI. Następnie urządzenie główne wysyła dane do PIN MOSI z pierwszego urządzenia niewolnika.

Jednocześnie Master wysyła sygnał zegara na szpilkę SCK. Dane są wysyłane z jednego niewolnika do drugiego, a pin SS jest ustawiany tak niski w tym czasie. Master powinien wysłać wystarczającą ilość sygnału zegara, aby dotrzeć do niego do ostatniego urządzenia niewolnika. Dane otrzymane z konkretnego urządzenia niewolnika zostaną odebrane przez Master przy jego pin miso.

Następujący obraz ilustruje konfigurację łańcucha stokrotki.

Jak zaprogramować Arduino do komunikacji SPI

Teraz weźmiemy dwie tablice Arduino i przekazamy sznurek z jednej płyty Arduino, która jest mistrzem do drugiego Arduino, która działa jako niewolnik. Pamiętaj, aby otworzyć dwa osobne okna Arduino IDE przed przesłaniem kodu, w przeciwnym razie istnieje duża szansa na przesłanie tego samego kodu w obu Arduino.

Przed przesłaniem kodu wybierz port COM, z którym podłączono Arduino. Oba Arduino powinny być podłączone w osobnych portach COM.

Okrążenie

Podłącz dwie płyty Arduino, takie jak pokazane w poniżej obwodu. Pamiętaj, aby podłączyć obie płyty do GND i podłączyć wszystkie pozostałe cztery piny SPI z PIN 10 do 13 obu Arduino.

Sprzęt komputerowy

Poniżej znajduje się obraz sprzętowy dwóch płyt Arduino podłączonych do komputera za pomocą kabla USB.

Kod główny

/*Master Arduino kod*/
#include /*biblioteka SPI zawierała* /
void setup ()
Seryjny.rozpocząć (115200); /*Wskaźnik transmisji zdefiniowany dla komunikacji szeregowej*/
DigitalWrite (SS, High); /*(Ss) Slave Wybierz linię wyłączoną*/
SPI.zaczynać(); /*Zaczyna się komunikacja SPI*/
SPI.setClockDivider (SPI_CLOCK_DIV8); /*Zegar podzielony przez 8*/

void Loop ()
char_str; /*Zmienna zdefiniowana w celu wysyłania danych*/
DigitalWrite (SS, niski); /*(Ss) Slave wybierz Włączone*/
dla (const char * p = "Linuxhint.Com \ r "; char_str =*p; p ++) /*String testowy wysłano* /
SPI.transfer (char_str); /*Transfer SPI rozpocznij*/
Seryjny.print (char_str); /*Ciąg jest drukowany*/

DigitalWrite (SS, High);
Opóźnienie (2000);

Tutaj, w powyższym kodzie najpierw uwzględniliśmy bibliotekę SPI do komunikacji. Następnie zaczęliśmy od zdefiniowania szybkości BAUD, aby zobaczyć wyjście na serial Monitor Slave Select Line jest wyłączony przy użyciu zapisu cyfrowego. Aby rozpocząć komunikację SPI SPI.zaczynać() Jest używane.

W częściowej części kodu zmienna char jest zdefiniowana do przechowywania ciągu, którą zamierzamy wysłać niewolnik Arduino. Następnie ciąg „Linuxhint.Com ” jest zdefiniowane, które jest przeniesieniem do niewolnika Arduino za pomocą SPI.przenosić(). Aby zobaczyć ciąg wejściowy na monitor seryjnego Seryjny.wydrukować() Zastosowana jest funkcja.

Kod niewolnika

/*Slave Arduino kod*/
#include /*biblioteka SPI zawierała* /
Char Buffer [50]; /*Bufor zdefiniowany w sklepie otrzymywanym ciągu z Master*/
Wskaźnik bajtów lotnych; /*Zapisz dane łańcuchowe*/
lotny proces boolean;
void setup ()
Seryjny.rozpocząć (115200);
Pinmode (MISO, wyjście); /*MISO Ustaw jako wyjście, aby wysłać dane do Master*/
Spcr | = _bv (SPE); /*SPI w trybie Slave Active*/
indeks = 0; /*Bufor pusty*/
proces = fałsz;
SPI.załącznik (); /*Włącz przerwanie*/

ISR (SPI_STC_VECT) /*SPI Rutyna przerwania* /
BYTE CHAR_STR = SPDR; /*Odczytaj bajtu z rejestru danych SPI*/
if (indeks < sizeof buffer)
bufor [index ++] = char_str; /*dane zapisane w indeksie Buff*/
if (char_str == '\ r') /*Sprawdź ciąg do końca* /
proces = prawda;


void Loop ()
if (proces)
proces = fałsz; /*Resetować proces*/
Seryjny.println (bufor); /*Otrzymano tablicę wydrukowaną na monitorze szeregowym*/
indeks = 0; /*Przycisk resetowania do zera*/

Powyższy kod jest przesyłany do Slave Arduino, gdzie zaczęliśmy od zdefiniowania trzech zmiennych bufor, indeks i proces. Zmienna buforowa będzie przechowywać ciąg wejściowy z głównego Arduino, podczas gdy indeks będzie szukał indeksu elementów wewnątrz ciągu, a po wydrukowaniu całego ciągu proces zatrzyma program i zresetuje na zero. Po czym znowu niewolnik rozpocznie otrzymywanie danych od Master Arduino i zostanie wydrukowany na monitorze szeregowym.

Wyjście

Wyjście można zobaczyć w dwóch różnych oknach Arduino IDE. Wyjście zarówno Master, jak i Slave Arduino jest wydrukowane na monitorze szeregowym.

Wniosek

Serial Peripheral Interface jest ważnym protokołem komunikacyjnym stosowanym w programowaniu Arduino, który pomaga użytkownikom kontrolować wiele urządzeń za pomocą pojedynczej płyty Arduino. SPI jest szybszy niż Protokół USART i I2C. Można go zaimplementować w dwóch różnych konfiguracjach pojedynczych głównych z pojedynczym niewolnikiem lub wieloma niewolnikami. Ten artykuł zawiera wgląd, w jaki sposób Arduino można podłączyć do komunikacji SPI.