IOT123 - LADRILLO I2C KY019: 5 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 KY019 es el primero de los ACTORES y tiene una propiedad de lectura / escritura:

Cambiar (verdadero / falso)

Los ladrillos del sensor tipo Keyes se extraerán primero, ya que vienen con vitaminas (se necesitan componentes adicionales) incluidas y son relativamente baratos (compré 37 por 10AUD). Se introducirán otras placas / circuitos en I2C BRICKS.

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. Relé KY-019 (1)
2. ATTINY85 20PU (1)
3. Protoboard de doble cara de 1 "(1)
4. Cabezal macho 90º (3P, 3P)
5. Cable de conexión (~ 7)
6. Soldadura y Hierro (1)

Paso 2: Prepare el ATTINY85

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

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_ky019".

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

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

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

www.instructables.com/id/How-to-program-th…

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

www.instructables.com/id/Programming-an-At…

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

Si tiene SENSORES ASSIMILATE existentes, asegúrese de que la dirección esclava sea diferente en una combinación de SENSOR / MCU Host, es decir, 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: ensamble el circuito

1. En la parte delantera, inserte los componentes ATTINY85 (1), cabezales macho 3P 90deg (2) (3) y suelde en la parte trasera.
2. En la parte posterior, traza un cable amarillo de AMARILLO1 a AMARILLO2 y suelda.
3. En la parte posterior, traza un cable azul de AZUL1 a AZUL2 y suelda.
4. En la parte posterior, traza un cable verde de VERDE1 a VERDE2 y suelda.
5. En la parte posterior, traza un cable negro de NEGRO1 a NEGRO2 y suelda.
6. En la parte posterior, traza un cable negro desde NEGRO3 a NEGRO4 y suelda.
7. En la parte posterior, traza un cable rojo de RED1 a RED2 y suelda.
8. En la parte posterior, traza un cable rojo de RED3 a RED4 y suelda.

El relé ahora se puede conectar directamente a través de sus pines a la PCB o mediante cables, a los puntos que se muestran en el contrato de pines.

Paso 4: 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 el UNO al ATTINY que abre o cierra el relé.

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. Abra la consola Arduino, elija 9600 baudios (reinicie UNO y vuelva a abrir la consola si es necesario).
4. La dirección del esclavo se imprimirá en la consola.
5. Cuando, ingrese en el cuadro de envío 2 1 (entonces 12 2 1), y el relé se enciende.
6. Cuando, ingrese en la casilla de envío 2 0 (es decir, 12 2 0), y el relé se apaga.

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 5: Pasos siguientes

El siguiente ASSIMILATE ACTOR: KY019 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.

Se han agregado algunos esquemas, pero hay varias formas de cablear el circuito aguas abajo dependiendo de lo que desee lograr, así que lo dejo para usted:)