🥇Monitoramento SMS do peso de três colmeias por 30$

Não, isto não é uma proposta comercial, este é o custo dos componentes do sistema que você poderá montar após ler o artigo.

Um pouco de histórico:

Há algum tempo, decidi começar a criar abelhas, e elas realmente apareceram… para toda a temporada, mas não sobreviveram ao inverno.
E isso apesar de eu ter feito tudo certo — alimentação no outono, isolamento antes do frio.
A colmeia era clássica, de madeira, do sistema 'Dadant', com 10 quadros de madeira de 40 mm.
Mas naquele inverno, por causa das oscilações de temperatura, até apicultores experientes perderam muito mais do que o habitual.

Assim surgiu a ideia de um sistema de monitoramento do estado da colmeia.
Após a publicação de alguns artigos no Habr e conversas no fórum de apicultores, decidi começar do simples para o complexo.
O peso é o único parâmetro indiscutível, mas, como regra, os sistemas existentes monitoram apenas uma colmeia 'padrão'.
Se algo estiver errado com ela (por exemplo, a saída de um enxame, doença das abelhas), os indicadores tornam-se irrelevantes.

Portanto, foi decidido monitorar a variação de peso de três colmeias com um microcontrolador, e adicionar outras 'funcionalidades' depois.
No final, resultou em um sistema autônomo com cerca de um mês de operação com uma única carga da bateria 18650 e envio de estatísticas uma vez por dia.
Tentei simplificar a construção ao máximo, de modo que pudesse ser replicada mesmo sem esquemas, apenas com fotografias.

A lógica de funcionamento é a seguinte: ao primeiro acionamento/reset, as leituras dos sensores instalados sob as colmeias são salvas na EEPROM.
Depois, todos os dias, após o pôr do sol, o sistema 'acorda', lê as medições e envia um SMS com a variação de peso do dia e desde o momento de ativação.
Além disso, é transmitido o valor da tensão da bateria, e ao reduzir para 3.5V, um aviso é emitido sobre a necessidade de recarga, pois abaixo de 3.4V o módulo de comunicação não se ativa, e as leituras de peso já 'flutuam'.

'Você se lembra como tudo começou. Tudo foi pela primeira vez e de novo.'

Sim, esse foi exatamente o conjunto de 'hardware' inicialmente, embora apenas os sensores de tensão e fios tenham chegado à versão final, mas vamos por partes.
Na verdade, um rolo de cabos não é necessário, apenas aconteceu que custou o mesmo que 30 metros cortados.

Se você não se importa em desmontar 3 LEDs SMD e meia centena de pontos de soldagem comuns — então vamos em frente!

Então, precisaremos do seguinte conjunto de equipamentos/materiais:

Arduino Pro Mini 3V
É importante observar o chip do conversor linear — ele deve ser exatamente de 3.3V — no chip com a marcação KB 33/LB 33/DE A10 — os chineses confundiram algo, e toda a partida
de placas na loja acabou com reguladores de 5 volts e cristais de 16MHz.
USB-Ttl no chip CH340 — pode até ser de 5 volts, mas durante o carregamento do microcontrolador, o Arduino precisará ser desconectado do módulo GSM, para não queimar o último.
Placas com chip PL2303 não funcionam no Windows 10.
Módulo de comunicação GSM Goouu Tech IOT GA-6-B ou AI-THINKER A-6 Mini.
Por que parei nele? Neoway M590 — um construtor que exige danças separadas, o GSM SIM800L — não gostei do nível de lógica não padrão de 2.8V, que requer adaptação mesmo com uma Arduino de três volts.
Além disso, a solução da AiThinker tem um consumo mínimo de energia (ao enviar SMS, não vi corrente superior a 100mA).
Antena GSM GPRS 3DBI (na foto acima — placa retangular com "rabo", às 9 horas)
Pacote inicial de um operador que tenha boa cobertura na localização da sua colmeia.
Sim, o pacote precisa ser ativado previamente em um telefone comum, DESATIVAR A SOLICITAÇÃO DE PIN ao entrar, e recarregar o saldo.
Atualmente, existem muitas opções com nomes no estilo "Sensor", "IoT" — eles têm uma mensalidade um pouco menor.
fio dupont de 20 cm fêmea-fêmea — 3 peças (para conectar o Arduino ao USB-TTL)
3 unidades HX711 — ADC para balanças
6 sensores de tensão com peso até 50kg
15 metros de cabo telefônico de 4 fios — para conectar os módulos de peso ao ARDUINO.
Fotoresistor GL5528 (é importante que seja exatamente esse, com resistência de escuridão de 1MΩ e resistência luminosa de 10-20kΩ) e dois resistores comuns de 20k
Um pedaço de fita adesiva dupla face "grossa" de 18x18mm — para fixar o arduino ao módulo de comunicação.
Suporte para bateria 18650 e, de fato, a própria bateria ~2600mAh.
Um pouco de cera ou parafina (vela de mesa para aromaterapia) — para proteção contra umidade do HX711
Um pedaço de madeira 25x50x300mm para a base dos sensores de tensão.
Uma dúzia de parafusos com arruela de pressão 4,2x19 mm para fixar os sensores à base.

A bateria pode ser retirada de notebooks desmontados — é muito mais barata que nova, e sua capacidade será bem maior que a da UltraFire chinesa — eu obtive 1500 em comparação a 450 (a do fire é 6800 😉

Além disso, serão necessárias mãos firmes, um ferro de solda EPSN-25, colofônia e estanho POS-60.

Cinco anos atrás, eu usava um ferro de solda soviético com ponta de cobre (não gostei das estações de solda — experimentei, mas continuei com o esquema EPSN).
Mas, após sua quebra e várias imitações chinesas monstruosas, a última delas chamada Sparta — um objeto tão severo quanto o nome, eu parei
em um produto com termorregulador.

Então vamos lá!

Para começar, desoldamos dois LEDs do módulo GSM (o local onde estavam está cercado por um oval laranja)
Inserimos o chip SIM com os contatos voltados para a placa de circuito, o canto chanfrado na foto está indicado por uma flecha.

Depois, realizamos o mesmo procedimento com o LED na placa Arduino (oval à esquerda do chip quadrado),
Soldamos um conector com quatro contatos (1),
Pegamos dois resistores de 20k, torcemos os terminais de um lado, soldamos a torção no furo do contato A5, os terminais restantes em RAW e GND da Arduino (2),
Diminuímos os terminais do fotoresistor para 10mm e o soldamos aos terminais GND e D2 da placa (3).

Agora é hora da fita adesiva de dupla face — colamos no suporte do chip SIM do módulo de comunicação, e por cima — a Arduino — o botão vermelho(prateado) voltado para nós está acima do chip SIM.

Soldamos a alimentação: positivo do capacitor do módulo de comunicação (4) no contato RAW da Arduino.
O fato é que o próprio módulo de comunicação requer uma alimentação de 3.4-4.2V, e seu contato PWR é conectado a um conversor step-down, portanto, para operar com li-ion, a tensão deve ser fornecida contornando essa parte do circuito.

Na Arduino, por outro lado, conectamos a alimentação através de um conversor linear — com baixos consumos de corrente, a queda de tensão drop-out é de 0.1V.
Assim, ao fornecer uma tensão estabilizada aos módulos HX711, eliminamos a necessidade de ajustá-los para uma menor voltagem (e ainda evitamos o aumento de ruídos como resultado dessa operação).

Em seguida, soldamos jumpers (5) entre os contatos PWR-A1, URX-D4 e UTX-D5, o 'terra' GND-G (6), e finalmente a alimentação do suporte para baterias 18650 (7), conectamos a antena (8).
Agora pegamos um conversor USB-TTL e conectamos com fios Dupont à ARDUINO (conector 1) os contatos RXD-TXD e TXD-RXD, GND-GND:

Na foto acima — a primeira versão (de três) do sistema que foi usada para depuração.

Agora vamos nos afastar do ferro de solda por um tempo e passar para a parte do software.
Vou descrever a sequência de ações para Windows:
Primeiro, é necessário baixar e instalar/descompactar o programa Arduino IDE — a versão atual é 1.8.9, mas eu uso 1.6.4

Para simplificar, descompactamos o arquivo na pasta C:arduino-«número_da_sua_versão», onde teremos as pastas /dist, drivers, examples, hardware, java, lib, libraries, reference, tools, além do arquivo executável arduino (entre outros).

Agora precisamos de uma biblioteca para trabalhar com o ADC HX711 — o botão verde «clone or download» — download ZIP.
O conteúdo (pasta HX711-master) vai para o diretório C:arduino-«número_da_sua_versão»libraries

E claro, o driver para USB-TTL do mesmo github — do arquivo descompactado, o instalador é iniciado com o arquivo SETUP.

Ok, iniciamos e configuramos o programa C:arduino-«número_da_sua_versão»arduino

Vamos em «Ferramentas» - escolhemos a placa «Arduino Pro ou Pro Mini», processador Atmega 328 3.3V 8 MHz, porta — número diferente de COM1 (ele aparece após a instalação do driver CH340 com o adaptador USB-TTL conectado)

Ok, copiamos o seguinte sketch (programa) e colamos na janela do Arduino IDE

char phone_no[]="+123456789012"; // Your phone number that receive SMS with counry code 
#include <avr/sleep.h>  // ARDUINO sleep mode library
#include <SoftwareSerial.h> // Sofrware serial library
#include "HX711.h" // HX711 lib. https://github.com/bogde/HX711
#include <EEPROM.h> // EEPROM lib.
HX711 scale0(10, 14);
HX711 scale1(11, 14);
HX711 scale2(12, 14);
#define SENSORCNT 3
HX711 *scale[SENSORCNT];

SoftwareSerial mySerial(5, 4); // Set I/O-port TXD, RXD of GSM-shield  
byte pin2sleep=15; //  Set powerON/OFF pin

float delta00; // delta weight from start
float delta10;
float delta20;
float delta01; // delta weight from yesterday
float delta11;
float delta21;

float raw00; //raw data from sensors on first start
float raw10;
float raw20;
float raw01; //raw data from sensors on yesterday
float raw11;
float raw21;
float raw02; //actual raw data from sensors
float raw12;
float raw22;

word calibrate0=20880; //calibration factor for each sensor
word calibrate1=20880;
word calibrate2=20880;

word daynum=0; //numbers of day after start

int notsunset=0;

boolean setZero=false;

float readVcc() { // Read battery voltage function
  long result1000;
  float rvcc;  
  result1000 = analogRead(A5);
  rvcc=result1000;
  rvcc=6.6*rvcc/1023;
  return rvcc;
}

void setup() { // Setup part run once, at start

  pinMode(13, OUTPUT);  // Led pin init
  pinMode(2, INPUT_PULLUP); // Set pullup voltage
  Serial.begin(9600);
  mySerial.begin(115200); // Open Software Serial port to work with GSM-shield
  pinMode(pin2sleep, OUTPUT);// Itit ON/OFF pin for GSM
  digitalWrite(pin2sleep, LOW); // Turn ON modem
  delay(16000); // Wait for its boot 

scale[0] = &scale0; //init scale
scale[1] = &scale1;
scale[2] = &scale2;

scale0.set_scale();
scale1.set_scale();
scale2.set_scale();

delay(200);

setZero=digitalRead(2);

if (EEPROM.read(500)==EEPROM.read(501) || setZero) // first boot/reset with hiding photoresistor
//if (setZero)
{
raw00=scale0.get_units(16); //read data from scales
raw10=scale1.get_units(16);
raw20=scale2.get_units(16);
EEPROM.put(500, raw00); //write data to eeprom
EEPROM.put(504, raw10);
EEPROM.put(508, raw20);
for (int i = 0; i <= 24; i++) { //blinking LED13 on reset/first boot
    digitalWrite(13, HIGH);
    delay(500);
    digitalWrite(13, LOW);
    delay(500);
  }
}
else {
EEPROM.get(500, raw00); // read data from eeprom after battery change
EEPROM.get(504, raw10);
EEPROM.get(508, raw20);
digitalWrite(13, HIGH); // turn on LED 13 on 12sec. 
    delay(12000);
digitalWrite(13, LOW);
}

delay(200); // Test SMS at initial boot

//
  mySerial.println("AT+CMGF=1");    //  Send SMS part
  delay(2000);
  mySerial.print("AT+CMGS="");
  mySerial.print(phone_no); 
  mySerial.write(0x22);
  mySerial.write(0x0D);  // hex equivalent of Carraige return    
  mySerial.write(0x0A);  // hex equivalent of newline
  delay(2000);
  mySerial.println("INITIAL BOOT OK");
  mySerial.print("V Bat= ");
  mySerial.println(readVcc());
 if (readVcc()<3.5) {mySerial.print("!!! CHARGE BATTERY !!!");}
  delay(500);
  mySerial.println (char(26));//the ASCII code of the ctrl+z is 26
  delay(3000);

//  

raw02=raw00;
raw12=raw10;
raw22=raw20;

//scale0.power_down(); //power down all scales 
//scale1.power_down();
//scale2.power_down();

}

void loop() {

  attachInterrupt(0, NULL , RISING); // Interrupt on high lewel
  set_sleep_mode(SLEEP_MODE_PWR_DOWN); //Set ARDUINO sleep mode
  digitalWrite(pin2sleep, HIGH); // Turn OFF GSM-shield
  delay(2200);
  digitalWrite(pin2sleep, LOW); // Turn OFF GSM-shield
  delay(2200);
  digitalWrite(pin2sleep, HIGH);
  digitalWrite(13, LOW);
  scale0.power_down(); //power down all scales 
  scale1.power_down();
  scale2.power_down();
  delay(90000);
  sleep_mode(); // Go to sleep
  detachInterrupt(digitalPinToInterrupt(0)); // turn off external interrupt

  notsunset=0;
 for (int i=0; i <= 250; i++){
      if ( !digitalRead(2) ){ notsunset++; } //is a really sunset now? you shure?
      delay(360);
   }
  if ( notsunset==0 )
  { 
  digitalWrite(13, HIGH);
  digitalWrite(pin2sleep, LOW); // Turn-ON GSM-shield
  scale0.power_up(); //power up all scales 
  scale1.power_up();
  scale2.power_up();
  raw01=raw02;
  raw11=raw12;
  raw21=raw22;
  raw02=scale0.get_units(16); //read data from scales
  raw12=scale1.get_units(16);
  raw22=scale2.get_units(16);

  daynum++; 
  delta00=(raw02-raw00)/calibrate0; // calculate weight changes 
  delta01=(raw02-raw01)/calibrate0;
  delta10=(raw12-raw10)/calibrate1;
  delta11=(raw12-raw11)/calibrate1; 
  delta20=(raw22-raw20)/calibrate2;
  delta21=(raw22-raw21)/calibrate2;

  delay(16000);
  mySerial.println("AT+CMGF=1");    //  Send SMS part
  delay(2000);
  mySerial.print("AT+CMGS="");
  mySerial.print(phone_no); 
  mySerial.write(0x22);
  mySerial.write(0x0D);  // hex equivalent of Carraige return    
  mySerial.write(0x0A);  // hex equivalent of newline
  delay(2000);
  mySerial.print("Turn ");
  mySerial.println(daynum);
  mySerial.print("Hive1  ");
  mySerial.print(delta01);
  mySerial.print("   ");
  mySerial.println(delta00);
  mySerial.print("Hive2  ");
  mySerial.print(delta11);
  mySerial.print("   ");
  mySerial.println(delta10);
  mySerial.print("Hive3 ");
  mySerial.print(delta21);
  mySerial.print("   ");
  mySerial.println(delta20);

  mySerial.print("V Bat= ");
  mySerial.println(readVcc());
  if (readVcc()<3.5) {mySerial.print("!!! CHARGE BATTERY !!!");}
  delay(500);
  mySerial.println (char(26));//the ASCII code of the ctrl+z is 26
  delay(3000);

  }

}

Na primeira linha, nas aspas char phone_no[]=»+123456789012″; — em vez de 123456789012, colocamos nosso número de telefone com o código do país, onde as SMS serão recebidas.

Agora clicamos no botão verificar (acima do número um na captura de tela acima) — se embaixo (abaixo do três na tela) aparecer «Compilação concluída» — podemos gravar no microcontrolador.

Assim, o USB-TTL está conectado ao ARDUINO e ao computador, colocamos a bateria carregada no suporte (geralmente, na nova Arduino, o LED começa a piscar uma vez por segundo).

Agora a gravação — praticamos pressionar o botão vermelho (prateado) do microcontrolador — isso deve ser feito exatamente em um momento específico!!!
Conseguiu? Pressionamos o botão «Carregar» (acima do dois na captura de tela), e olhamos atentamente para a linha na parte inferior da interface (abaixo do três da tela).
Assim que a mensagem «compilação» mudar para «carregamento» — pressionamos o botão vermelho (reset) — se tudo estiver ok — os LEDs do adaptador USB-TTL piscam alegremente, e abaixo da interface aparece a mensagem «Carregado»

Agora, enquanto esperamos pela chegada da SMS de teste no telefone, vou explicar como o programa funciona:

Na foto — a segunda versão do banco de testes.

Ao ligar pela primeira vez, o sistema compara os bytes número 500 e 501 da EEPROM; se forem iguais, significa que os dados de calibração não estão gravados, e o algoritmo vai para a seção de configuração.
O mesmo ocorre se, ao ligar, o fotossensor estiver sombreado (com a tampa de uma caneta) — o modo de reset dos parâmetros é ativado.

Os sensores de tensão devem já estar instalados sob as colmeias, pois estamos apenas fixando o nível inicial zero e, em seguida, medindo a mudança de peso (neste momento, só virão zeros, pois ainda não conectamos nada).
No Arduino, o LED embutido do pino 13 começará a piscar.
Se o reset não ocorrer, o LED acende por 12 segundos.
Depois disso, uma SMS de teste é enviada com a mensagem “INITIAL BOOT OK” e a voltagem da bateria.
O módulo de comunicação é desligado, e após 3 minutos, a placa Arduino coloca as placas ADC HX711 em modo de suspensão e adormece.
Esse atraso é feito para evitar interferências do módulo GSM ativo (após desligá-lo, ele 'irradia' por um tempo).

A seguir, temos uma interrupção ativada pelo fotodetector no segundo pino (o pull-up está habilitado).
Após o acionamento, o estado do fotossensor é verificado por mais 3 minutos — para evitar acionamentos repetidos/falsos.
Curiosamente, sem qualquer configuração, o sistema é acionado 10 minutos após o pôr do sol astronômico em dias nublados e 20 minutos em dias claros.
Sim, para que o sistema não faça reset a cada ligação, pelo menos o primeiro módulo HX711 (pinos DT-D10, SCK-A0) deve estar conectado.

Em seguida, são lidas as medições dos sensores de tensão, calcula-se a mudança de peso desde a última ativação (o primeiro número na linha após Hive) e desde a primeira ligação, verifica-se a voltagem da bateria, e essa informação é enviada na forma de uma SMS:

A propósito, você recebeu a SMS? Parabéns! Estamos na metade do caminho! A bateria pode ser removida do suporte, não precisaremos mais do computador.

Por falar nisso, o centro de controle de voo ficou tão compacto que cabe em um pote de maionese, no meu caso, uma caixa semi-translúcida de 30x60x100mm (de cartões de visita) se encaixou perfeitamente.

Sim, o sistema em modo de espera consome ~2.3mA — 90% por causa do módulo de comunicação — que não se desliga completamente, mas vai para modo de espera.

Vamos começar a fabricar os sensores, primeiro vamos abordar o esquema de disposição dos sensores:

Este é o plano da colmeia — vista de cima.

Classicamente, 4 sensores são instalados nos cantos (1,2,3,4).

Nós vamos medir de forma diferente. Mais precisamente, de uma terceira maneira. Afinal, de forma diferente é como os pessoal da BroodMinder faz:

Nesta construção, os sensores estão posicionados nas posições 1 e 2, os pontos 3 e 4 apoiam-se na madeira.
Então, os sensores suportam apenas metade do peso.
Sim, esse método possui menor precisão, mas é difícil imaginar que as abelhas construam todos os quadros com "línguas" de cera ao longo de uma parede da colmeia.

Portanto, eu sugiro reunir os sensores no ponto 5 — assim, não será necessário blindar o sistema, e ao usar colmeias leves, podemos até usar apenas um sensor.

No geral, foram testados dois tipos de módulos com HX711, dois tipos de sensores e duas opções de conexão — com a ponte completa de Wheatstone (2 sensores) e com a metade, quando a segunda parte é complementada com resistores de 1k com tolerância de 0,1%.
Mas o último método é indesejável e não recomendado nem mesmo pelos fabricantes dos sensores, portanto descreverei apenas o primeiro.

Assim, para uma colmeia, teremos dois strain gauges e um módulo HX711; o esquema de fiação é o seguinte:

Do circuito integrado ADC até o Arduino, vai um cabo telefônico de 4 fios de 5 metros — lembramos como as abelhas não gostam de dispositivos GSM na colmeia..

Portanto, deixamos "caudas" de 8cm nos sensores, desnudamos o par trançado e fazemos a fiação como na foto acima.

Antes de começar a parte de marcenaria, coloque cera/parafina em um recipiente adequado para derreter em banho-maria.

Agora, pegamos nossa madeira e cortamos em três segmentos de 100mm.

Em seguida, marcamos um rasgo longitudinal de 25 mm de largura e 7-8mm de profundidade, usando uma serra e um formão para remover o excesso — isso deve resultar em um perfil em U.

A cera derreteu? — mergulhamos nossas placas ADC — isso as protegerá da umidade/neblina:

Colocamos tudo isso em uma base de madeira (deve ser tratada com um antisséptico contra apodrecimento):

E finalmente, fixamos os sensores com parafusos:

Havia também uma opção com fita adesiva azul, mas por questões de humanidade não a incluo 😉

Do lado do Arduino, fazemos o seguinte:

Desnudamos nossos cabos telefônicos, torcemos os fios coloridos entre si e tinjimos.

Depois disso, soldamos aos contatos da placa como na foto:

Pronto, agora para a verificação final, colocamos os sensores nos setores do círculo, por cima — um pedaço de compensado, zeramos o controlador (colocamos a bateria com a tampinha da caneta esferográfica sobre o fotodiodo).

O LED na Arduino deve piscar e você deve receber uma SMS de teste.

Em seguida, removemos a tampa do fotoresistor e vamos encher uma garrafa plástica de 1,5 litro com água.
Colocamos a garrafa sobre uma chapa de compensado e, se já se passaram alguns minutos desde a ativação, colocamos a tampa de volta no fotoresistor (simulando o pôr do sol).

Após três minutos, o LED na Arduino acenderá e você deve receber uma SMS com valores de peso em torno de 1 kg em todas as posições.

Parabéns! O sistema foi montado com sucesso!

Se agora for necessário fazer o sistema funcionar novamente, a primeira coluna de peso mostrará zeros.

Sim, em condições reais, é preferível posicionar o fotoresistor verticalmente para cima.

Agora apresentarei um breve manual de uso:

Instale os sensores de carga sob as paredes traseiras das colmeias (coloque um bloco ou uma tábua de cerca de 30 mm sob as frontais).
Cubra o fotoresistor e conecte a bateria — o LED deve piscar e você deve receber uma SMS com o texto "INITIAL BOOT OK".
Posicione a unidade central o mais longe possível das colmeias e de modo que os fios não atrapalhem ao trabalhar com as abelhas.
Todas as noites, após o pôr do sol, você receberá uma SMS com as alterações de peso do dia e desde o início.
Quando a tensão da bateria atingir 3,5V, a SMS terminará com "!!! CHARGE BATTERY !!!".
O tempo de operação com uma bateria de 2600mAh é de cerca de um mês.
Em caso de substituição da bateria, as alterações diárias de peso das colmeias não são registradas.