Arduino Serial, ejemplos y funcionamiento

El Serial en Arduino, se refiere a un puerto que se utiliza para comunicar dos dispositivos digitales. Se usan dos pines, RX y TX. Por ejemplo dependiendo del tipo de tarjeta, puede haber 1 o mas puertos. Estos puertos consisten de dos pines llamados RX y Tx. Por lo general los datos a enviar estan codificados en caracteres.

Para Arduino, el modulo Serial se puede descomponer en dos elementos básicos:

  • Hardware. En Arduino el Hardware Serial se refiere a la cantidad de puertos físicos que puede tener una tarjeta, la velocidad máxima de comunicación así como las distintas configuraciones posibles. En este enlace puedes encontrar más información sobre el puerto serial.
  • Software. En relación al software, estan las funciones del lenguaje Arduino, que son utilizadas para controlar a dicho puerto, estas funciones son:
    • Serial.print . Esta función se encarga de imprimir caracteres seriales.
    • Serial.begin . Permite inicializar al puerto con una velocidad estándar.
    • Serial.read . Se utiliza para, si hay datos disponibles sin leer, se puedan capturar y procesar dichos caracteres seriales.
    • Serial.available . Esta función nos indicará si existen bytes que no han sido leidos del buffer.
      • Verdadero. Hay datos sin leer.
      • Falso. No hay datos nuevos en el puerto.
    • Serial.write . Funciona de forma similar a la función de Arduino Serial print, pero con la diferencia que se pueden escribir solo un byte a la vez en formato binario o hexadecimal.

Arduino Serial pinout o pines de conexión

De acuerdo al tipo de Tarjeta Arduino Serial, los pines o pinout para conectar el serial, en la siguiente imagen se muestran los pines para las tarjetas mas populares.

Por ejemplo, cada puerto esta identificado por un nombre unico, en el lenguaje Arduino son:

  • Serial. Para todas las tarjetas Arduino.
  • Serial1. Para casi todos los Arduinos sin incluyer el Arduino UNO.
  • Serial2
  • Serial3
Arduino serial pinout para tarjetas Arduino

En el Arduino UNO R3, el serial se controla mediante los pines 0 y 1. Esto es para los puertos reales, ya que se pueden usar otros pines como puertos seriales virtuales. En el siguiente tema platicaremos que podemos enviar por un puerto serial.

Arduino Serial pines de conexion

Comunicación Arduino Serial

Por lo general en la comunicación serial con Arduino, se envían caracteres codificados en ascii. Estos caracteres representan la mayoria de los caracteres usados en los idiomas que usan caracteres occidentales. Por ejemplo, para la agrupación de estos caracteres se denomina con el estandanr UTF-8. En la siguiente tabla se muestran equivalencias para algunos caracteres y su representación en numeros binarios y hexadecimales.

Para poder enviar caracteres en formato ascii se usan las funciones de Arduino Serial print y println. Por ejemplo, la siguiente instrucción:

Serial.println(«Hola Mundo!);

En realidad envia 12 caracteres ascii o 12 bytes de informacion binaria.

Ejemplos de codigo ascii

Ejemplos para Arduino Serial

A continuación veremos una serie de ejemplos básicos para iniciar una comunicación Serial en Arduino.

Configuración del puerto Serial en Arduino

El proceso de iniciar una comunicación mediante dos dispositivos seriales en Arduino, comienza con la configuración e inicialización del modulo. Esto se realiza mediante la siguiente instrucción:

Serial.begin(9600);

La instrucción anterior permite inicializar los pines RX y Tx para que puedan ser usados como puerto serial. Además configura el puerto con una velocidad estandar de 9600 Baudios por segundo. El puerto en Arduino Serial se configura con los siguientes parametros:

  • Velocidad: 9600 BAUD.
  • 8 bits de datos.
  • 1 bits de parada.
  • 0 bits de paridad.

Enviar caracteres por el puerto serial en Arduino

Para enviar caracteres por el puerto serial en Arduino, se requiere que el puerto este inicializado. Una vez que el puerto este listo, se pueden usar cualquiera de estas dos funciones:

  • Serial.print( ).
  • Serial.println( ).

Ejemplo enviar datos seriales:

En este ejemplo, se enviara la cadena de caracteres: «Hola Mundo!». Por ejemplo, dicha cadena consta de los siguientes caracteres:

Hola mundo en ascii

Si quieres ver como recibir datos seriales, o leer datos seriales te recomiendo que veas nuestro tutorial sobre la funcion Arduino serialEvent.

Autor: Dr. Rubén Estrada-Marmolejo

Referencia APA: Rubén Estrada-Marmolejo (2019, Marzo 22). Arduino Serial, ejemplos y funcionamiento. Obtenido de: https://hetpro-store.com/TUTORIALES/instalar-arduino-1-8-9-en-ubuntu-18-04/

5 comentarios en «Arduino Serial, ejemplos y funcionamiento»

  1. Hola:
    Hice un circuito para mover un servo con la señal de un sensor de flexión, quiero aplicar una librería de filtro para suavizar la señal pero no sé como combinar ambos códigos. podrían ayudarme con eso?

    saludos desde chile.

  2. Hola, tengo este codigo para un filtro Kalman para suavizar una señal del canal A0. Quizas te pueda servir, solo qu eesta algo revoltoso.
    int hola[500]; // Aqui se guarda la info del adc 0
    int i=0;
    int tdatos = 300; //Cuantos datos se usan para la calibración inicial
    int tdatos2 = 500; //Cuantos datos se toman para obtener los pulsos
    int baset2 = 4; //Base de tiempo, en milisegundos.
    int limite = 650; //En porcentaje el limite de corte de la señal normalizada
    int prom = 2; //La cantidad de datos a promediar

    int test22 = 0;

    //Kalman
    long double mean1 = 0.0;
    long double var1 = 0.0;
    double Xest = 0.0;
    double Phi1 = 1;
    double H1 = 1;
    double Pest1 = var1/1;
    double Qs = var1/100;
    double R1 = 0.1;
    double K1 = 0.0;
    double X1 = 0.0;
    double P1 = 0.0;

    //
    // the setup routine runs once when you press reset:
    void setup() {
    Serial.begin(115200);
    //Serial.println(«Tomando Datos…»);
    }

    // the loop routine runs over and over again forever:
    void loop() {

    /// Inicia la toma de datos para la calibración

    for(i=0; i<=tdatos-1; i++){ hola[i] = analogRead(A0); mean1 = mean1+hola[i]; delay(10); } mean1 = mean1/tdatos; for(i=0; i<=tdatos-1; i++){ var1 = var1+((hola[i]-mean1)*(hola[i]-mean1)); } var1 = var1/tdatos; Pest1 = var1/1; Qs = var1/100; //Serial.print("Media: "); //Serial.print((double)mean1); //Serial.print("Var: "); //Serial.print((double)var1); //Serial.print("Pest: "); //Serial.print(Pest1); //Serial.print("Qs: "); //Serial.print(Qs); // Serial.println("Fin Datos..."); // Serial.println("Inicia transmision Datos..."); for(i=0; i<=tdatos-1; i++){ /// Serial.println(hola[i]); delay(10); } // Serial.println("Fin transmision Datos..."); //Encontrar maximo int vmax=0; for(i=0; i<=tdatos-1; i++){ if(hola[i]>vmax) vmax = hola[i];
    }

    int vmin=1000;
    for(i=0; i<=tdatos-1; i++){ if(hola[i]=limite && bandera1 ==0) {
    bandera1 = i;

    }
    else if(hola[i] >= limite && bandera1 != 0 && (i-bandera1) > 30 ) {
    bandera2 = i;
    break;
    }

    }
    double pulso = (double)60/((double)(bandera2-bandera1)/100);

    // Serial.print(«Bandera1: «);
    // Serial.println(bandera1);
    // Serial.print(«Bandera2: «);
    // Serial.println(bandera2);
    // Serial.print(«Pulso: «);
    // Serial.println(pulso);

    /// Fin de calibración inicial

    /// Inicio la toma de las muestras para obtener el pulso.

    double pulso2 = 0.0; // Variable que guarda el pulso
    int jj=0;
    while(1){ // wait for a second
    bandera1 = 0;
    bandera2 = 0;
    // for(i=0; i<=tdatos2-1; i++){ // hola[i] = analogRead(A0); // delay(baset2); // } int A = 0; int B = 0; //test22 ++; for(i=0; i<=tdatos2-1; i++){ A =micros(); hola[i] = analogRead(A0); K1 = Pest1*H1/(H1*Pest1*H1+R1); X1 = Xest+K1*(hola[i]-H1*Xest); P1 = (1-K1*H1)*Pest1; Pest1 = Phi1*P1*Phi1+Qs; Xest = Phi1*X1; hola[i] = (int) X1; if(test22 != 10){ hola[i] = (int)(1000*(double)(hola[i]-vmin)/(vmax-vmin)); if(hola[i]100) break;
    else if(hola[i]>=limite && bandera1 ==0) {
    bandera1 = i;

    }
    else if(hola[i] >= limite && bandera1 != 0 && ((i-bandera1) > 20 )) {
    bandera2 = i;
    break;
    }
    else if( bandera1 == 0 && bandera2 == 0 && i >100) { break;
    //bandera1 = 0; bandera2 = 0;
    }
    }
    else {
    // hola[i] = analogRead(A0);

    }
    B = micros();
    delayMicroseconds(1000-(B-A));
    delay(baset2-1);

    // Serial.print(«Tiempo»);
    // Serial.println(B-A);
    }
    if(test22 != 10){

    pulso = (double)60/((double)(bandera2-bandera1)*baset2/1000); //if(pulso>0) Serial.println(pulso);
    if(pulso>0 && pulso<200){
    jj++;
    pulso2 = pulso2+pulso;
    if(jj==prom) {
    //Serial.print("ppm: ");
    Serial.println((double)pulso2/prom); //Imprimir el pulso
    pulso2=0;
    jj=0;
    }
    }
    else Serial.println("3"); /// Se envia si hay una desconexión

    }
    else {

    for(i=0; i<=tdatos2-1; i++){ Serial.println(hola[i]); delay(10); test22 = 0; } } } }

  3. Buenas noches, como puedo tener mas de 4 puertos seriales en un arduino mega 2560, ya me funciona para 4 RX, TX, (19,18 – 17,16 – 15,14 – 13,12), cuando agrego el puerto (11,10), me siguen funcionando solo 4, los tres primeros (en el orden que los escribí), y de los dos últimos solo me funciona 1, el que este de ultimo en las instrucciones del código fuente (todo lo anterior para lectura RX y escritura TX). Necesito 15 puertos con lectura y escritura, la pregunta es necesito utilizar 3 arduino mega o solo utilizando uno y activando de alguna manera los otros pines como puerto serial se podría?. de antemano agradezco su respuesta, sugerencias o recomendaciones

  4. Hola, estoy haciendo un proyecto y necesito comunicar un Arduino con un Microcontrolador y tenia la duda de Como activo el UART en el Arduino y le mando los datos a otro Arduino???

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *