Comunicación Serial con Arduíno.

Todas las tarjetas Arduino tienen, al menos, un puerto de tipo Serial, situado en el conector 0 para la recepción de datos (RX) y el conector 1 para la emisión (TX). Estos dos conectores también se utilizan por el convertidor USB-Serie para comunicar por el puerto USB cuando se transfiere un nuevo programa a la tarjeta, pero aún así la transmisión de datos TX queda libre y a nuestra disposición ,ya que al cargar un programa solo se utiliza el canal RX. Por ejemplo puedo dejar conectado el puerto serie-usb con el ordenador al mismo tiempo que usamos el canal TX para enviar comandos Jogging a otro arduino con el firmware GRBL.

La funciones más importantes que debemos conocer para manejar el puerto serie son: begin(), read(), write(), print() y available())

  • begin() – estable la velocidad de la UART en baudios para la transmisión serie, también es posible configurar el número de bits de datos, la paridad y los bits de stop, por defecto es 8 bits de datos, sin paridad y un bit de stop. 
  • read() – lee el primer byte entrante del buffer serie. 

Sintaxis
Serial.read ()

Devoluciones
El primer byte de datos seriales entrantes disponible (o -1 si no hay datos disponibles). Tipo de datos: int.

  • write() – escribe datos en binario sobre el puerto serie. El dato es enviado como un byte o serie de bytes.

Escribe datos binarios en el puerto serie. Estos datos se envían como un byte o una serie de bytes; para enviar los caracteres que representan los dígitos de un número, utilice la función print () en su lugar.

Sintaxis
Serial.write (val)
Serial.write (str)
Serial.write (buf, len)

val: un valor para enviar como un solo byte.
str: una cadena para enviar como una serie de bytes.
buf: una matriz para enviar como una serie de bytes.
len: el número de bytes que se enviarán desde la matriz.

write () devolverá el número de bytes escritos, aunque leer ese número es opcional. Tipo de datos:size_t.

void setup() {
  Serial.begin(9600);
}

void loop() {
  Serial.write(45); // send a byte with the value 45

  int bytesSent = Serial.write("hello");  //send the string "hello" and return the length of the string.
}



--------------------------------
void setup() {
  Serial.begin(9600);

  Serial.write(45);     // write a byte with the value 45 => '-' character
  Serial.write('\n');   // write a newline character
  Serial.write("ArduinoGetStarted.com\n"); // write a string terminated by a newline character

  byte buf[] = {'A', 'r', 'd', 'u', 'i', 'n', 'o'};
  Serial.write(buf, 7); // write an array
}

void loop() {

Notas y advertencias
A partir de Arduino IDE 1.0, la transmisión en serie es asincrónica. Si hay suficiente espacio vacío en el búfer de transmisión, Serial.write () regresará antes de que los caracteres se transmitan en serie. Si el búfer de transmisión está lleno, Serial.write () se bloqueará hasta que haya suficiente espacio en el búfer. Para evitar bloquear llamadas a Serial.write (), primero puede verificar la cantidad de espacio libre en el búfer de transmisión usando availableForWrite ().

Serial.availableForWrite()

  • print() –Imprime datos en el puerto serie como texto ASCII legible por humanos. Este comando puede tomar muchas formas. Los números se imprimen utilizando un carácter ASCII para cada dígito. Los flotantes se imprimen de manera similar como dígitos ASCII, por defecto con dos lugares decimales. Los bytes se envían como un solo carácter. Los caracteres y las cadenas se envían tal cual. Por ejemplo-

Serial.print (78) da “78”

Serial.print (1.23456) da “1.23”

Serial.print (‘N’) da “N”

Serial.print (“Hola mundo”) da “Hola mundo”.

Un segundo parámetro opcional especifica la base (formato) a utilizar; Los valores permitidos son BIN (binario o base 2), OCT (octal o base 8), DEC (decimal o base 10), HEX (hexadecimal o base 16). Para números de coma flotante, este parámetro especifica el número de posiciones decimales que se utilizarán. Por ejemplo-

Serial.print (78, BIN) da “1001110”

Serial.print (78, OCT) da “116”

Serial.print (78, DEC) da “78”

Serial.print (78, HEX) da “4E”

Serial.print (1.23456, 0) da “1”

Serial.print (1.23456, 2) da “1.23”

Serial.print (1.23456, 4) da “1.2345”

Puede pasar cadenas basadas en memoria flash a Serial.print () envolviéndolas con F (). Por ejemplo:

Serial.print (F (“Hola mundo”))

Para enviar datos sin conversión a su representación como caracteres, use Serial.write ().

Sintaxis
Serial.print (val)
Serial.print (val, formato)

Parámetros
Serie: objeto de puerto serie. Consulte la lista de puertos serie disponibles para cada placa en la página principal de serie.
val: el valor a imprimir. Tipos de datos permitidos: cualquier tipo de datos.

Devoluciones
print () devuelve el número de bytes escritos, aunque leer ese número es opcional. Tipo de datos: size_t.

/*
  Uses a for loop to print numbers in various formats.
*/
void setup() {
  Serial.begin(9600); // open the serial port at 9600 bps:
}

void loop() {
  // print labels
  Serial.print("NO FORMAT");  // prints a label
  Serial.print("\t");         // prints a tab

  Serial.print("DEC");
  Serial.print("\t");

  Serial.print("HEX");
  Serial.print("\t");

  Serial.print("OCT");
  Serial.print("\t");

  Serial.print("BIN");
  Serial.println();        // carriage return after the last label

  for (int x = 0; x < 64; x++) { // only part of the ASCII chart, change to suit
    // print it out in many formats:
    Serial.print(x);       // print as an ASCII-encoded decimal - same as "DEC"
    Serial.print("\t\t");  // prints two tabs to accomodate the label lenght

    Serial.print(x, DEC);  // print as an ASCII-encoded decimal
    Serial.print("\t");    // prints a tab

    Serial.print(x, HEX);  // print as an ASCII-encoded hexadecimal
    Serial.print("\t");    // prints a tab

    Serial.print(x, OCT);  // print as an ASCII-encoded octal
    Serial.print("\t");    // prints a tab

    Serial.println(x, BIN);  // print as an ASCII-encoded binary
    // then adds the carriage return with "println"
    delay(200);            // delay 200 milliseconds
  }
  Serial.println();        // prints another carriage return
}
  • available() – Obtiene el número de bytes (caracteres) disponibles para leer desde el puerto serie. Se trata de datos que ya llegaron y se almacenaron en el búfer de recepción en serie (que contiene 64 bytes).

Serial.available () hereda de la clase de utilidad Stream.

Sintaxis
Serial.available()()

Devoluciones
El número de bytes disponibles para leer.

Código de ejemplo
El siguiente código devuelve un carácter recibido a través del puerto serie.

int incomingByte = 0; // for incoming serial data

void setup() {
  Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}

void loop() {
  // send data only when you receive data:
  if (Serial.available() > 0) {
    // read the incoming byte:
    incomingByte = Serial.read();

    // say what you got:
    Serial.print("I received: ");
    Serial.println(incomingByte, DEC);
  }
}

  • if(Serial) –

Indica si el puerto serie especificado está listo.

En las placas con USB nativo, si (Serial) (o si (SerialUSB) en el vencimiento) indica si la conexión en serie USB CDC está abierta o no. Para todas las demás placas y los puertos CDC que no son USB, esto siempre será verdadero.

Esto se introdujo en Arduino IDE 1.0.1.

Sintaxis
si (serial)

Devoluciones
Devuelve verdadero si el puerto serie especificado está disponible. Tipo de datos: bool.

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
  }
}

void loop() {
  //proceed normally
}
  • find() –

Serial.find () lee datos del búfer en serie hasta que se encuentra el objetivo. La función devuelve verdadero si se encuentra el objetivo, falso si se agota el tiempo de espera.

Serial.find () hereda de la clase de utilidad de transmisión.

Sintaxis
Serial.find (objetivo)
Serial.find (destino, longitud)


target: la cadena a buscar. Tipos de datos permitidos: char.
longitud: longitud del objetivo. Tipos de datos permitidos: size_t.

Devoluciones
Tipo de datos: bool.

Ejemplo de recepción del puerto serial 2.Observar que uso while() y no if(),

while (Serial2.find("ABC"){
//instrucciones
}

  • readBytes() 

Serial.readBytes () lee caracteres del puerto serie en un búfer. La función termina si se ha leído la longitud determinada o se agota el tiempo de espera (consulte Serial.setTimeout ()).

Serial.readBytes () devuelve el número de caracteres colocados en el búfer. Un 0 significa que no se encontraron datos válidos.

Serial.readBytes () hereda de la clase de utilidad Stream.

Sintaxis
Serial.readBytes (búfer, longitud)

Parámetros
Serie: objeto de puerto serie. Consulte la lista de puertos serie disponibles para cada placa en la página principal de serie.
búfer: el búfer en el que almacenar los bytes. Tipos de datos permitidos: matriz de caracteres o bytes.
longitud: el número de bytes a leer. Tipos de datos permitidos: int.

Devoluciones
El número de bytes colocados en el búfer. Tipo de datos: size_t.

  • readBytesUntil() –

Serial.readBytesUntil () lee caracteres del búfer serial en una matriz. La función termina (se realizan comprobaciones en este orden) si se ha leído la longitud determinada, si se agota el tiempo de espera (ver Serial.setTimeout ()), o si se detecta el carácter terminador (en cuyo caso la función devuelve los caracteres hasta el último carácter antes del terminador suministrado). El terminador en sí no se devuelve en el búfer.

Serial.readBytesUntil () devuelve el número de caracteres leídos en el búfer. Un 0 significa que el parámetro de longitud <= 0, se produjo un tiempo de espera antes de cualquier otra entrada o se encontró un carácter de terminación antes que cualquier otra entrada.

Serial.readBytesUntil () hereda de la clase de utilidad Stream.

Sintaxis
Serial.readBytesUntil (carácter, búfer, longitud)

character: el character a buscar. Tipos de datos permitidos: char.
buffer: el bufferr en el que almacenar los bytes. Tipos de datos permitidos: matriz de caracteres o bytes.
longitud: el número de bytes a leer. Tipos de datos permitidos: int.

Devoluciones
Tipo de datos: size_t.

Notas y advertencias
El carácter terminador (‘\n’)) se descarta del búfer en serie, a menos que el número de caracteres leídos y copiados en el búfer sea igual a la longitud.

  • serialEvent() – Esta función se llama automáticamente al final de loop () cuando hay datos en serie disponibles en el búfer. En este caso, cada carácter encontrado se agrega a una cadena hasta que se encuentra una nueva línea. Luego, la cadena se imprime y se vuelve a establecer en nulo. Se utiliza Serial.read () para capturar estos datos.
void serialEvent() {
 //instrucciones
}
Void setup() {
  Serial.begin(9600);
}

void loop() {
}

void serialEvent() {
  int incomingByte = Serial.read();

  // prints the received data
  Serial.print("I received: ");
  Serial.println((char)incomingByte);
}
/*
  Serial Event example

  When new serial data arrives, this sketch adds it to a String.
  When a newline is received, the loop prints the string and clears it.

  A good test for this is to try it with a GPS receiver that sends out
  NMEA 0183 sentences.

 

String inputString = "";         // a String to hold incoming data
bool stringComplete = false;  // whether the string is complete

void setup() {
  // initialize serial:
  Serial.begin(9600);
  // reserve 200 bytes for the inputString:
  inputString.reserve(200);
}

void loop() {
  // print the string when a newline arrives:
  if (stringComplete) {
    Serial.println(inputString);
    // clear the string:
    inputString = "";
    stringComplete = false;
  }
}

/*
  SerialEvent occurs whenever a new data comes in the hardware serial RX. This
  routine is run between each time loop() runs, so using delay inside loop can
  delay response. Multiple bytes of data may be available.
*/
void serialEvent() {
  while (Serial.available()) {
    // get the new byte:
    char inChar = (char)Serial.read();
    // add it to the inputString:
    inputString += inChar;
    // if the incoming character is a newline, set a flag so the main loop can
    // do something about it:
    if (inChar == '\n') {
      stringComplete = true;
    }
  }
}

8. Strings

Deja una respuesta

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

➤
Translate »