As comunicações seriais são amplamente usadas na eletrônica. Hoje quase todos os equipamentos eletrônicos os utilizam. Neste artigo vamos aprender como usar a comunicação serial e ver sua utilidade. Nós também usaremos o monitor serial do Arduino IDE, que é usado para verificar e testar os exemplos de códigos ou códigos desenvolvidos por qualquer programador ou usuário.
MIC044S
Os exemplos apresentados neste artigo são um ponto de partida para entender as comunicações seriais. Muitos protocolos, como internet, intranet, CAN, Bluetooth, etc., usam comunicações seriais para enviar e receber dados. A placa Arduino Uno possui uma porta serial para comunicação com outros sistemas e dispositivos. Veja a Figura 1.
Como você pode ver na imagem, os pinos digitais 0 e 1 são usados para a porta serial. O pino 0 é o receptor e é por isso que ele é rotulado com RX. O pino 1 é o transmissor e é rotulado com TX. A Figura 2 mostra o modo de conexão serial entre uma placa Arduino Uno e um computador.
Note que o transmissor Arduino deve estar conectado ao receptor do computador e ao receptor Arduino, ao transmissor do computador. Hoje em dia, os laptops não trazem mais a porta serial, mas são usados circuitos integrados que convertem e usam a porta USB para essa finalidade. O circuito integrado faz uma conversão: Série / USB / Serial. Os laptops antigos, se viessem com a porta serial e sua conexão, foram feitos conforme indicado acima. É necessário conectar os negativos dos dois circuitos, ou seja, o Arduino Uno e o computador, para o seu correto funcionamento.
Além disso, no Arduino IDE, existe um aplicativo ou programa chamado Monitor Series, que nos permite interagir com a porta serial deste cartão. Veja a Figura 3.
Neste programa podemos ver ou monitorar os dados enviados ou recebidos pela porta serial da placa Arduino Uno. Isso é muito útil para desenvolver e testar os programas feitos para o Arduino, embora esta técnica seja utilizada, também com outros microcontroladores. Os seguintes códigos de exemplo, mostrados neste artigo, podem ser encontrados no menu: Files-> Examples-> 04.Communication. Veja a Figura 4.
A maioria dos códigos de exemplo para comunicação serial tem alguns códigos comentados na parte inferior dos programas ou sketch, que são códigos executados em outros IDEs, que têm a capacidade de interagir com a porta serial do computador. Um exemplo desses IDEs é o programa Processing, que é muito semelhante ao Arduino, mas é usado para desenvolver programas para o computador.
CÓDIGO EXEMPLO Graph
Este programa envia dados ou bytes para o computador ou PC. Os dados ou bytes são lidos a partir da porta analógica A0 e enviados para o computador através da porta serial. A figura 5 mostra como fazer um circuito com um potenciômetro ou resistor variável para demonstrar o funcionamento do programa.
O potenciômetro pode ser trocado por qualquer sensor que forneça um sinal analógico. Você pode usar o monitor serial para visualizar os dados recebidos no computador. Para ativar o monitor serial, vá ao menu: Ferramentas-> Monitor Series. Veja a Figura 6. Este código de amostra está no menu: Arquivo-> Exemplos-> 04.Comunicação-> Gráfico. O seguinte é o código de exemplo:
void setup() {// initialize the serial communication: Serial.begin(9600); }
void loop() {// send the value of analog input 0: Serial.println(analogRead(A0));
// wait a bit for the analog-to-digital converter to stabilize after the last// reading: delay(2); }
O envio de dados para o computador ou PC é uma tarefa simples no Arduino Uno. Na função setup(), a porta serial é inicializada e configurada com a seguinte função:
Serial.begin(9600);
Esta função recebe um parâmetro para indicar a velocidade de transmissão da porta serial. Para o caso deste programa, usamos 9600 bauds ou bits por segundo. Então, na função loop(), a entrada analógica é lida no canal 0, com a seguinte função:
analogRead(A0)
O valor retornado pela função analogRead(A0) é passado diretamente para a função:
Serial.println()
responsável por enviar ou transmitir os dados lidos para o computador. Em seguida, é feito um atraso para estabilizar o conversor analógico para digital de sua última leitura. Isto é muito importante, porque se o circuito analógico para digital, não estabilizado pode dar valores falsos. Nós fazemos isso com a função:
delay(2);
Com o Monitor da Série, aberto, podemos ver os dados. Lembre-se que os conversores analógicos do Arduino Uno são 10 bits, portanto os valores apresentados nos monitores da série irão oscilar entre 0 e 1023. Veja a Figura 7.
EXEMPLO DE CÓDIGO Dimmer.
O programa a seguir controla o brilho de um LED, de acordo com o valor enviado do computador ou PC para a placa Arduino Uno. Para enviar o byte que controla o LED, usamos o Monitor Serial. Nós usamos o pino 9 da placa Arduino, porque isso pode ser usado para controlar o brilho do LED, devido à sua capacidade de lidar com PWM. Os pinos que podem ser usados para controlar o PWM são: 3, 4, 6, 9, 10 e 11. A Figura 8 mostra como fazer o circuito para este programa. Este código de exemplo está no menu: File-> Examples-> 04.Communication-> Dimmer. O seguinte é o código de exemplo:
const int ledPin = 9; // the pin that the LED is attached to void setup() { // initialize the serial communication: Serial.begin(9600); // initialize the ledPin as an output: pinMode(ledPin, OUTPUT); } void loop() { byte brightness; // check if data has been sent from the computer: if (Serial.available()) { // read the most recent byte (which will be from 0 to 255): brightness = Serial.read(); // set the brightness of the LED: analogWrite(ledPin, brightness); } }
O código começa com a função setup(), onde a porta serial está configurada para transmitir a 9600 bit por segundo e o pino 9 também é configurado como saída com a função:
pinMode (ledPin, OUTPUT);
No loop principal, isto é, na função setup(), verifica-se se há dados disponíveis na porta serial. Isso é feito com a função:
if (Serial.available ())
Se os dados estiverem disponíveis, a função retornará true e executará o bloco de códigos. A primeira coisa que é feita no bloco de código é ler a porta serial com a função:
brightness = Serial.read ();
Os dados recebidos são armazenados na variável de brilho. Então este valor é usado para enviar para a função:
analogWrite (ledPin, brilho);
que é responsável por controlar o pino ledPin (pino 9). O controle é por PWM e é por isso que é possível ver o brilho da mudança do LED.
Este programa demonstra como podemos enviar dados do computador ou PC para a placa do Arduino Uno. É possível controlar qualquer projeto feito com o Arduino a partir do computador.
EXEMPLO DE CÓDIGO VirtualColorMixer.
Este código de exemplo mostra como enviar vários dados para o computador e vê-los no Serial Monitor. O programa faz a leitura dos pinos de entrada analógica A0, A1 e A2 e usando a instrução Serial.print () envia-os para o computador. A figura 9 mostra um possível circuito eletrônico para testar este programa. O código de exemplo está no menu: File-> Examples-> 04.Communication-> VirtualColorMixer. O seguinte é o código para este exemplo:
const int redPin = A0; // sensor to control red colorconst int greenPin = A1; // sensor to control green colorconst int bluePin = A2; // sensor to control blue color void setup() { Serial.begin(9600); } void loop() { Serial.print(analogRead(redPin)); Serial.print(“,”); Serial.print(analogRead(greenPin)); Serial.print(“,”); Serial.println(analogRead(bluePin)); }
Como podemos ver, é muito fácil enviar vários dados para o computador e vê-los no Serial Monitor. Por experiência, em alguns projetos práticos, enviei muitos dados de um sistema para outro através da porta serial. Quase todos os sistemas eletrônicos modernos fazem uso de alguma comunicação serial para enviar dados. Daí a importância de saber como fixá-los ou agrupá-los para depois transmiti-los.
EXEMPLO DE CÓDIGO PhysicalPixel.
Este código de exemplo demonstra como podemos controlar pinos digitais configurados como saída, através de bytes enviados do computador ou outro sistema, para a placa do Arduino Uno. A Figura 10 mostra o circuito eletrônico para testar este programa.
Neste exemplo, um pino é configurado como uma saída para controlar um LED. O controle nós fazemos assim:
- Se o byte recebido for o caractere H, o LED acenderá (ligado).
- Se o byte recebido for o caractere L, o LED apagará (desligado).
A Figura 11 mostra como o byte pode ser enviado pelo monitor serial.
O código de exemplo está no menu: File-> Examples-> 04.Communication-> PhysicalPixel. O seguinte é o código para este exemplo:
const int ledPin = 13; // the pin that the LED is attached toint incomingByte; // a variable to read incoming serial data into void setup() { // initialize serial communication: Serial.begin(9600); // initialize the LED pin as an output: pinMode(ledPin, OUTPUT); } void loop() { // see if there’s incoming serial data: if (Serial.available() > 0) { // read the oldest byte in the serial buffer: incomingByte = Serial.read(); // if it’s a capital H (ASCII 72), turn on the LED: if (incomingByte == ‘H’) { digitalWrite(ledPin, HIGH); } // if it’s an L (ASCII 76) turn off the LED: if (incomingByte == ‘L’) { digitalWrite(ledPin, LOW); } } }
Este método é usado em quase todas as comunicações onde é necessário fazer algum tipo de controle. O programador pode escolher os caracteres ASCII de acordo com seus critérios. Embora existam alguns protocolos já definidos para esta classe de aplicativos, mas em geral eles são baseados no mesmo princípio. Um uso muito atual desse tipo de controle é aquele que usa módulos de comunicação Bluetooth.
CODE EXEMPLO ReadASCIIString.
Este programa de exemplo lê uma string de texto ou uma string e a converte em números inteiros. Esses números são usados para controlar o brilho de 3 LEDs, conectados aos pinos 3, 5 e 6 da placa Arduino Uno. A Figura 12 mostra o circuito eletrônico para testar este programa.
A Figura 13 mostra como digitar a string ou a string de texto a ser enviada para a placa Arduino Uno.
O código de exemplo está no menu: File-> Examples-> 04.Communication-> ReadASCIIString. O seguinte é o código para este exemplo:
const int redPin = 3;const int greenPin = 5;const int bluePin = 6; void setup() { // initialize serial: Serial.begin(9600); // make the pins outputs: pinMode(redPin, OUTPUT); pinMode(greenPin, OUTPUT); pinMode(bluePin, OUTPUT); } void loop() { // if there's any serial available, read it: while (Serial.available() > 0) { // look for the next valid integer in the incoming serial stream: int red = Serial.parseInt(); // do it again: int green = Serial.parseInt(); // do it again: int blue = Serial.parseInt(); // look for the newline. That's the end of your sentence if (Serial.read() == '\n') { // constrain the values to 0 - 255 and invert // if you're using a common-cathode LED, just use "constrain(color, 0, 255);" red = 255 - constrain(red, 0, 255); green = 255 - constrain(green, 0, 255); blue = 255 - constrain(blue, 0, 255); // fade the red, green, and blue legs of the LED: analogWrite(redPin, red); analogWrite(greenPin, green); analogWrite(bluePin, blue); // print the three numbers in one string as hexadecimal: Serial.print(red, HEX); Serial.print(green, HEX); Serial.println(blue, HEX); } } }
O programa começa definindo os pinos 3, 5 e 6 como redPin, greenPin e bluePin, respectivamente. Isso é feito com as seguintes linhas de código:
const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;
Em seguida, na função setup(), a comunicação serial é inicializada a 9600 bits por segundo e os pinos redPin, greenPin e bluePin são configurados como saída. Na função loop(), é verificado se um byte foi recebido na porta serial. Isso é feito com a instrução:
while (Serial.available ()> 0)
Nesse caso, a sequência de texto é lida até que algum caractere diferente de um valor numérico seja encontrado. Como a string enviada é separada pelo caractere de vírgula (,), a função:
Serial.parseInt ();
É responsável por remover o próximo número inteiro encontrado na porta serial. Qualquer caractere que não represente um número inteiro será ignorado. O valor de leitura é atribuído à variável de rede. Esta operação é repetida para todas as variáveis verde e azul. As linhas de código que fazem isso são:
int red = Serial.parseInt ();
int green = Serial.parseInt ();
int blue = Serial.parseInt ();
Então, verifica-se se o caractere ASCII da nova linha chegou, para o qual utilizamos a seguinte instrução:
if (Serial.read () == '\ n')
Se o novo caractere de linha chegar, então limitaremos os valores inteiros recebidos para um intervalo de 0 a 255, para o qual usamos a seguinte linha de código:
constrain (red, 0, 255);
Esta função, é receber em seu primeiro parâmetro um número inteiro e se o valor estiver dentro do intervalo dos próximos dois parâmetros, então retorna o mesmo valor, mas se o número for menor que o segundo parâmetro, então retorna o número valor do segundo parâmetro. Se o número inteiro for maior que o terceiro parâmetro, o valor do terceiro parâmetro retornará. Em outras palavras, essa função limita um número a um determinado intervalo.
Caso você esteja usando LEDs de anodo comuns, é necessário inverter o número inteiro para corresponder ao valor recebido pela porta serial. Para isso, podemos usar a seguinte função:
red = 255 - constrain(red, 0, 255);
O mesmo deve ser feito para números inteiros verdes e azuis. Finalmente, o brilho dos LEDs é controlado com as instruções:
analogWrite (redPin, red);
analogWrite (greenPin, green);
analogWrite (bluePin, blue);
E imprime na série Monitor, os números inteiros em formato hexadecimal. Para isso, as instruções são usadas:
Serial.print (red, HEX);
Serial.print (green, HEX);
Serial.println (blue, HEX);
EXEMPLO DE CÓDIGO ASCIITable.
Este programa ou esboço imprime ou exibe a tabela de caracteres ASCII no monitor serial. A Figura 14 mostra o resultado deste programa.
Juntamente com o caractere ASCII, seu valor equivalente em decimal, hexadecimal, octal e binário também é enviado. A análise de como este programa funciona é muito simples, porque as funções são muito intuitivas. O código de exemplo está no menu: File-> Examples-> 04.Communication-> ASCIITable. O seguinte é o código para este exemplo:
void setup() { //Initialize serial and wait for port to open: Serial.begin(9600); while (!Serial) { ; // wait for serial port to connect. Needed for native USB port only } // prints title with ending line break Serial.println("ASCII Table ~ Character Map"); } // first visible ASCIIcharacter '!' is number 33: int thisByte = 33; // you can also write ASCII characters in single quotes. // for example, '!' is the same as 33, so you could also use this: // int thisByte = '!'; void loop() { // prints value unaltered, i.e. the raw binary version of the byte. // The Serial Monitor interprets all bytes as ASCII, so 33, the first number, // will show up as '!' Serial.write(thisByte); Serial.print(", dec: ");
// prints value as string as an ASCII-encoded decimal (base 10). // Decimal is the default format for Serial.print() and Serial.println(), // so no modifier is needed: Serial.print(thisByte); // But you can declare the modifier for decimal if you want to. // this also works if you uncomment it: // Serial.print(thisByte, DEC); Serial.print(", hex: "); // prints value as string in hexadecimal (base 16): Serial.print(thisByte, HEX); Serial.print(", oct: "); // prints value as string in octal (base 8); Serial.print(thisByte, OCT); Serial.print(", bin: "); // prints value as string in binary (base 2) also prints ending line break: Serial.println(thisByte, BIN); // if printed last visible character '~' or 126, stop: if (thisByte == 126) { // you could also use if (thisByte == '~') { // This loop loops forever and does nothing while (true) { continue; } } // go on to the next character
thisByte++; }
CONCLUSÃO
Podemos ver que o manuseio da comunicação serial é muito simples. A principal função usada é Serial.println(). Esta função tem algumas variantes, mas todas fazem quase o mesmo, enviam dados através da porta serial. O utilitário é muito grande e apenas a imaginação pode determinar como usá-lo. Além disso, uma de suas principais aplicações é ver os resultados dos dados e fazer a depuração de código em programas ou esboços.
