IOT123 - I2C KY019 TIJOLO: 5 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:38

Os TIJOLOS IOT123 são unidades modulares DIY que podem ser combinadas com outros TIJOLOS IOT123, para adicionar funcionalidade a um nó ou vestível. Eles são baseados em protoboards de dois lados, quadrados, de polegada quadrada com orifícios de passagem interconectados.

Espera-se que vários desses BRICKS estejam em vários nós (MCUs Master - ESP8266 ou ATTINY84) em um site. O MCU não precisa de conhecimento prévio da finalidade dos sensores ou das necessidades de software. Ele faz a varredura em busca de nós I2C e, em seguida, solicita um despejo de propriedade (dados do sensor) de cada escravo. Estes TIJOLOS fornecem 5,0V, 3,3V e outra linha AUX personalizável.

Este TIJOLO I2C KY019 é o primeiro dos ACTORS e tem uma propriedade de leitura / gravação:

Alternar (verdadeiro / falso)

Os blocos de sensores do tipo Keyes serão retirados primeiro, pois vêm com vitaminas (componentes extras necessários) incluídos e são relativamente baratos (comprei 37 por 10AUD). Outras placas / circuitos serão apresentados ao I2C BRICKS.

Os orifícios adjacentes ao ATTINY85 foram deixados sem uso, para permitir um programador de pogo pin enquanto o DIP8 é soldado ao PCB. Uma outra abstração, empacotando os BRICKS em pequenos cilindros que se conectam a um hub D1M WIFI BLOCK, bombeando os valores para um servidor MQTT, está sendo desenvolvida.

Etapa 1: Materiais e Ferramentas

Há uma lista completa de Bill of Material and Sourcing.

1. Relé KY-019 (1)
2. ATTINY85 20PU (1)
3. 1 "Protoboard dupla face (1)
4. Cabeçalho Masculino 90º (3P, 3P)
5. Fio de conexão (~ 7)
6. Solda e Ferro (1)

Etapa 2: Prepare o ATTINY85

NOTA: Se pretende ter integração com o Crouton, por favor use a biblioteca daqui, e use o exemplo instalado "attiny_ky019".

AttinyCore do gerenciador de placas é necessário. Grave bootloader "EEPROM Retained", "8mHZ Internal" (todas as configurações mostradas acima).

O repositório de código pode ser encontrado aqui.

Um ZIP da biblioteca pode ser encontrado aqui.

Instruções para "Importar uma biblioteca ZIP" aqui.

Assim que a biblioteca estiver instalada, você pode abrir o exemplo "attiny_ky019".

Para fazer o upload do firmware para o ATTINY85, você pode encontrar mais detalhes nestas instruções:

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…

Melhor testar através do breadboard antes de continuar.

Se você tiver SENSORES ASSIMILADOS, certifique-se de que o endereço do escravo seja diferente em uma combinação SENSOR / Host MCU, ou seja, todos os atores de retransmissão podem ter o mesmo endereço, desde que você tenha apenas um ator de retransmissão em um MCU / nó.

Etapa 3: montar o circuito

1. Na frente, insira os componentes ATTINY85 (1), cabeçotes macho 3P 90deg (2) (3) e solde na parte traseira.
2. Na parte traseira, trace um fio amarelo de AMARELO1 a AMARELO2 e solde.
3. Na parte traseira, trace um fio azul de AZUL1 a AZUL2 e solde.
4. Na parte traseira, trace um fio verde de VERDE1 a VERDE2 e solde.
5. Na parte traseira, trace um fio preto de BLACK1 a BLACK2 e solde.
6. Na parte traseira, trace um fio preto de BLACK3 a BLACK4 e solde.
7. Na parte traseira, trace um fio vermelho de RED1 a RED2 e solde.
8. Na parte traseira, trace um fio vermelho de RED3 a RED4 e solde.

O relé agora pode ser conectado diretamente por meio de seus pinos ao PCB ou por meio de fios, aos pontos mostrados no contrato de pino.

Etapa 4: Teste

Espera-se que vários desses BRICKS estejam em vários nós (MCUs - ESP8266 ou ATTINY84) em um ambiente. Este é um teste de unidade: envia comandos I2C do UNO para o ATTINY que abre ou fecha o relé.

Anteriormente, construímos um I2C SHIELD para Arduino.

Se você quiser fazer o breadboard em vez disso:

1. Conecte o 5.0 V no UNO a um VCC no TIJOLO.
2. Conecte o GND no UNO ao GND no BRICK.
3. Conecte o A5 em UNO a SCL em TIJOLO.
4. Conecte o A4 em UNO a SDA em TIJOLO.
5. Conecte um resistor pull-up 4K7 de SDA para VCC.
6. Conecte um resistor pull-up 4K7 de SCL para VCC.

Executando o teste

1. Conecte seu UNO ao seu Dev PC com USB.
2. Faça upload do código para o UNO.
3. Abra o console do Arduino. Escolha 9600 baud (reinicie o UNO e reabra o console se for necessário).
4. O endereço do escravo será impresso no console.
5. Quando, entre na caixa de envio 2 1 (então 12 2 1), e o relé liga.
6. Quando, entre na caixa de envio 2 0 (então 12 2 0), e o relé desliga.

Comandos adhoc I2C BRICK para escravos do mestre UNO

#incluir

const byte _num_chars = 32;

char _received_chars [_num_chars]; // um array para armazenar os dados recebidos

booleano _has_new_data = false;

voidsetup () {

Serial.begin (9600);

Serial.println ();

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

Serial.println ("garantir nova linha selecionada na janela do console");

Serial.println ();

Serial.println ("ENDEREÇO 1 CONFIRMAR RECIBO DE METADADOS N / A (PARA M2M)");

Serial.println ("COMANDO DO ATOR ENDEREÇO 2");

Serial.println ();

Serial.println ("ENDEREÇOS NO BUS:");

scan_i2c_addresses ();

Serial.println ();

Serial.println ("");

}

voidscan_i2c_addresses () {

int device_count = 0;

para (endereço de byte = 8; endereço <127; endereço ++)

{

Wire.beginTransmission (endereço);

erro de byte const = Wire.endTransmission ();

if (erro == 0)

{

Serial.println (endereço);

}

}

}

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;

}

}

outro {

_received_chars [ndx] = '\ 0'; // termina a string

ndx = 0;

_has_new_data = true;

}

}

}

voidsend_to_i2c () {

char param_buf [16];

const String received_string = String (_received_chars);

if (_has_new_data == true) {

int idx1 = string_recebida.indexOf ('');

Endereço da string = string_recebido.substring (0, idx1);

int address_int = address.toInt ();

if (address_int <8 || address_int> 127) {

Serial.println ("ENTRADA DE ENDEREÇO INVÁLIDA:");

Serial.println (endereço);

Retorna;

}

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

Código de string;

if (idx2 == -1) {

código = string_recebida.substring (idx1 + 1);

}outro{

código = string_recebida.substring (idx1 + 1, idx2 + 1);

}

int code_int = code.toInt ();

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

Serial.println ("ENTRADA DE CÓDIGO INVÁLIDA:");

Serial.println (código);

Retorna;

}

bool has_parameter = idx2> -1;

Parâmetro String;

if (has_parameter) {

parâmetro = string_recebido.substring (idx2 + 1, idx2 + 17); // 16 caracteres no máximo

if (parameter.length () <1) {

Serial.println ("PARTAMETER MIN. LENGTH 1");

_has_new_data = false;

Retorna;

}

}outro{

if (code_int> 1) {

Serial.println ("PARÂMETRO NECESSÁRIO!");

_has_new_data = false;

Retorna;

}

}

Serial.println ();

Serial.print ("input orig =");

Serial.println (cadeia_de_recebida);

Serial.print ("endereço =");

Serial.println (endereço);

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

Serial.println (código);

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

Serial.println (parâmetro);

// ENVIAR VIA I2C

Wire.beginTransmission (address_int);

Wire.write (code_int);

if (has_parameter) {

parameter.trim ();

strcpy (param_buf, parameter.c_str ());

Wire.write (param_buf);

}

Wire.endTransmission ();

Serial.println ();

Serial.println ("ENVIADO VIA I2C!");

Serial.println ();

Serial.println ("");

_has_new_data = false;

}

}

visualizar rawuno_i2c_command_input.ino hospedado com ❤ por GitHub

Etapa 5: Próximas etapas

O acompanhamento ASSIMILATE ACTOR: KY019 que usa este brick tem configuração automática para Crouton através dos metadados já instalados no ATTINY85 aqui. O pacote JSON enviado ao Crouton é enviado por meio do firmware mais recente para o ICOS10. Você pode fazer uma prova de conceito em um ESP8266 comum, se a construção for demais por enquanto.

O esboço UNO usado no teste tem uma função para salvar um novo endereço de escravo para EEPROM no ATTINY85, se você tiver um conflito em seu barramento I2C de destino.

Alguns esquemas foram adicionados, mas existem várias maneiras de conectar o circuito downstream, dependendo do que você deseja alcançar, então vou deixar isso para você:)