La interfaz más antigua en ordenadores y microcontroladores es la interfaz serial, a menudo marcada con Rx/Tx (= Recibir / Transmitir) o UART (= Transmisor-Receptor Asíncrono Universal). Para la realización técnica, se publicaron normas con los nombres RS-232 o EIA-485. Con una velocidad inicial de 75 baudios, los primeros ordenadores se conectaron a través de un módem en el mundo de las teleimpresoras. El progreso técnico nos ha aportado, velocidades de transmisión de 300, 1200, 2400, 9600, 19200 baudios hasta 56kBaud. Entonces, comenzó la era del DSL.

De aquella época quedan estas interfaces como conexión entre los ordenadores y los microcontroladores. Debido a la ausencia de la antigua interfaz COM en el PC, hoy en día se utiliza un adaptador USB con un Virtual Comm. Se requiere un puerto (VCP). El componente esencial, por ejemplo, ATmega 16U2, CH340/341 o FT232 puede estar instalalado en la MCU o - para los microcontroladores muy pequeños - puede ser necesario como un adaptador USB-serial separado, por ejemplo, UART-TTL USB Adaptador de Interfaz con CH340G de 3.3V y 5V o FT232-AZ USB a TTL Adaptador serie de 3.3V y 5V. Si es necesario, se debe instalar el controlador necesario en Windows.

En nuestro microcontrolador con ATMEGA 328P, los pines 2 y 3 (parte superior izquierda en la imagen) están conectados al chip para la interfaz USB ATMEGA 16U2, así como a los pines 0 = Rx y 1 = Tx. Por lo tanto, durante la programación y cuando se utliza el monitor serial en funcionamiento, los GPIO 0 y 1 no deben utilizarse de ninguna otra manera. Lo mejor es no utilizarlos en absoluto.

En este blog, sin embargo, queremos conectar microcontroladores entre sí y enviar datos (por ejemplo, datos de sensores) de un MCU a un segundo microcontrolador. El sketch del microcontrolador emisor parece bastante simple. El código es idéntico al del envío de datos al monitor serie. La interfaz serial se abre y se envían los datos con Serial.print () o Serial.println ().

Aquí está el sketch para la visualización de la humedad relativa y la temperatura en el monitor serial, al mismo tiempo, el "envío" microcontrolador (Descargar):

 # include "dht.h"
  
 #define dhtpin 2// GPIO PIN de Datos
 #define DHTTYPE DHT22 // DHT22 (AM2302)
 DHT DHT(DHTPIN, DHTTYPE);
  
 vacío configurar(vacío) {
   De serie.Empezar(9600);
   De serie.println(F("Prueba de DHT22!"));
   DHT.Empezar();
 }
  
 vacío círculo(vacío) {
   flotador H = DHT.Readhumidity();
   flotador t = DHT.Temperatura de lectura();
   De serie.impresión(F("T ="));
   De serie.impresión(t);
   De serie.impresión(F("° C H ="));
   De serie.impresión(H);
   De serie.println(F(" % "));
   demora(1000);
 }

Para el segundo microcontrolador, iniciamos de nuevo el Arduino IDE.

Atención: Para abrir dos puertos virtuales diferentes, el Arduino IDE se debe iniciar por segunda vez (instanciado), una nueva ventana no es suficiente.

En primer lugar, se carga el sketch para la recepción de los datos y, a continuación, se conectan de forma cruzada Tx y Rx.

Atención: Mientras los sketches se carguen en uno u otro microcontrolador, los MCUs no deben estar conectados entre sí. Esto se remedia con el uso de SoftwareSerial. Con esto también podemos recibir datos y mostrar (posiblemente más) datos en el monitor serial al mismo tiempo. Más adelante se revisará esto.

Aquí está el primero diagrama del circuito:

Debido a las diferentes voltajes en el microcontrolador con ATmega 328P (5V) y el D1 Mini (3.3 V) he instalado un divisor de voltaje con 1 kOhm y 2,2 kOhm entre Tx en el microcontrolador emisor y Rx en el D1 Mini. Como alternativa, puede utilizar con Convertidor de nivel lógico.

Aquí están las explicaciones de la Librería SoftwareSerial

Como se mencionó anteriormente, el hardware de Arduino tiene soporte incorporado para la comunicación serial en los pines 0 = Rx y 1 = Tx (que también pasa a través de la conexión USB al ordenador). Por lo tanto, los pines digitales 0 y 1 no se deben utilizar en el programa si es posible.

El soporte serial nativo es proporcionado por el hardware (integrado en el chip) llamado UART. Este hardware permite al chip ATMega recibir comunicaciones serial incluso mientras trabaja otras tareas, siempre que haya espacio en el búfer serial de 64 bytes.

La librería HardwareSerial está integrada en el Arduino IDE y no es necesaria incluirla (excepción: ESP32 Serial1 y Serial2).

La librería SoftwareSerial está diseñada para proporcionar una comunicación serial adicional en otros pines digitales del Arduino, utilizando software para replicar la funcionalidad (de ahí el nombre de "SoftwareSerial"). Es posible inicializar varios puertos serial de software a velocidades de hasta 115200 bps, pero sólo se puede utilizar uno a la vez. Un parámetro opcional permite la inversión de las señales para los dispositivos que requieren este protocolo.

Para utilizar esta librería, primero hay que incluirla con:

 # include 

A continuación, un objeto con un nombre de su elección, a menudo mySerial o SoftSerial, es instanciado con los pines utilizados (7 y 8 en el ejemplo) con:

 serie de software mySerial(7,8,);     // RX, TX

Hay que tener en cuenta que el pin Rx es capaz de generar interrupciones.
Finalmente, el objeto mySerial se inicia en la función void setup () en la función void setup () con la velocidad deseada (tasa de baudios) (se permiten tasas de baudios de 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600 y 115200):

 mySerial.Empezar(9600);

Encontrará más explicaciones y, sobre todo, restricciones, en https://www.arduino.cc/en/Reference/SoftwareSerial

A continuación, un resumen de los métodos / funciones (con un enlace a la documentación de Arduino):

SoftwareSerial(), available(), begin(), isListening(), overflow(), peek(), read(), print(), println(), listen(), write().

Y aquí viene el sketch para la recepción de datos (Descargar):

 # include 
 serie de software Serial suave;
  
 // variable global para almacenar los datos entrantes
 En t datos = 0; 
 cuerda conjunto de datos="";
 cuerda dataSet="";
  
 vacío configurar() {
   // Comenzar de comunicaciones serie con 9600 baudios
   De serie.Empezar(9600);
   Serial suave.Empezar(9600, SWSERIAL_8N1, 4, 5, falso);   // RX = 4, TX = 5
 }
 vacío círculo() {
   // Cuando se dispone de datos ...
   si (Serial suave.disponible() > 0) {
       // Leer datos de entrada
       datos = Serial suave.leer();
     // Formato de datos es ASCII (0,255)
     // TANTO conversión a char ()
       si (carbonizarse(datos) != '\ N')  {
       conjunto de datos += carbonizarse(datos);
     }  
     demás  {
       De serie.println("Conjunto de datos");    
       De serie.println(conjunto de datos);
       De serie.println();
       dataSet = conjunto de datos;      
       conjunto de datos="";
     }
   }
 }

Los comentarios sobre el sketch:

Los datos se reciben en formato ASCII como caracteres individuales. Para el procesamiento posterior, primero necesitamos la concatenación (= encadenar juntos) de los caracteres para formar una cadena. Siempre que no se alcance el final de la línea (\ n), los caracteres individuales (datos) se combinan para formar el conjunto de datos de cadena después de la conversión con char ().

Si el carácter recibido es igual al salto de línea (\ n), se produce el salto a else con la salida del conjunto de datos de la cadena en el monitor serial, el almacenamiento de la cadena en una segunda dataSet (Con la S mayúscula) para su posterior procesamiento, así como el restablecimiento de conjunto de datos a la cadena vacía para la recepción de datos de nuevo.

Por supuesto, la cadena completa puede colocarse en la WLAN doméstica como servidor web con un microcontrolador ESP y visualizarse completamente en el navegador del PC o del smarthphone. Sin embargo, si se quiere seguir procesando los valores de temperatura y humedad relativa, hay que descomponer la cadena y convertir los caracteres en los respectivos valores numéricos con decimales (float).

Para ello necesitamos las funciones substring() y toFloat(). Las líneas correspondientes en el código son:

 Cuerda Tstring = conjunto de datos.subcadena(de, para);
 Cuerda hstring = conjunto de datos.subcadena(de, para);
 T = Tstring.flotar();
 H = hstring.flotar();

Por último, la pregunta que queda por resolver es qué valores utilizamos para from y to para obtener las dos subcadenas de forma que podamos convertirlas en números de punto flotante (= floating point!).

En el primer intento, conté los caracteres. El recuento del índice comienza en 0, from es el índice inclusivo, desde donde comienza la subcadena, to es el índice exclusivo del final, excluido, es decir, el primera caracter después. Esto funciona siempre y cuando los valores de la temperatura y la humedad tengan dos dígitos antes del punto decimal. Las temperaturas de un solo dígito o los signos de menos estropean el recuento. Así que necesitamos puntos de referencia para los índices. Decidí determinar el índice para T y H respectivamente, porque las funciones para los caracteres (isAlpha(), isAlphaNumeric(), IsAscii(), isControl(), isDigit(), isGraph(), isHexadecimalDigit(), isLowerCase(), isPrintable(), isPunct(), isSpace(), IsUpperCase(), isWhiteSpace()) eran desafortunadamente inadecuadas para este propósito.

Así que, sin más, programé un bucle for en el que se comprueba desde index = 0 hasta la última posición (función length()), si charAt (i) es igual a 'T' o 'H'. (Nota: char requiere 'comillas simples') ahora tenía una referencia para cade una de mis subcadenas. Los valores exactos dependen de la cadena emitida, por supuesto.

 por (En t I=0; I<=conjunto de datos.largo(); I++)  
     {
       SI (conjunto de datos.charat(I) == "T") índice = I;
       SI (conjunto de datos.charat(I) == 'H') indexh = I;           
     } 

Aquí está el sketch completo (Descargar):

 por (En t I=0;I<=conjunto de datos.largo();I++)  
 # include 
 SoftwareSerial SoftSerial;
  
 // variables globales para almacenar los datos entrantes
 En t dateness = 0; 
 Cuerda conjunto de datos="";
 Cuerda conjunto de datos="";
 En t índice;
 En t indexh;
 flotador T;
 flotador H;
  
 vacío configurar() {
   // Comenzar de comunicaciones serie con 9600 baudios
   De serie.Empezar(9600);
   SoftSerial.Empezar(9600, Swserial_8n1, 4, 5, falso);
 }
 vacío círculo() {
   // Cuando datos se encuentran disponibles ...
   SI (SoftSerial.Disponible() > 0) {
       // Leer entrante de datos
       dateness = SoftSerial.leyendo();
     // Formato de datos es ASCII (0..255),
     // por lo tanto, la conversión a char ()
       SI (Carbonizarse(dateness) != '\ N')  {
       conjunto de datos += Carbonizarse(dateness);
     }  
     Demás  {
       De serie.println("Conjunto de datos");    
       De serie.println(conjunto de datos);
       De serie.println();
       conjunto de datos = conjunto de datos;      
       conjunto de datos="";
       Conversión de datos();
     }
   }
 }
 vacío Conversión de datos()  {  
   por (En t I=0; I<=conjunto de datos.largo(); I++)  
     {
       SI (conjunto de datos.charat(I) == "T") índice = I;
       SI (conjunto de datos.charat(I) == 'H') indexh = I;           
     } 
     Cuerda Tstring = conjunto de datos.subcadena(índice+4, indexh-5);
     Cuerda hstring = conjunto de datos.subcadena(indexh+4, indexh+9);
     T = Tstring.flotar();
     H = hstring.flotar();
     De serie.impresión("T =");
     De serie.println(T);
     De serie.impresión("H =");
     De serie.println(H);    
     De serie.println();
 }

Espero que estos pequeños consejos y trucos sobre la transmisión de datos y la manipulación de cadenas sean útiles. Yo mismo tuve que manipular un buen tiempo. Pronto podrá leer el resultado global de nuestros experimentos, El resultado global de nuestros experimentos, incluida la salida de datos en la WLAN, en el E-Book de nuestro Smart Home Starter Set.