Electrónica y programación para Microcontroladores.

Cursos técnicos para electrónica programable

Mapa
Estamos en

Urquiza 1695, Entre Ríos, Gualeguaychú

Email
Contactanos

consultas@firteconline.com.ar

Arduino

Siendo evidente la importancia que tiene ARM en el mundo de la electrónica, a la hora de trabajar con estos dispositivos se  presentan distintas opciones para encarar su programación. 
Por ejemplo imaginemos que estamos trabajando con un Cortex M4, en C (32 bits)
tenemos dos caminos, podemos usar las librerías clásicas de periféricos (LL) o la nueva biblioteca HAL(Capa de Abstracción de Hardware).
La diferencia entre ambos enfoques es grande, las librerías en bajo nivel para periféricos son especializadas para cada microcontrolador, contienen las definiciones de registros y bits de control del microcontrolador
y un conjunto de funciones destinadas a completar las estructuras que finalmente configuran al periférico.
El programador y la electrónica están muy vinculados y es normal trabajar con la hoja de datos del microcontrolador para tener certeza de lo
que estamos haciendo con los registros de la CPU.
Todo esto ofrece una gran optimización de código pero una menor portabilidad y un gran trabajo del programador lo que implica mayor tiempo para el desarrollo de una aplicación.

Que es el CAN BUS (Controller Area Network).

Desde mediados de los años 90 en todos los vehículos los sistemas de motor y transmisión se han basado en una red de sensores que envían información a la computadora de abordo, de esta forma se ajusta la cantidad de combustible, los cambios en la transmisión y en general todo lo que hace al funcionamiento del vehículo.

Pero fue recién a mediados del 2000 que los sistemas evolucionaron para incluir el CAN BUS.
Este bus usa el método de transmisión broadcast, es decir, un elemento envía un mensaje a través del bus a todos los componentes, y estos se encargan de saber si la información del mensaje le es útil o no. Si el mensaje fuese de interés para algún nodo, este lo almacena y procesa, si no, simplemente la deshecha.

En este escenario podemos ver que la “Unidad de control 2″, envía el mensaje que tenía almacenado en memoria al bus, y todas las demás unidades ven ese mensaje a sus entradas. Sin embargo la “Unidad de control 3″ deshecha este mensaje en la etapa de “Selección”, mientras que las restantes deciden que es apropiado y lo almacenan.

ZigBee es el nombre de un conjunto de protocolos de alto nivel para la comunicación inalámbrica por enlace de radio de bajo consumo basada en el estándar IEEE 802.15.4 de redes inalámbricas de área personal. 
Su objetivo son las aplicaciones que requieren comunicaciones seguras con baja tasa de envío de datos y un muy bajo consumo de energía, e
n principio el ámbito donde esta tecnología tiene mayor presencia es en domótica y la razón de ello son las características que lo diferencian de otras tecnologías.

  • Su bajo consumo.
  • Su topología de red en malla.
  • Su fácil integración (se pueden fabricar nodos con muy poca electrónica).

ZigBee es similar al Bluetooth pero con algunas diferencias y ventajas por ejemplo una red ZigBee puede constar de un máximo de 65535 nodos distribuidos en subredes de 255 nodos cada una, frente a los ocho máximos de una subred (Piconet) Bluetooth.
Menor consumo eléctrico que el Bluetooth, en términos exactos ZigBee tiene un consumo de 30 mA transmitiendo y de 3 μA en reposo frente a los 40 mA transmitiendo y 0,2 mA en reposo que tiene el Bluetooth.
Este menor consumo se debe a que el sistema ZigBee se queda la mayor parte del tiempo dormido, mientras que en una comunicación Bluetooth esto no se puede dar y siempre se está transmitiendo y/o recibiendo.

Tiene una velocidad de hasta 250 kbit/s siendo claramente mas lento que Bluetooth y es debido a esto que cada uno es más apropiado que el otro para ciertas cosas.
Por ejemplo, mientras que el Bluetooth se usa para aplicaciones como los teléfonos móviles y la informática, la velocidad del ZigBee se hace insuficiente para estas tareas, siendo mas adecuado para el control electrónico, manejo de sensores y en general los productos dependientes de baterías como sensores también juguetes en los cuales la transferencia de datos es menor.

ZigBee tiene tres categorías de nodos.
El Coordinador ZigBee es el nodo más completo y se encarga de controlar toda la red y los caminos para su comunicación.
Por debajo tenemos el Router ZigBee que conecta los nodos entre si para poder ejecutar código del usuario, es decir, ofrece un nivel de aplicación dentro de la torre de protocolos.
Por último, el Dispositivo final ZigBee sólo recibe información y se comunica únicamente con el nodo padre.
La ventaja de este dispositivo es que puede permanecer dormido y ‘despertarse’ en ciertos momentos para alargar la duración de batería.
Sin duda que ZigBee es una alternativa interesante para la comunicación entre distintos dispositivos que necesiten de un consumo energético reducido. Al contrario que el Bluetooth o el WiFi, ZigBee es una opción a tener en cuenta a la hora de domotizar una casa.
Además, el Internet de las Cosas puede recurrir a esta tecnología en lugar de a dispositivos conectados por WiFi.
Por ejemplo, creando un nodo central con conexión a Internet y con suministro energético constante se podrían verificar todos los aspectos de una vivienda manteniendo una carga de datos sobre la red ZigBee y no sobre WiFi que solo se usaría cuando hay algo relevante que informar a la red exterior.

 En este vídeo se puede ver el envío de los datos obtenidos de un sensor BME280 a través de una red ZigBee. El controlador usado es una placa Arduino Uno, un sensor BME280 montado sobre un mikroBus.
En este simple ejemplo se ha definido una red ZigBee con el ID_PAN 0x40F3, este identificador es el ID de la red (similar al SSID en una red WiFi) que identifica esta red de otras que pudieran existir en el área.
Luego simplemente se envía el paquete de datos al nodo apuntado. 
El siguiente es el código del transmisor.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/**********************************************************************
** Descripción  : Lee un sensor BME280 y envía los datos por ZigBee            
**                usando el controlador MRF24J40MA a 2.4 Ghz
**                
**  Target       : Arduino UNO
**  ToolChain    : Arduino IDE 1.8.9 bajo Linux Debian
**  www.firtec.com.ar 
**********************************************************************/
#include <Wire.h>
#include <SPI.h>
#include <mrf24j.h>
 
#include "SparkFunBME280.h"
BME280 Sensor; 
 
#define pin_reset 6
#define pin_cs 10   // Pin CS por defecto para ATmega 328
#define pin_irq  2  // IRQ para ATmega 328
 
 
Mrf24j mrf(pin_reset, pin_cs, pin_irq);
long tiempo_anterior;
long temporizador = 3000;
char buffer[20]=" ";
byte contador = 0;
 
void setup()
{
  Serial.begin(9600);
  mrf.reset();  // Inicia el reset del modulo ZegBee
  mrf.init();   // Configuración inicial del modulo
  mrf.set_pan(0x40F3);  // ID de la red ZigBee
  Wire.begin();
 
  Sensor.setI2CAddress(0x76); //Connect to a second sensor
  if(Sensor.beginI2C() == false) Serial.println("Sensor ERROR!!");
}
 
void loop(){
     unsigned long tiempo_actual = millis();
    if (tiempo_actual - tiempo_anterior > temporizador) {
        tiempo_anterior = tiempo_actual;
  
   switch(contador){
   case 0:{
        dtostrf(Sensor.readTempC(),2,1,buffer);
        mrf.send16(0x4202, buffer);  // Envía buffer al nodo destino (0x4202)
        Serial.println(buffer);
        contador++; 
        break; 
        }
        
       case 1:{       
        dtostrf(Sensor.readFloatHumidity(),2,1,buffer);
        mrf.send16(0x4202, buffer); // Envía buffer al nodo destino (0x4202)
        Serial.println(buffer);
        contador++;
        break; 
        }
       case 2:{
         dtostrf((Sensor.readFloatPressure()/100),4,0,buffer);
         mrf.send16(0x4202, buffer);   // Envía buffer al nodo destino (0x4202)
         Serial.println(buffer);
         contador = 0;
         break;  
       }
    }           
  }
}

Este el código del receptor ZigBee.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
/**********************************************************************
** Descripción  : Recibe los datos de un sensr BME280 por ZigBee            
**                usando el controlador MRF24J40MA a 2.4 Ghz
**                
**  Target       : Arduino UNO
**  ToolChain    : Arduino IDE 1.8.9 bajo Linux Debian
**  www.firtec.com.ar 
**********************************************************************/
#include <SPI.h>
#include <mrf24j.h>
 
#define pin_reset   6
#define pin_cs      10  // Pin CS para ATmega 328
#define pin_ISR     2   // Pin IRQ para ATmega 328
 
Mrf24j mrf(pin_reset, pin_cs, pin_ISR);
 
void setup() {
  Serial.begin(9600);
  
  mrf.reset();
  mrf.init();
  
  mrf.set_pan(0x40F3);  // Identificador de la red ZigBee
  mrf.address16_write(0x4202); // Identificador del dispositivo en la red
  attachInterrupt(0, Rutina_ISR, CHANGE); // IRQ 0 equivale al pin 2(INT0) en ATmega 328
  interrupts(); // Interrupciones activas
}
 
void Rutina_ISR() {
  mrf.interrupt_handler(); // mrf24 manejador de interrupciones del modulo zigbee
}
 
void loop() {
    mrf.check_flags(&vector_rx, &vector_tx);
}
 
void vector_rx() {
  Serial.println("");
   
    for (int i = 0; i < mrf.rx_datalength(); i++) {
        Serial.write(mrf.get_rxinfo()->rx_data[i]);
        }
}
 
void vector_tx() {
    // IRQ del transmisor (no se usa en este ejemplo)
}

La programación completa para Arduino se puede descargar desde este link y la biblioteca para Arduino.


 

Cuando los enfoques informáticos clásicos (servidores web, socket de red, etc) resultan ser demasiado “pesados” por la cantidad de recursos necesarios para sostenerlos o resultan ser soluciones exageradas para resolver una simple comunicación de algunos Bytes, entran en juego protocolos como MQTT (Message Queue Telemetry Transport), ideado por IBM es un protocolo usado para la comunicación máquina a máquina (M2M).
Específico para Internet de las cosas, orientado a la comunicación de sensores y dispositivos con una tasa de transferencia de datos baja, necesita muy poco ancho de banda y puede ser utilizado en la mayoría de los dispositivos con escasos recursos (CPU, RAM, etc).

La arquitectura de MQTT sigue una topología de estrella, con un nodo central que hace de servidor o "broker" normalmente con una capacidad teórica de hasta 10000 clientes. El broker es el encargado de gestionar la red y de transmitir los mensajes, para mantener activo el canal, los clientes mandan periódicamente un paquete de datos y según el caso pueden esperar una confirmación del broker.
La comunicación se basa en "topics" o temas, y para que un cliente tenga acceso a la información debe estar subscrito al tema sin importar cuantos clientes estén siguiendo el tema.
Un cliente (cualquiera) puede publicar mensajes y los nodos, que deseen recibirlo deben estar subscrito a él. La comunicación puede ser de uno a uno, o de uno a muchos. Un "topic" se representa mediante una cadena y tiene una estructura jerárquica separada con '/'.

Por ejemplo, "firtec/sensor_1/temperatura" o "firtec/sensor_2/ruido". De esta forma se pueden crear jerarquías de clientes que publican y reciben datos.

Como funciona MQTT?

El funcionamiento es sencillo y sumamente ágil. El servidor o broker, recopila los datos que los publishers, los clientes o nodos que publican los tópicos. Determinados datos recopilados por el broker se enviarán a determinados nodos que previamente así se lo hayan solicitado al broker.

El principio de intercambio se parece mucho al de Twitter donde los publishers envían los mensajes a un canal llamado topic. Los suscriptores pueden leer esos mensajes. Los topics (o canales de información) pueden estar distribuidos jerárquicamente de forma que se puedan seleccionar exactamente las informaciones que se desean. Los mensajes enviados por los nodos pueden ser de todo tipo pero no pueden superar los 256 Mbit.

Por ejemplo el tópico firtec/oficina_1/temperatura comunicará la temperatura de oficina_1 si se suscribe un nodo a ese tópico el sensor de temperatura presente en la oficina_1 publicará periódicamente en ese tópico la temperatura registrada.

Si un nodo se suscribe al topic firtec/oficina_1/#, recibirá todos los datos de la oficina (por ejemplo, luminosidad, humedad, temperatura, etc). Si se suscribe al topic firtec/#, recibirá todos los datos de los sensores de firtec.


En este ejemplo se ha conectado un sensor para medir la cantidad de luz visible al ojo humano, los datos son "publicados" en la red MQTT interna de tal forma que todos los subscritos al tema (tópico) pueden acceder a los datos del sensor.
Con esta tecnología podemos publicar datos en la red con cualquier microcontrolador (PIC, Atmel, ARM, etc) solo se necesita un broker MQTT y que los dispositivos accedan a la red por ejemplo a través de un puente ESP32 y su conexión Wi-Fi.


(Ejemplo sacado del material de estudio del curso "Internet de las Cosas").