IOT123 - LADRILLO I2C HEARTBEAT: 6 Pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:43

Los LADRILLOS IOT123 son unidades modulares de bricolaje que se pueden combinar con otros LADRILLOS IOT123, para agregar funcionalidad a un nodo o dispositivo portátil. Se basan en los protoboards de dos lados de una pulgada cuadrada con orificios pasantes interconectados.

Se espera que varios de estos BRICKS estén en múltiples nodos (Master MCU - ESP8266 o ATTINY84) en un sitio. La MCU no necesita conocimientos previos sobre el propósito de los sensores o las necesidades de software. Busca nodos I2C y luego solicita un volcado de propiedad (datos del sensor) de cada esclavo. Estos LADRILLOS suministran 5.0V, 3.3V y otra línea AUX que es personalizable.

Este LADRILLO I2C HEARTBEAT indica si el esclavo ATTINY está vivo, también el tráfico I2C, y tiene una propiedad:

ESTADO ("VIVO")

PB1 (blanco) indica salud ATTINY.

PB3 (amarillo) alterna con las solicitudes I2C del maestro.

PB4 (naranja) alterna con la recepción I2C del maestro.

Los orificios pasantes adyacentes al ATTINY85 se han dejado sin usar, para habilitar un programador de pines pogo mientras el DIP8 está soldado a la PCB. Se está desarrollando una abstracción adicional, empaquetar los BRICKS en pequeños cilindros que se conectan a un concentrador D1M WIFI BLOCK, bombeando los valores a un servidor MQTT.

Paso 1: Materiales y herramientas

Hay una lista completa de lista de materiales y abastecimiento.

1. PCB de papel (7 x 7 agujeros)
2. LEDS (rojo, verde, azul)
3. Resistencias (3 de 1 K)
4. ATTINY85 20PU (1)
5. Protoboard de doble cara de 1 "(1)
6. Cabezal macho 90º (3P, 3P)
7. Encabezado macho (2P, 2P)
8. Puente de derivación (1)
9. Cable de conexión (~ 7)
10. Soldadura y Hierro (1)

Paso 2: Prepare el ATTINY85

NOTA: Si tiene la intención de tener la integración de Crouton, use la biblioteca de aquí y use el ejemplo instalado "attiny_heartbeat"

Se necesita AttinyCore de Boards Manager. Grabe el cargador de arranque "EEPROM Retained", "8mHZ Internal" (todas las configuraciones se muestran arriba).

El repositorio de código se puede encontrar aquí.

Puede encontrar un ZIP de la biblioteca aquí.

Instrucciones para "Importar una biblioteca ZIP" aquí.

Una vez instalada la biblioteca, puede abrir el ejemplo "attiny_heartbeat".

Para cargar el firmware en el ATTINY85, puede encontrar más detalles en estos instructivos:

www.instructables.com/id/Programming-the-….

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

www.instructables.com/id/How-to-Program-A…

www.instructables.com/id/Programming-the-…

Es mejor probar a través de la placa de pruebas antes de continuar.

Si tiene SENSORES ASIMILADOS existentes, asegúrese de que la dirección del esclavo sea diferente en una combinación de SENSOR / MCU Host, p. Ej. todos los actores de retransmisión pueden tener la misma dirección siempre que solo tenga un actor de retransmisión en una MCU / nodo.

Paso 3: ensamblar los indicadores

Los indicadores están pensados para ser totalmente personalizables. Son las señales de eventos del circuito principal las que se ven como Heartbeats. Para esta construcción usaremos indicadores LED; su construcción puede usar relés (sí, el VCC está roto) u otro indicador visual / basado en señal. Los valores de la resistencia dependerán de las preferencias personales de qué tan brillantes los desee.

1. En la parte superior, inserte un LED azul en RED1 (+) y BLACK1 (G), y suelde en la parte inferior.
2. En la parte inferior, doble el cable de RED1 para que toque la almohadilla de cobre en SILVER8 y recorte.
3. En la parte inferior, corte el cable de NEGRO1 arriba de la soldadura.
4. En la parte superior, inserte un LED verde en RED2 (+) y BLACK2 (G), y suelde en la parte inferior.
5. En la parte inferior, doble el cable de RED2 para que toque la almohadilla de cobre en SILVER9 y recorte.
6. En la parte inferior, corte el cable de NEGRO2 arriba de la soldadura.
7. En la parte superior, inserte un LED rojo en RED3 (+) y BLACK3 (G), y suelde en la parte inferior.
8. En la parte inferior, doble el cable de RED3 para que toque la almohadilla de cobre en SILVER10 y recorte.
9. En la parte inferior, corte el cable de NEGRO3 arriba de la soldadura.
10. En la parte superior, inserte una resistencia de 1K en los orificios pasantes SILVER1 y SILVER4.
11. En la parte inferior, trace, recorte y suelde el cable de PLATA1 a NEGRO1.
12. En la parte superior, inserte una resistencia de 1K en los orificios pasantes SILVER2 y SILVER4.
13. En la parte inferior, trace, recorte y suelde el cable de SILVER2 a BLACK2.
14. En la parte superior, inserte una resistencia de 1K en los orificios pasantes SILVER3 y SILVER4.
15. En la parte inferior, trace, recorte y suelde el cable de SILVER3 a BLACK3.
16. En la parte inferior, suelde los cables en SILVER4 y recórtelos a unos 5 mm de extensión.
17. En la parte inferior, suelde un cable negro a SILVER4.
18. En la parte inferior, suelde un cable blanco en SILVER5, asegurando la continuidad del cable desde RED1.
19. En la parte inferior, suelde un cable amarillo en SILVER6, asegurando la continuidad al cable de RED2.
20. En la parte inferior, suelde un cable naranja en SILVER7, asegurando la continuidad del cable desde RED3.

Paso 4: Montaje del circuito principal

Montaje:

1. En la parte delantera, inserte los componentes ATTINY85 (1), conectores macho 3P de 90 grados (2) (3), conectores macho 3P (4) (5) y suelde en la parte posterior.
2. En la parte posterior, traza un cable amarillo de AMARILLO1 a AMARILLO2 y suelda.
3. En la parte posterior, traza un cable naranja de NARANJA1 a NARANJA2 y suelda.
4. En la parte posterior, traza un cable azul de AZUL1 a AZUL2 y suelda.
5. En la parte posterior, traza un cable verde de VERDE1 a VERDE2 y suelda.
6. En la parte posterior, traza un cable blanco de BLANCO1 a BLANCO2 y suelda.
7. En la parte posterior, traza un cable negro de NEGRO1 a NEGRO2 y suelda.
8. En la parte posterior, traza un cable negro desde NEGRO3 a NEGRO4 y suelda.
9. En la parte posterior, traza un cable rojo de RED1 a RED2 y suelda.
10. En la parte posterior, traza un cable desnudo de RED3 a RED4 y suelda.
11. En la parte posterior, traza un cable desnudo de SILVER1 a SILVER2 y suelda.
12. Agregue un puente en la línea 5V o 3V3.

Si usa los indicadores anteriores (consulte el diagrama de distribución de pines):

1. En la parte posterior, suelde el cable blanco en PB1.
2. En la parte posterior, suelde el cable amarillo en PB3.
3. En la parte posterior, suelde el cable naranja en PB4.
4. En la parte posterior, suelde el cable negro a GND.

Paso 5: prueba

Se espera que varios de estos BRICKS estén en varios nodos (MCU: ESP8266 o ATTINY84) en un entorno. Esta es una prueba unitaria: envía comandos I2C desde UNO al ATTINY que alterna el LED de recepción. El LED ATTINY ALIVE permanece encendido.

Anteriormente hemos construido un I2C SHIELD para Arduino.

Si en su lugar, desea hacer una placa de prueba:

1. Conecte el 5.0V en UNO a un VCC en BRICK.
2. Conecte GND en UNO a GND en BRICK.
3. Conecte el A5 en UNO a SCL en BRICK.
4. Conecte el A4 en UNO a SDA en BRICK.
5. Conecte una resistencia pull-up 4K7 de SDA a VCC.
6. Conecte una resistencia pull-up 4K7 de SCL a VCC.

Ejecutando la prueba

1. Conecte su UNO a su Dev PC con USB.
2. Sube el código a la UNO.
3. Abre la consola Arduino.
4. Elija 9600 baudios (reinicie UNO y vuelva a abrir la consola si es necesario).
5. La dirección del esclavo se imprimirá en la consola.
6. Cuando, ingrese en el cuadro de envío 2 1 (es decir, 16 2 1), y el LED de recepción se enciende.
7. Cuando, ingrese en el cuadro de envío 2 0 (es decir, 16 2 0), y el LED de recepción se apagará.

Comandos adhoc I2C BRICK para esclavos del maestro UNO

#incluir

const byte _num_chars = 32;

char _received_chars [_num_chars]; // una matriz para almacenar los datos recibidos

boolean _has_new_data = false;

voidsetup () {

Serial.begin (9600);

Serial.println ();

Serial.println ("ASIMILAR IOT ACTOR / SENSOR EEPROM EDITOR");

Serial.println ("asegúrese de seleccionar una nueva línea en la ventana de la consola");

Serial.println ();

Serial.println ("DIRECCIÓN 1 CONFIRMAR RECIBO DE METADATOS N / A (PARA M2M)");

Serial.println ("COMANDO ACTOR DIRECCIÓN 2");

Serial.println ();

Serial.println ("DIRECCIONES EN BUS:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

para (dirección de byte = 8; dirección <127; dirección ++)

{

Wire.beginTransmission (dirección);

error de byte constante = Wire.endTransmission ();

si (error == 0)

{

Serial.println (dirección);

}

}

}

voidloop () {

recv_with_end_marker ();

send_to_i2c ();

}

voidrecv_with_end_marker () {

byte estático ndx = 0;

char end_marker = '\ n';

char rc;

while (Serial.available ()> 0 && _has_new_data == false) {

rc = Serial.read ();

if (rc! = end_marker) {

_received_chars [ndx] = rc;

ndx ++;

if (ndx> = _num_chars) {

ndx = _num_chars - 1;

}

}

demás {

_received_chars [ndx] = '\ 0'; // termina la cadena

ndx = 0;

_has_new_data = true;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String cadena_recibida = Cadena (_caracteres_recibidos);

if (_has_new_data == true) {

int idx1 = cadena_recibida.indexOf ('');

Dirección de cadena = cadena_recibida.subcadena (0, idx1);

int address_int = address.toInt ();

if (dirección_int <8 || dirección_int> 127) {

Serial.println ("ENTRADA DE DIRECCIÓN NO VÁLIDA:");

Serial.println (dirección);

regreso;

}

int idx2 = cadena_recibida.indexOf ('', idx1 + 1);

Código de cadena;

si (idx2 == -1) {

código = cadena_recibida.subcadena (idx1 + 1);

}demás{

código = cadena_recibida.subcadena (idx1 + 1, idx2 + 1);

}

int code_int = code.toInt ();

if (code_int <0 || code_int> 5) {

Serial.println ("ENTRADA DE CÓDIGO NO VÁLIDO:");

Serial.println (código);

regreso;

}

bool has_parameter = idx2> -1;

Parámetro de cadena;

if (has_parameter) {

parámetro = cadena_recibida.subcadena (idx2 + 1, idx2 + 17); // 16 caracteres como máximo

if (parameter.length () <1) {

Serial.println ("PARÁMETRO LONGITUD MÍNIMA 1");

_has_new_data = falso;

regreso;

}

}demás{

if (code_int> 1) {

Serial.println ("¡PARÁMETRO REQUERIDO!");

_has_new_data = falso;

regreso;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (cadena_recibida);

Serial.print ("dirección =");

Serial.println (dirección);

Serial.print ("código =");

Serial.println (código);

Serial.print ("parámetro =");

Serial.println (parámetro);

// ENVIAR A TRAVÉS DE I2C

Wire.beginTransmission (dirección_int);

Wire.write (code_int);

if (has_parameter) {

parámetro.trim ();

strcpy (param_buf, parámetro.c_str ());

Wire.write (param_buf);

}

Wire.endTransmission ();

Serial.println ();

Serial.println ("¡ENVIADO A TRAVÉS DE I2C!");

Serial.println ();

Serial.println ("");

_has_new_data = falso;

}

}

ver rawuno_i2c_command_input.ino alojado con ❤ por GitHub

Paso 6: Pasos siguientes

El siguiente ASSIMILATE ACTOR: HEARTBEAT que usa este ladrillo tiene una configuración automática para Crouton a través de los metadatos ya instalados en el ATTINY85 aquí. El paquete JSON enviado a Crouton se envía a través del último firmware para ICOS10. Puede hacer una prueba de concepto en un ESP8266 ordinario, si la construcción es demasiado por ahora.

El boceto UNO usado en Pruebas tiene una función para guardar una nueva dirección esclava en EEPROM en el ATTINY85, si tiene un conflicto en su bus I2C de destino.