Skip to content

Internet de las Cosas - IoT

Acercamiento al internet de las cosas mediante Arduino.

arduino uno

Preparación

Antes del taller debes revisar la siguiente documentación que utilizaremos en el taller.

NO podrá participar en el taller el alumnado que no se haya visto la documentación de forma previa.

Hardware

El hardware empleado para el taller son las placas compatibles con Arduino Uno de Keyestudio.

Firmware

Descripción

Cargar programa con: Archivo - Ejemplos - 01.Basics - Blink

Dado que la placa Arduino Uno no tiene soporte directo para depuración, utilizaremos la UART interna para facilitar la programación mediante envío de mensajes utilizando el monitor serie:

//------------------------
// Macros
//------------------------
    #define DEBUGMSG(X) \
        Serial.print("DEBUG: ");  \
        Serial.print(__PRETTY_FUNCTION__); \
        Serial.print(' '); \
        Serial.print(__FILE__); \
        Serial.print(':'); \
        Serial.print(__LINE__); \
        Serial.print(' '); \
        Serial.println(X);


//------------------------
// Constantes del sistema
//------------------------
// Pin a utiliar
// Pasos de incremento y periodo total

//------------------------
// Variables globales
//------------------------
// Tiempo up
// ¿Cada vez más tiempo en Up?

//------------------------
// Configuración del sistema
//------------------------
void setup() {
  // Pin de salida

  // Config puerto (hay versión ampliada)
  Serial.begin(9600);
  // Esperar a que esté disponible. El puerto es lento, mejor esperarlo si es algo crítico.
  while (!Serial) {
        ; // wait for serial port to connect. Needed for native USB
  }
}

//------------------------
// Programa principal
//------------------------
// A lo main() de Java, pero dentro de un bucle infinito
void loop() {

/* En cada ciclo debe estar un tiempo apagado y otro encendido. Dichos tiempos deben sumar el periodo.

Además, en cada ciclo, el tiempo encendido deber ir incrementándose hasta llegar al periodo, y luego irá decrementando, hasta llegar al paso mínimo.

Para facilitar el desarrollo, puedes emplear la función de depuración
  debugger(__PRETTY_FUNCTION__, __FILE__, __LINE__, tiempoUp) o la macro DEBUGMSG(X)
*/
}


//------------------------
// Funciones
//------------------------
// Mensajes de depuración con funciones
void debugger(String FUNCION, String FILE, int LINEA, int VALOR){
  Serial.print("DEBUG: ");  
  Serial.print(FUNCION); 
  Serial.print(' '); 
  Serial.print(FILE); 
  Serial.print(':'); 
  Serial.print(LINEA); 
  Serial.print(' '); 
  Serial.println(VALOR);
}

Comunicaciones por UART

Dev2Dev

Dev2PC

Necesitamos un arduino y un conversor USB - UART.

Partiendo del programa blink mejorado, añadiremos que nuestro Arduino escuche en el puerto UART y pare en caso de recibir el comando “stop” y se reactive si recibe “start”.

Firmware del Arduino:

//------------------------
// Constantes del sistema
//------------------------
// Comandos
const String STOP = String("stop");
const String START = String("start");
// Pin a utiliar
// Pasos de incremento y periodo total

//------------------------
// Variables globales
//------------------------

//------------------------
// Configuración del sistema
//------------------------
void setup() {
  // Aquí config
  }
}


//------------------------
// Programa principal
//------------------------
// A lo main() de Java, pero dentro de un bucle infinito
void loop() {

  // Zona blink

  // Zona comunicaciones
  String request = "";
  // Mientras haya datos disponibles leerlos y guardarlos en variable
  while(Serial.available()) {
    request += Serial.readString();
  }

  // Zona de control
  if ( request == STOP ) {
    habilitado = false;
    DEBUGMSG("Debemos parar");
  } else if ( request == START ) {
    habilitado = true;
    DEBUGMSG("Debemos reemprender");
  } else if ( request.length() != 0 ){
    DEBUGMSG("Otro COMANDO:"+request+"-"+request.length());
  }
}

Programa PC:

package uart;

import com.fazecast.jSerialComm.SerialPort;

import java.util.Arrays;
import java.util.Scanner;

public class ConexionUART{
    // Puerto UART de la placa
    private static final String PORT = "ttyUSB0";

    public static void main(String[] args) {
        ConexionUART conexionUART = new ConexionUART();
        conexionUART.start();
    }

    private void start(){
        // Capturamos los puertos UART disponibles
        SerialPort[] puertos = SerialPort.getCommPorts();
        System.out.println("Lista de puertos: \n" + Arrays.toString(puertos) );

        // Buscamos el puerto UART deseado (el ttyUSB0)
        SerialPort uart = null;
        for (SerialPort puerto : puertos) {
            String descripcionDelPuerto = String.format("%s, %s, %s, %s", puerto.getSystemPortName(), puerto.getPortDescription(), puerto.getSystemPortName(), puerto.getManufacturer());
            System.out.println(descripcionDelPuerto);
            if (puerto.getSystemPortName().equals(PORT)) {
                uart = puerto;
            }
        }

        // Si existe el puerto UART deseado, y podemos abrirlo
        if ( uart != null && uart.openPort() ){
            String comando;
            do {
                // Capturamos comando y enviamos
                System.out.println("Envía comando 'start/stop' para iniciar/detener:");
                Scanner sc = new Scanner(System.in);
                comando = sc.nextLine();
                // Salir del programa
                if (comando.equals("quit")) { break; }
                uart.writeBytes(comando.getBytes(), comando.length());

            } while ( ! comando.equals("quit") );
            uart.closePort();
        }
    }
}

Dependencias pom.xml:

<dependency>
    <groupId>com.fazecast</groupId>
    <artifactId>jSerialComm</artifactId>
    <version>[2.0.0,3.0.0)</version>
</dependency>