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

Nextion es probablemente una de las mejores opciones para crear proyectos con electrónica. No solamente son compatibles con Arduino, Raspberry PI, Atmel, Microchip, ARM, etc, sino que además podemos utilizarlos de forma independiente contando la propia placa con una serie de pines de uso general incluso un RTC para sistemas de adquisición de datos. Para crear una interfaz en una pantalla Nextion usaremos el editor Nextion, un software provisto por el propio fabricante que hace la tarea del diseño realmente simple.
Una vez que tenemos todo los elementos de la interfaz desplegados en la pantalla se envía la programación a la propia pantalla usando una simple conexión serial.
Este editor de Nextion es la mejor solución, en realidad casi la única para crear proyectos con estas pantallas inteligentes.
Lamentablemente solo existe en versión para Windows que se descarga a través del enlace oficial de Nextion.

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.