Raspberry Pi Arduino Serial Communication-Everything You Need to Know

BY admin
|

In this tutorial i’ll show you how to communicate between a Raspberry Pi and an Arduino board via Serial communication.Primeiro, explicarei rapidamente o que é a comunicação em série. Então você verá como configurar seu hardware e software, e nós mergulharemos no código Python (Cpp para Arduino). Um exemplo básico no início, levando a uma aplicação mais completa usando um Raspberry Pi, um Arduino, e outros dispositivos eletrônicos.

este tutorial irá trabalhar com uma placa Raspberry Pi 4 (e anterior: 3B, 3B+), e qualquer placa Arduino. Vou usar mais Arduino Uno, mas vou dar mais detalhes sobre as diferenças entre as placas Arduino quando se trata de comunicação em série.

quando se trabalha com dispositivos electrónicos, A comunicação é fundamental. Cada dispositivo-além de fazer bem o que é suposto fazer – deve ser capaz de se comunicar claramente com outros dispositivos. Essa é uma das coisas mais importantes para trabalhar, a fim de mudar de uma aplicação muito básica para mais complexas.

Tabela de Conteúdo

o Que é comunicação Serial (com UART)

comunicação Serial é simplesmente uma forma de transferir os dados. Os dados serão enviados sequencialmente, um bit de cada vez (1 byte = 8 bits), ao contrário da comunicação paralela, onde muitos bits são enviados ao mesmo tempo.

protocolo UART

mais especificamente, quando você usa Serial com Arduino e Raspberry Pi, você está usando o protocolo UART. UART significa “recepção e transmissão assíncrona Universal”.Está a aprender a usar Raspberry Pi para construir os seus próprios projectos?

confira Raspberry Pi para iniciantes e aprender passo a passo.Basicamente, é um protocolo assíncrono multi-mestre baseado na comunicação Serial, que lhe permitirá comunicar entre as duas placas. Tenha certeza, existem bibliotecas que irão lidar com todas as camadas baixas para você.

multi-master significa que todos os dispositivos conectados serão livres para enviar dados quando quiserem. Esta é uma das principais diferenças com os protocolos master-slaves, onde apenas o dispositivo master pode iniciar uma comunicação. Normalmente você vai usar outros protocolos como I2C e SPI quando você precisa de Configurações master-slaves: por exemplo, quando você tem um tabuleiro Arduino e vários sensores ou atuadores.

A placa Arduino Uno tem um UART que você pode usar com um cabo USB ou a partir dos pinos RX/TX (não use com ambos ao mesmo tempo). Algumas placas têm mais UARTs disponíveis. Por exemplo, o Arduino Mega tem diferentes séries (Serial, Serial1, Serial2, Serial3) e o Arduino Zero tem apenas uma porta USB nativa (use SerialUSB em vez de Serial).

na Raspberry Pi, você pode conectar muitos dispositivos seriais nas portas USB. Cada um terá um nome de dispositivo diferente (veremos como encontrá-los mais tarde neste tutorial). Você também pode usar o GPIOs (RX0/TX0) para um UART adicional.

provavelmente já conhece a comunicação em série

certamente já usou a comunicação em série muitas vezes. Tenho certeza que você já conhece a Biblioteca Serial Arduino, que lhe permite registrar o que está acontecendo em seu código e obter a entrada do Usuário. Quando você usa o monitor de série, bem, basicamente o seu Arduino IDE inicia uma comunicação em série com o seu Arduino. Você pode receber e enviar dados diretamente do monitor Serial.

o que vamos fazer aqui é quase o mesmo, exceto que em vez de seu Arduino IDE, o outro lado da comunicação Serial será uma placa Raspberry Pi. Vamos ter que fazer alguma configuração e escrever algum código para fazer com que funcione. Em seguida, tanto Raspberry Pi e Arduino será capaz de enviar mensagens um para o outro.Vejamos agora como ligar fisicamente as duas placas.

configuração de Hardware para comunicação em série

existem 2 maneiras de conectar o seu Raspberry Pi e Arduino para comunicação em série.

Serial via USB

A maneira mais fácil é usar um cabo USB entre ambas as placas.

no lado Raspberry Pi, um conector USB simples é tudo o que você precisa. Você pode escolher qualquer uma das 4 portas USB disponíveis no tabuleiro.

para Arduino, você vai usar a porta USB que você usa para carregar o código do seu computador (com o Arduino IDE) para o seu tabuleiro. Aqui o conector USB irá depender da versão que você tem. Para placas como Arduino Uno e Mega, O conector será diferente de Arduino Nano, e de Arduino Zero.

para este exemplo eu usei uma placa Arduino Uno.

como você pode ver, é a conexão mais simples de hardware que você pode fazer entre Raspberry Pi e Arduino.

Nota: você primeiro vai precisar conectar seu Arduino ao seu computador, para que você possa carregar o código no tabuleiro. Depois disso, ligue o cabo USB ao Raspberry Pi. O Raspberry Pi vai ligar o Arduino através deste cabo.

Serial via GPIOs

To make a Serial connection you can also use plain wires between the Raspberry Pi GPIOs and the Arduino pins.

dependendo do seu quadro de Arduino, você pode precisar de usar um metamorfo de voltagem. O Raspberry Pi está operando em 3.3 V. Para Arduino boards como Due, 101, vai ser bom, porque eles também usam 3.3 V.

Mas, para muitos Arduino, como Uno, Mega, Leonardo, Nano, e muitos mais, a placa está operando em 5V. Assim, você precisa de uma 3,3 V/5 V do nível de shifter para proteger o Raspberry Pi ao ligar RX e TX (mais informações no Raspberry Pi pinos e pinos do Arduino Uno).

para o resto deste tutorial vamos usar a configuração com o cabo USB. Isso será mais fácil de gerenciar e a menos que você tenha uma boa razão não Também, você deve preferir usar o cabo USB em vez de simples gpios para a comunicação em série.

Raspberry Pi Software setup

você não precisa de nenhuma configuração especial para Arduino. Certifique-se apenas de ter baixado e instalado o Arduino IDE.

agora, em seu Raspberry Pi, algumas coisas são necessárias para fazer a comunicação funcionar.

conecte-se ao seu Raspberry Pi, seja através de ssh, ou por plugin um ecrã+Mouse+Teclado, e abra um terminal. Se você ainda não instalou um SO no seu Pi, você pode instalar Raspbian ou Ubuntu muito facilmente em um cartão SD.

Detectar a placa Arduino

Ao ligar o Arduino com um cabo USB, você deve vê-lo aparecer como /dev/ttyACM0, ou /dev/ttyUSB0 (às vezes, o número pode ser diferente, por exemplo /dev/ttyACM1).

simplesmente executar ls /dev/tty* e você deve vê-lo. Neste ponto, se você não tem certeza de qual dispositivo é a placa Arduino, basta desligar a placa (remover o cabo USB), e executar ls /dev/tty* novamente. Desta forma você vai facilmente identificar o nome do dispositivo serial de seu Arduino.

Permissões de Hardware para Serial

também, você pode querer adicionar seu usuário ao grupo de dialout, para evitar erros como: serial.serialutil.Descrição Serial: não foi possível abrir o porto / dev / ttyACM0: Permissão negada: ‘/ dev / ttyACM0’

$ sudo adduser your_username dialout

Isto irá certificar-se de que tem acesso a dispositivos seriais (/dev/ttyACMx, /dev/ttyUSBx, …).

depois de se ter adicionado ao grupo de marcação, precisa de reiniciar o seu Pi (ou, pelo menos, logout/login) para aplicar a mudança – saiba mais sobre as permissões de hardware do Raspberry Pi.

instale Python Serial library on Raspberry Pi

você precisa instalar uma biblioteca para ser capaz de usar a interface Serial com Python.

para este tutorial, utilizaremos a biblioteca pySerial (documentação para Python 3). Para o instalar:

python3 -m pip install pyserial

esta biblioteca Python é bem conhecida e usada em muitas aplicações.

ao instalar, se você tiver um erro como “/usr / bin / python3: nenhum módulo chamado pip”, então você precisa instalar pip primeiro com sudo apt install python3-pip.

comunicação Serial simples de Arduino a Raspberry Pi

vamos começar com um programa muito simples.

Código Arduino

Upload this code from your computer to your Arduino, using the Arduino IDE.

void setup() { Serial.begin(9600);}void loop() { Serial.println("Hello from Arduino!"); delay(1000);}

primeiro, inicializamos a comunicação Serial, e escolhemos uma taxa de baud, aqui 9600. 9600 é uma taxa de baud comumente usada, e também uma bastante baixa. Em suas futuras aplicações você pode usar uma taxa de baud de 57600 ou mesmo 115200 sem qualquer problema. Para este tutorial vamos continuar com 9600.

A cada segundo que fazemos o Arduino enviar uma corda com Serial.println (). a função println () irá adicionar um carácter de linha nova ‘\n’ no fim do texto.

pode abrir o monitor Serial para ver o texto no seu computador.

código Python De Framboesa Pi 

#!/usr/bin/env python3import serialif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

então, o que este código faz?

#!/usr/bin/env python3import serial

primeiro, importamos a biblioteca série que instalamos anteriormente.

if __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1)

A comunicação Serial é inicializada chamando serial.Serial () junto com alguns parâmetros:

  • nome do dispositivo Serial do Arduino: normalmente ‘/ dev / ttyACM0’, ‘/dev/ttyUSB0’, ou semelhante.
  • taxa Deaud: este parâmetro é muito importante. Você precisa usar a mesma taxa de baud que você usou no Arduino, ou então tudo que você vai ler e escrever será lixo. Então, escolhemos 9600 como fizemos no sketch Arduino.
  • tempo-limite: este é um tempo-limite para as operações de leitura. Aqui o ajustamos para um segundo. Significa que quando lermos de série, o programa não ficará preso para sempre se os dados não chegarem. Após 1 segunda ou leitura, se nem todos os bytes são recebidos, a função retornará os bytes já recebidos.

So, serial.O Serial () devolve um objecto que pode usar para todas as suas operações seriais. Guardamo-lo na variável “ser”.

 ser.flush()

depois usamos a função flush (). Isto irá eliminar qualquer buffer de entrada e saída, para que evite receber ou enviar dados estranhos/não úteis/não completos no início da comunicação.

 while True: if ser.in_waiting > 0: line = ser.readline().decode('utf-8').rstrip() print(line)

In an infinite loop( think of the loop() function in the Arduino sketch), we check if some data is available with the in_waiting attribute (don’t put parêntesis, this is not a function). Em caso afirmativo, podemos ler os dados.

a função readline () irá ler todos os bytes até ser detectado um carácter newline.Se apenas imprimíssemos o que recebemos, veríamos B’Hello de Arduino!\r\n’. Você recebe bytes quando você lê de série, e você tem que converter (decodificar) esses bytes no tipo de dados apropriado. Então, nós usamos decode (‘utf-8’) – Você também pode usar decode (‘ascii’) – para decodificar os dados recebidos para uma string.

finalmente, a função rstrip() é específica de strings, que lhe permite remover quaisquer caracteres de atraso (newline, carriage return). Desta forma, podemos remover o ‘\r’ e ‘\n’ e obter uma cadeia de caracteres adequada.Nota: aqui lemos uma linha completa todas as vezes. Se você quiser ler uma certa quantidade de bytes – um ou mais – use a função read(size=1).

testando a comunicação em série

agora, desligue a placa de Arduino do seu computador e conecte-a à placa de Raspberry Pi.

o código Arduino já está em execução, assim que está ligado.

no Raspberry Pi, faça o arquivo Python executável e o lance.

$ chmod +x receive_serial_data_from_arduino.py$ ./receive_serial_data_from_arduino.py Hello from Arduino!Hello from Arduino!Hello from Arduino!

funciona! A corda enviada por Arduino a cada segundo é exibida no Terminal Raspberry Pi.

comunicação em série bidirecional entre Raspberry Pi e Arduino

vamos tornar as coisas um pouco mais interessantes. Já viste como enviar dados de Arduino para Raspberry Pi. Nesta parte você verá como falar de Raspberry Pi A Arduino. Assim você terá ambos os lados da comunicação e você será capaz de criar programas que esperam pela entrada um do outro.

Código Arduino 

void setup() { Serial.begin(9600);}void loop() { if (Serial.available() > 0) { String data = Serial.readStringUntil('\n'); Serial.print("You sent me: "); Serial.println(data); }}

aqui verificamos se o Arduino recebeu dados com série.disponivel(). Isto dar-lhe-á o número de bytes já chegados e armazenados no buffer de recepção.

se alguns dados chegaram, Nós usamos Serial.readStringUntil () com um carácter de linha nova ‘\n’ para obter a próxima linha. Isto é semelhante à função readline (). Todos os bytes recebidos até ‘\n ‘ são automaticamente convertidos e adicionados num objecto de cadeia de Arduino.

então, nós apenas imprimimos de volta os dados que recebemos, com um pedaço adicional de texto.Nota :Se quiser ler bytes um por um, pode fazê-lo com a série.read () function. Então você terá que converter este(aqueles) byte (s) se necessário: int, String, etc.

código Python De Framboesa Pi 

#!/usr/bin/env python3import serialimport timeif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: ser.write(b"Hello from Raspberry Pi!\n") line = ser.readline().decode('utf-8').rstrip() print(line) time.sleep(1)

Use a função pySerial write() para enviar dados para o Arduino. Aqui você pode ver que eu adicionei um ‘ b ‘ antes do string para enviar. Isto irá codificar o texto para bytes, porque você só pode enviar bytes através de série. Quaisquer dados que não sejam um byte ou uma matriz de bytes devem ser convertidos antes de serem enviados. Se você apenas tentar enviar o texto assim, você vai obter este erro ” TypeError: as cadeias de unicode não são suportadas, por favor codificar para bytes: ‘Olá de Raspberry Pi! Nota: em vez de ser.write(b"Hello from Raspberry Pi!\n") poderia ter escrito ser.write("Hello from Raspberry Pi!\n".encode('utf-8')) ou ser.write("Hello from Raspberry Pi!\n".encode('ascii')). Isto vai fazer a mesma coisa. A função encode () irá pegar o texto e codificá-lo para ser Serial.

também, adicionamos um personagem newline ‘\n ‘ porque é isso que o Arduino é esperado para terminar a sua leitura com Serial.readStringUntil (‘\n’).

então, nós fazemos a mesma coisa que fizemos antes: nós lemos uma linha, descodificamo-la para string, e removemos qualquer caractere trailing. Não vamos usar o ser.in_waiting aqui, porque para esta aplicação específica sabemos que o Arduino irá enviar de volta alguns dados logo após ter recebido a string. Além disso, temos um segundo tempo para evitar ficar presos nesta linha.Finalmente, imprimimos a sequência recebida e esperamos 1 segundo com o tempo.sleep () antes de enviar o texto seguinte sobre a série.

testando a comunicação em série bidirecional

no seu Raspberry Pi, torne o seu ficheiro Python executável e inicie-o.

$ chmod +x bidirectional_serial_communication.py $ ./bidirectional_serial_communication.py You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!You sent me: Hello from Raspberry Pi!

sucesso! O Arduino recebeu a corda, e Enviou-a de volta com mais algumas palavras. Em seguida, o Raspberry Pi recebeu e imprimiu o texto final.

Raspberry Pi Arduino Serial communication: Application example

Now that you know how to setup your Arduino and Raspberry Pi for Serial communication, and write programs to talk between each board, let’s create a more complex application.

nesta aplicação, 4 LEDs e um botão de pressão serão ligados à placa de Arduino.

o Raspberry Pi e Arduino serão conectados com um cabo USB e usar a comunicação Serial para conversar uns com os outros.Aqui está o resultado que queremos obter:

  • quando o botão de pressão é pressionado, o Arduino enviará uma notificação ao Raspberry Pi (um simples byte).
  • o Raspberry Pi irá então calcular um número inteiro aleatório entre 1 e 4, e enviá-lo para o Arduino.
  • the Arduino will power on the LED related to this number, and power off the other LEDs.

isto fará com que pratique a comunicação e sincronização de tarefas entre Arduino e Raspberry Pi.Se você chegou a este ponto do tutorial (Parabéns!) Eu encorajo você a tentar escrever o código por si mesmo antes de ler o código que eu forneci abaixo. Além disso, não há apenas um código possível para atender esses requisitos, então o seu código pode ser diferente do meu, está totalmente OK. Você pode obter ajuda da referência de série Arduino e da referência de API pilerial.Esquema

para fazer este circuito:

  • Conecte 4 LEDs a Pinos 9-12. Adicione um resistor de 220 Ohm para cada LED entre a perna mais longa e o pino digital. A perna mais Curta está ligada ao solo.
  • adicione um botão de pressão com uma resistência de 10 kOhm ligada ao solo (resistência de tracção). Um lado do botão Está ligado ao 5V, o outro ao pin 5 digital para leitura.
  • não se esqueça de criar um terreno comum entre todos os componentes: a placa de Arduino, os 4 LEDs e o botão de pressão. Não adicione nenhuma fonte de alimentação se você não tiver pelo menos conectado corretamente o terreno.
  • ligue o Arduino e o Raspberry Pi através de um cabo USB, para a comunicação em série (o cabo USB já gere a ligação terrestre entre as suas 2 placas).

Código Arduino 

#define LED_1_PIN 9#define LED_2_PIN 10#define LED_3_PIN 11#define LED_4_PIN 12#define BUTTON_PIN 5byte lastButtonState = LOW;byte currentButtonState = LOW;unsigned long lastButtonDebounceTime = 0;unsigned long buttonDebounceDelay = 20;void powerOffAllLEDs(){ digitalWrite(LED_1_PIN, LOW); digitalWrite(LED_2_PIN, LOW); digitalWrite(LED_3_PIN, LOW); digitalWrite(LED_4_PIN, LOW);}void setup(){ Serial.begin(9600); pinMode(LED_1_PIN, OUTPUT); pinMode(LED_2_PIN, OUTPUT); pinMode(LED_3_PIN, OUTPUT); pinMode(LED_4_PIN, OUTPUT); pinMode(BUTTON_PIN, INPUT); powerOffAllLEDs();}void loop(){ byte readValue = digitalRead(BUTTON_PIN); if (readValue != lastButtonState) { lastButtonDebounceTime = millis(); } if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } } } lastButtonState = readValue; if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }}

na função setup() inicializamos os modos pin para todos os 4 LEDs e o botão de pressão. Também garantimos que todos os LEDs estão desligados.

depois no ciclo () fazemos 2 coisas: manusear o botão de pressão e gerir os 4 LEDs. Ambas as ações são feitas uma a uma, mas elas são tratadas muito rápido, então é como se estivessem acontecendo ao mesmo tempo. É um caso de multitarefa de um programa Arduino.Primeira acção: manuseamento do botão injector .

byte readValue = digitalRead(BUTTON_PIN);if (readValue != lastButtonState) { lastButtonDebounceTime = millis();}if (millis() - lastButtonDebounceTime > buttonDebounceDelay) { if (readValue != currentButtonState) { currentButtonState = readValue; if (currentButtonState == HIGH) { Serial.write(18); } }}lastButtonState = readValue;

precisamos de desacreditar o botão para evitar valores indesejados. Quando descobrirmos que o botão está pressionado, podemos enviar alguns dados para o Raspberry Pi via Serial.Aqui usei a série.função write (): envia um byte ou uma série de bytes. Isto é diferente de Serial.imprimir () que fará com que a saída agradável para ver no monitor Serial. Como estamos a falar com outra máquina e não com um humano, não há problema com isso.

o número que enviamos aqui é 18. Este é apenas um número aleatório que vamos associar com o Estado “botão foi pressionado” , então quando o Raspberry Pi vai receber um número, ele vai verificar se é igual a 18. Você pode imaginar o envio de diferentes ações ou mensagens através de série, usando números diferentes.Nota: normalmente você também pode usar interrupções de Arduino para saber quando um botão foi pressionado. Se você fizer isso, não use a biblioteca Serial na interrupção. Se você absolutamente tem que usar interrupções, em seguida, definir uma bandeira dentro da interrupção (uma simples variável booleana), e usar Serial dentro de sua função loop ().

e a segunda acção: gerir os 4 LEDs.

 if (Serial.available() > 0) { int ledNumber = Serial.read() - '0'; powerOffAllLEDs(); switch (ledNumber) { case 1: digitalWrite(LED_1_PIN, HIGH); break; case 2: digitalWrite(LED_2_PIN, HIGH); break; case 3: digitalWrite(LED_3_PIN, HIGH); break; case 4: digitalWrite(LED_4_PIN, HIGH); break; default: // wrong pin number, do nothing // all LEDs will be powered off break; } }

primeiro nós verificamos se o Arduino recebeu alguns dados do Raspberry Pi sobre a comunicação Serial.

se sim, lemos o próximo byte com Serial.ler(). Aqui você pode notar um pequeno truque, consistindo em subtrair com ‘0’, que irá converter o personagem para o número que representa – neste caso um inteiro.

depois disso é bastante simples. Nós desligamos todos os LEDs, e, em seguida, ligar apenas o LED associado com o número: 1, 2, 3 ou 4. Caso um valor errado seja enviado, nenhum LED será ligado.

código Python De Framboesa Pi 

#!/usr/bin/env python3import serialimport randomif __name__ == '__main__': ser = serial.Serial('/dev/ttyACM0', 9600, timeout=1) ser.flush() while True: number = ser.read() if number != b'': if int.from_bytes(number, byteorder='big') == 18: led_number = random.randint(1,4) print("Button has been pressed.") print("Sending number " + str(led_number) + " to Arduino.") ser.write(str(led_number).encode('utf-8'))

primeiro adicionamos uma linha de importação: a Biblioteca aleatória Python.

no loop infinito (“while True”), Lemos pela primeira vez um byte da série. O tempo-limite é de 1 segundo. Se nada for recebido após um segundo, a função read() retornará b”.

por isso, verificamos se o que recebemos está simplesmente vazio (b”) ou se havia realmente alguma coisa. Neste último caso, convertemos os dados que recebemos para um inteiro para que possamos usar no código. Para isso usamos a função int.from_bytes (), que irá descodificar b’0x12′ (a representação hexadecimal de 18 é 0x12) a 18.

como pode ver, verificamos que o número é 18 para continuar a acção. Se você tem comandos diferentes para lidar, usar um número diferente para cada comando é uma boa prática.

escolhemos um número aleatório entre 1 e 4 para determinar o que levou ao poder. Então nós o enviamos com a função pySerial write (). Para enviar um int via Serial, primeiro o convertemos como uma string com str(), e então o codificamos com encode(‘utf-8’).

testando a aplicação

Agora você pode conectar o Arduino ao Raspberry Pi usando o cabo USB. O Raspberry Pi irá então fornecer a energia tanto para o Arduino quanto para os 4 LEDs.

se você tem muitas coisas conectadas ao seu Arduino, você pode querer adicionar uma fonte de alimentação externa no conector de alimentação Arduino. Por exemplo, se você quiser usar um motor de estepe, o Raspberry Pi nunca terá corrente suficiente para si mesmo + o Arduino + o motor. Neste caso, com 4 LEDs não faz mal.

execute o seu programa em Python e carregue no botão de pressão. Você vai ver um log e um dos LED no Arduino será ligado.Sempre que carregar no botão:

  • o Arduino vai detectá-lo e enviar 18 para o Raspberry Pi.
  • o Raspberry Pi receberá alguns dados do Serial. Verificará se o número é igual a 18. Se sim, um número aleatório (entre 1-4) é escolhido. O Raspberry Pi vai enviar este número para o Arduino.
  • o Arduino receberá este número e poder sobre o LED associado.

Nota: para fazer esta aplicação mais rápido e com menos código, você também pode optar por usar o protocolo Firmata, com por exemplo a biblioteca pyFirmata em framboesa e Biblioteca StandarfFirmata em Arduino. Confira esses tutoriais para saber mais.

conclusão

neste tutorial aprendeu a comunicar entre o seu Raspberry Pi e o Arduino board via Serial.Agora, na vida real, isto será útil para si? A resposta é sim, e muitas vezes.

o Raspberry Pi é ótimo para ter um monte de poder computacional incorporado em sua aplicação. Você pode executar softwares completos em muitas línguas, servidores web, aplicações robóticas, etc. O Raspberry Pi certamente tem alguns GPIOs que você pode usar, mas eles não são tão bons como os Arduino. Além disso, você tem mais chances de queimar seu Pi se você fizer algo de errado com o hardware.

o Arduino é mais apropriado para lidar diretamente com sensores de hardware e atuadores: IMU, motores servo, motores estepadores, qualquer coisa que requer mais potência, etc. – mais informações sobre quando usar Arduino vs Raspberry Pi.

Tudo em todos, as 2 placas podem funcionar perfeitamente em conjunto: O Raspberry Pi como o “cérebro” da aplicação, e o Arduino como os “músculos”, com uma comunicação Serial para fazê-los falar uns com os outros.