Clase Stream

La clase Stream es la base de lectura de las secuencias basadas en caracteres y binarios en Arduino. No se llama directamente sino que se instancia un objeto y se le usa luego como métodos. Cada vez que veas que se usa el metodo read(), puedes asumir que se esta usando la clase Stream. Para funciones tipo print() la clase Stream hereda de la clase Print.

Esta clase esta presente en las siguientes librerías:

1. Métodos

Primero es necesario crear un objeto instaciando la clase Stream especifica según la librería.

libreria objeto;

1.1 available()

Obtiene el numero de bytes transmitidos y disponibles en el buffer. Devuelve un int.

objeto.available();

1.2 read()

Lee el primer byte disponible en el buffer de la secuencia entrante. Devuelve un -1 si hay datos disponibles.

objeto.read();

1.3 peek()

Lee un byte del buffer sin avanzar al siguiente byte. Es decir llamadas sucesivas a peek() devolverán el mismo valor igual que read(). De no haber mas bytes disponibles devuelve -1.

objeto.peek();

1.4 readBytes()

Lee caracteres desde el buffer la cantidad de bytes determinados por longitud. La función finaliza si la longitud determinada ha sido leída, o se agota el tiempo. Ver setTimeout(). Devuelve la cantidad de bytes colocados en el buffer.

objeto.readBytes(buffer, longitud);

longitud esta dado en int y representa el numero de char o bytes.

1.5 readBytesUntil()

Busca cierto carácter de una secuencia de entrada y la almacen un búfer. La función finaliza si se detecta el carácter del terminador, si se ha leído la longitud determinada o se agota el tiempo de espera (vea setTimeout ())

objeto.readBytesUntil(carácter, buffer, longitud);

carácter es el carácter a buscar, búfer donde almacenar los bytes y longitud en numero de bytes en int. Devuelve la cantidad de byte colocados en el buffer o 0 si no encontró datos validos.

1.6 readString()

Lee caracteres de una secuencia de entrada. La función finaliza si se agota el tiempo. Ver setTimeaout().

objeto.readString();

1.7 readStringUntil()

Lee caracteres de una secuencia de entrada. La función finaliza si se detecta el carácter terminador o se agota el tiempo. Ver setTimeout(). Devuelve toda la cadena leida hasta el caracter terminador.

objeto.readStringUntil(terminador);

1.8 flush()

Borra el búfer una vez que se han enviado todos los caracteres salientes. Devuelve boleano.

objeto.flush();

1.9 find()

Lee los datos de el buffer hasta que se encuentra la cadena objetivo. La función devuelve verdadero si se encuentra la cadena objetivo, falsa si se agota el tiempo de espera. Ver setTimeout().

objeto.find(objetivo);

1.10 findUntil()

Lee datos de la secuencia de entrada hasta que se encuentra el caracter objetivo o el caracter terminador. Un verdadero si encontro y falso si no encontro o se agoto el tiempo. Ver setTimeaout().

objeto.findUntil(objetivo, terminal);

1.11 parseInt()

Devuelve el primer número entero válido (largo) del búfer en serie. Los caracteres que no son digitos o el signo menos se saltan. El analisis se detiene cuando no se ha leido caracteres por cierto tiempo, en cuyo caso devuelve 0. Ver setTimeout(). Termina con el primer caracter no valido. Devuelve un numero de punto flotante o 0.

objeto.parseInt("","lista a caracteres a omitir");

1.12 parseFloat(lista)

Devuelve el primer numero de punto flotante en la secuencia de entrada. Los caracteres que no sea digitos o signo - se saltan.

objeto.parseFloat();

1.13 setTimeout()

Establece los milisegundos máximos para esperar los datos de la secuencia. Por defecto es 1000 milisegundos.

objeto.setTimeout(tiempo);

2. Clase Ethernet

La clase Ethernet inicializa la biblioteca de ethernet y la configuración de red.

2.1 begin()

Inicializa la biblioteca de ethernet y la configuración de red.

Ethernet.begin(mac);
Ethernet.begin(mac,ip);
Ethernet.begin(mac,ip,dns);
Ethernet.begin(mac,ip,dns,gateway);
Ethernet.begin(mac,ip,dns,gateway,subred);

Los parametros son:

Devuelve un 1 si la conexion es exitosa y 0 si no lo es.

#include <SPI.h>
#include <Ethernet.h> 
byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  
byte ip[] = {10,0,0,177};    

void setup (){
   Ethernet.begin(mac,ip); 
} 

1.2 localIP()

Obtiene la dirección IP del escudo de Ethernet. Útil cuando la dirección se asigna automáticamente a través de DHCP.

Ethernet.localIP();
#include <SPI.h> 
#include <Ethernet.h>
const byte mac[] = {0x00,0xAA,0xBB,0xCC,0xDE,0x02}; 
Cliente EthernetClient; 
void setup() {
   Serial.begin(9600); 
   if (Ethernet.begin(mac) == 0) { 
      Serial.println("Error al configurar Ethernet usando DHCP"); 
      ; 
  } 
  //Imprime tu dirección IP local 
  Serial.println(Ethernet.localIP()); 
} 

1.3 maintain()

Permite renovar la conexion al DHCP. Cuando se le asigna una dirección IP a través de DHCP, los dispositivos ethernet reciben un arrendamiento de la dirección por un período de tiempo. Con Ethernet.maintain(), es posible solicitar una renovación desde el servidor DHCP. Dependiendo de la configuración del servidor, puede recibir la misma, una nueva o ninguna dirección IP.

Ethernet.maintain();

Los parametros son:

2. Clase IPAddress

La clase IPAddress funciona con direccionamiento IP local y remoto.

#include <SPI.h>
#include <Ethernet.h>

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  
IPAddress ip(192,168,0,2);
const IPAddress dns(192, 168, 0, 1);
const IPAddress gateway(192, 168, 0, 1);
const IPAddress subnet(255, 255, 255, 0);

void setup(){
   Serial.begin(9600);
   Ethernet.begin(mac, ip, dns, gateway, subnet);
   Serial.print("IP = ");
   Serial.println(Ethernet.localIP());
}

3. Clase Server

La clase Servidor crea servidores que pueden enviar y recibir datos de clientes conectados (programas que se ejecutan en otros dispositivos).

3.1 EthernetServer()

Crea un servidor que escuche las conexiones entrantes en el puerto especificado. El puerto es un int.

EthernetServer(puerto)
#include <:SPI.h>:
#include <:Ethernet.h>:

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  
byte ip[] = {10,0,0,177};    
const byte gateway[] = {10,0,0,1};
const byte subnet[] = {255,255,0,0};

EthernetServer server = EthernetServer(23);

void setup(){
  Ethernet.begin(mac, ip, gateway, subnet);
  server.begin();
}

void loop(){
  EthernetClient client = server.available();
  if (client) {
    server.write(client.read());
  }
}

3.2 begin()

Le dice al servidor que comience a escuchar las conexiones entrantes.

server.begin();
#include <SPI.h>
#include <Ethernet.h>

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  
byte ip[] = {10,0,0,177};
const byte gateway[] = {10,0,0,1};
const byte subnet[] = {255,255,0,0};

EthernetServer server = EthernetServer(23);

void setup(){
   Ethernet.begin(mac, ip, gateway, subnet);
   server.begin();
}

void loop(){
   EthernetClient client = server.available();
   if (client){
      server.write(client.read());
   }
}

3.3 available()

Obtiene un cliente que está conectado al servidor y tiene datos disponibles para leer. La conexión persiste cuando el objeto cliente devuelto sale del alcance; puede cerrarlo llamando al cliente.stop().

server.available();
#include <Ethernet.h>
#include <SPI.h>

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  
byte ip[] = {10,0,0,177};
const byte gateway[] = {10,0,0,1};
const byte subnet[] = {255,255,0,0};

EthernetServer server = EthernetServer(23);

void setup(){
   Ethernet.begin(mac, ip, gateway, subnet);
   server.begin();
}

void loop(){
   EthernetClient client = server.available();
   if (client){
      server.write(client.read());
   }
}

3.4 write()

Escribir datos a todos los clientes conectados a un servidor. Esta información se envía como un byte o serie de bytes.

server.write(val) 
server.write(buf, len)

Los parametros son:

#include <SPI.h>
#include <Ethernet.h>

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};  
byte ip[] = {10,0,0,177};    
const byte gateway[] = {10,0,0,1};
const byte subnet[] = {255,255,0,0};

EthernetServer server = EthernetServer(23);

void setup(){
   Ethernet.begin(mac, ip, gateway, subnet);
   server.begin();
}

void loop(){
   EthernetClient client = server.available();
   if (client) {
      server.write(client.read());
   }
}

3.5 print()



3.6 println()





4. Clase Client

La clase de cliente crea clientes que pueden conectarse a servidores con diteccion IP y puerto especifico de internet, para enviar y recibir datos.

EthernetClient cliente;
#include <Ethernet.h>
#include <SPI.h>

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};
byte ip[] = {10,0,0,177};
const byte server[] = {64,233,187,99}; //Google

EthernetClient cliente;

void setup(){
   Ethernet.begin(mac, ip);
   Serial.begin(9600);
   delay(1000);
   Serial.println("conectando...");
   if (cliente.connect(server, 80)) {
      Serial.println("conectado");
      cliente.println("GET /search?q=arduino HTTP/1.0");
      cliente.println();
   }else{
      Serial.println("connection failed");
  }
}

void loop(){
   if (cliente.available()) {
      char c = cliente.read();
      Serial.print(c);
   }
   if (!cliente.connected()) {
      Serial.println();
      Serial.println("disconectando.");
      cliente.stop();
      for(;;)
        ;
   }
}

4.1 connect()

cliente.connect();
cliente.connect(ip, port)
cliente.connect(URL, port)

Las posibles respuestas son:

#include <Ethernet.h>
#include <SPI.h>

const byte mac[] = {0xDE,0xAD,0xBE,0xEF,0xFE,0xED};
byte ip[] = {10,0,0,177};
const byte server[] = {64,233,187,99}; //Google

EthernetClient cliente;

void setup(){
   Ethernet.begin(mac, ip);
   Serial.begin(9600);
   delay(1000);
   Serial.println("conectando...");
   if (cliente.connect(server, 80)) {
      Serial.println("conectado");
      cliente.println("GET /search?q=arduino HTTP/1.0");
      cliente.println();
   }else{
      Serial.println("conexion falida");
   }
}
void loop(){
   if (cliente.available()) {
      char c = cliente.read();
      Serial.print(c);
   }
   if (!cliente.connected()) {
      Serial.println();
      Serial.println("desconectando.");
      cliente.stop();
      for(;;)
      ;
   }
}

4.2 avalailable()

cliente.avalailable();


4.3 read()



4.4 write()

cliente.write();


4.5 print()

cliente.print();


4.6 println()

cliente.println();


4.7 flush()

cliente.flush();


4.8 stop()

cliente.stop();


5. Clase EthernetUDP

La clase EthernetUDP permite que se envíe y reciba el mensaje UDP.

5.1 begin()



5.2 avalaible()



5.3 beginPacked()



5.4 read()



5.5 write()



5.6 endPacket()



5.7 remoteIP()



5.8 remotePort()



5.9 stop()