A empresa adquiriu postos de monitoramento NEKST-M, produzidos internamente pela Next Technologies. Para garantir a visualização do funcionamento das unidades de bombeamento,
alarmes de incêndio e segurança, presença de tensão nas partidas, temperatura ambiente, nível de água de emergência. O coração do NEKST-M é o ATMEGA 1280 e este facto é encorajador no que diz respeito à possibilidade de criar o seu próprio kit para necessidades específicas.
A tarefa foi criar um sistema de despacho local totalmente autônomo para necessidades específicas no menor tempo possível e com custo mínimo. A base é um microcontrolador. Desenvolvimento, fabricação, criado pela própria equipe.
O sistema deve operar sem dependência de redes celulares, servidores, Internet e sistema de licenciamento de uso de recursos de radiofrequência, não utilizar computadores na operação do sistema de monitoramento e controle ou, no máximo, utilizar periodicamente laptops, sem acesso a objetos por muito tempo (6-9 meses). A configuração da rede possui uma estrutura radial. Os dados são coletados em um ponto e depois enviados para processamento por meio de canais de comunicação regulares ou em cópia impressa.
O sistema deve fornecer:
- monitorar o funcionamento das unidades de bombeamento
- automação tecnológica
- proteção contra as consequências de condições de emergência
- sinalização de emergência
- cálculo do tempo de operação
- calculando a quantidade de eletricidade consumida
- controle de temperatura do equipamento
- segurança e alarme de incêndio
- gravação remota periódica de informações
- requisitos futuros desconhecidos
Condições de trabalho:
- área de cobertura 1 kmXNUMX.
- visibilidade direta entre objetos
- temperatura de +50 a -50 C
- umidade até 100%
- depósitos biologicamente ativos (mofo, bactérias redutoras de sulfato)
- vibração, não mais, de máquinas das classes 1-2 de acordo com GOST ISO 10816-1-97
- ambiente eletromagnético - comutação de motores elétricos com contatores KT 6053, equipamento de soft start RVS-DN, equipamento de controle SIEMENS MICROMASTER PID, radiação na faixa ISM e GSM de acordo com os requisitos para estes dispositivos, soldagem a arco manual no local
- tensão excessiva da rede, interrupções de curto prazo no fornecimento de energia, sobretensões atmosféricas, desequilíbrio de fase quando um fio de linha aérea se rompe em redes de distribuição de 6 a 10 kV.
Apesar desses requisitos rigorosos, a implementação é bastante simples ao resolver o problema passo a passo.
Levando tudo em conta, a placa “Arduino Nano 3.0” passou a ser o “cérebro” do plano. A placa robotdyn possui um controlador ATMEGA 328, o estabilizador de tensão de 3,3V necessário para
corrente 800 mA e conversor para CH340G UART-USB.
Em primeiro lugar, foram criados contadores de horas de funcionamento como os mais atualizados. Medidores industriais usados anteriormente montados em PICs com um circuito de fonte de alimentação sem transformador falharam devido a picos de tensão dentro de um ano de operação. Apenas aqueles conectados com fontes de alimentação caseiras de 5V permaneceram intactos. Para agilizar a instalação e versatilidade de conexão, um sinal sobre o estado das unidades é retirado dos terminais dos dispositivos de comutação, ou seja, registro da presença da tensão da 1ª fase com alimentação trifásica de 380V. Para coordenar com o controlador é utilizado um relé intermediário com enrolamento de 220V ou um optoacoplador composto por um LED e um fotorresistor GL5516 ou um optoacoplador PC817. Todas as opções foram testadas. O LED é alimentado por uma tensão retificada com limitação de corrente por meio de dois capacitores SVV22 projetados para uma tensão de 630V conectados em série para segurança durante testes acidentais dos circuitos com megôhmetro.
Leitura de leituras de tempo de operação usando a tela LCD ST7735S, transmissão de dados em tempo real via rádio usando o módulo E01-ML01DP05 na frequência de 2,4 MHz. Este dispositivo contém o chip nRF24L01 + e o amplificador de transmissão/recepção RFX2401C,
potência de saída de até 100 mW. Antenas helicoidais projetadas para o alcance desejado na calculadora online . A escolha do tipo de antena é determinada pela exclusão da recepção de ondas refletidas individualmente nas estruturas metálicas circundantes. As peças da antena são impressas em uma impressora 3D. O estado atual dos contadores é salvo na EEPROM do próprio controlador e restaurado em caso de queda inesperada de energia. Os intervalos de tempo para contagem são fornecidos pelo chip RTC DS3231 na forma de um módulo com bateria reserva. A fonte de alimentação usa 3 módulos, a fonte de pulso real 220/5V HLK-PM01 600mA, um conversor de 1-5V a 5V и - controlador de bateria com proteção contra curto-circuito, descarga excessiva e sobrecarga. Todos os componentes foram adquiridos no site Aliexpress.
Tábua de pão
Contador de 4 canais. Existem filtros LC nas entradas para proteção contra interferências em uma linha de comunicação de par trançado. Os dados sobre o estado dos objetos de controle são lidos constantemente uma vez por segundo e exibidos em cores no LCD. As leituras são atualizadas e registradas em memória não volátil a cada 1 segundos. 36 segundos equivalem a 36/1 de hora, este é o formato em que os dados são necessários. A cada 100 seg. são transmitidas informações sobre o número de segundos de operação de cada unidade de controle. A memória EEPROM possui um número limitado de ciclos de gravação e apagamento, segundo o fabricante, 12 vezes. A pior opção é quando pelo menos uma célula está em constante atualização. O volume do 100000º contador é de 1 bytes, este é um número de formato longo, 4 contadores, um total de 4 bytes é ocupado por um registro. O comprimento da memória do chip é de 16 bytes, após 1024 entradas de 64 contadores a gravação será reiniciada. Na biblioteca EEPROM, o método EEPROM.put não grava, se o valor da célula e a informação que está sendo escrita corresponderem, não haverá degradação das células. Como resultado, o tempo de operação garantido da memória será superior a 4 anos. O tempo de trabalho possível, mas não garantido, pode ser muito maior.
Diagrama de circuito
Programa em Arduino IDE//12 bytes (328%)
#incluir // Biblioteca gráfica principal
#include // Biblioteca específica de hardware
#incluir
#include
#incluir
#incluir
#incluir
rádio RF24(9, 10); // objeto de rádio para trabalhar com a biblioteca RF24,
// e números de pinos nRF24L01+ (CE, CSN)
#incluir
DS3231rtc(SDA,SCL);
Tempo t;
//#define TFT_CS 10
# define TFT_CS 8
#define TFT_RST -1 // você também pode conectar isso ao reset do Arduino
// nesse caso, defina este pino #define como -1!
//#define TFT_DC 9 // DC=RS=A0 - opções de designação para selecionar um comando ou registro de dados.
#define TFT_DC 3
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
// Opção 2: use qualquer pino, mas um pouco mais lento!
#define TFT_SCLK 13 // defina estes como os pinos que você quiser!
#define TFT_MOSI 11 // defina estes como os pinos que você quiser!
//Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
#incluir
deslocamento de bytes = 52;
byte pinState;
unsigned long pump[4];//array com valores de contador de 4 segundos
flutuar m = 3600.0;
endereço interno não assinado = 0;
int rc; // variável para contadores
sumprim longo sem sinal = 0;
sumsec longo sem sinal = 0;
byte eu = 0;
byte k = 34;
não assinado int z = 0;
byte b = B00000001;
contador de bytes[4]; // array para armazenar estados de objetos, 1 - desligado, 0 - ligado.
int início = 0; //
configuração nula () {
rtc.begin();
radio.begin(); // Inicia o trabalho nRF24L01+
radio.setChannel(120); // canal de dados (de 0 a 127).
radio.setDataRate(RF24_250KBPS); //taxa de transferência de dados (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS).
radio.setPALevel(RF24_PA_MAX); // potência do transmissor (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm,
//RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openWritingPipe(0xAABBCCDD11LL); //Abre um pipe com um identificador para transferência de dados
// Para definir a hora, remova o comentário das linhas necessárias
//rtc.setDOW(1); // Dia da semana
//rtc.setTime(21, 20, 0); //Hora, no formato de 24 horas.
//rtc.setDate(29, 10, 2018); // Data, 29 de outubro de 2018
tft.initR(INITR_BLACKTAB); // inicializa um chip ST7735S, aba preta
// Use este inicializador (remova o comentário) se estiver usando um TFT de 1.44"
//tft.initR(INITR_144GREENTAB); // inicializa um chip ST7735S, aba RED rcB
tft.setTextWrap(falso); //Permite que o texto saia da borda direita
tft.setRotation(2); // para PCB PRETO e VERMELHO tft.setRotation(0) ou não.
tft.fillScreen(ST7735_BLACK); // limpar tela
DDRD = DDRD | B00000000;
PORTD = PORTD | B11110000; // o aperto do software está funcionando, alto nível -
// objetos controlados “não funcionam”, “4” é escrito em todas as 1 portas seniores D, nenhuma contagem ocorre.
para (rc = 0; rc < 4; rc++)
{
tft.setCursor (3, rc * 10 + shift); // exibindo números de posição de objetos de controle
tft.print(rc+1);
}
tft.setCursor(12, 0); // gera 3 linhas de texto
tft.println("DESENVOLVEDORES E CONSTRUÇÃO"); // para elogiar a si mesmo, entes queridos
tft.setCursor(24, 10); // ou direitos autorais malignos
tft.print("DESENVOLVEDOR M.M.");
tft.setCursor(28, 20);
tft.print("BUILD-ER DD.");
//recuperação de dados////////////////////////////////////////////// ///////////
for ( z = 0; z < 1023; z += 16 ) { // Itera por todas as células da indústria
//e escreve em um array de 4 variáveis de bomba, 4 bytes para cada contador, porque
// variável longa sem sinal. Existem 4 contadores, um registro de todos os 4 ocupa 16 bytes.
EEPROM.get(z, bomba[0]); // então, sem o loop for, menos volume
EEPROM.get(z+4, bomba[1]);
EEPROM.get(z+8, bomba[2]);
EEPROM.get(z+12, bomba[3]);
// atribuindo um novo próximo valor para a soma de 4 contadores
sumprim = (bomba [0] + bomba [1] + bomba [2] + bomba [3]);
// compara o novo valor da soma de 4 contadores na variável sumprim com o valor anterior na variável
// sumsec e se a soma anterior for menor ou igual à nova soma, o novo maior ou igual é atribuído
// valor sumsec.
if (sumsec <= sumprim) {
sumsec = sumprim; //
//e o valor atual z é atribuído à variável de endereço, z é o endereço do início de um bloco de 16 bytes de 4 valores
// contadores gravados ao mesmo tempo (já que ao sondar uma porta, todos os 8 bits dela são escritos simultaneamente,
// incluindo nossos 4 bits necessários da porta D).
endereço = z;
}
}
// acessando novamente a memória eeprom no endereço do início de um bloco de 16 bytes de 4 valores de contador gravados
// último, ou seja, valores antes de desligar ou reiniciar devido ao congelamento. Gravando o mais recente
//conta valores em um array de 4 variáveis pump.
EEPROM.get(endereço, bomba[0]);
EEPROM.get(endereço + 4, bomba[1]);
EEPROM.get(endereço + 8, bomba[2]);
EEPROM.get(endereço + 12, bomba[3]);
endereço += 16; //aumentando o endereço para escrita do próximo bloco sem sobrescrever os dados do último registro
//fim da recuperação de dados //////////////////////////////////////// / //////////////////
anexarInterrupt(0, contagem, RISING); // pin D2, habilita interrupções, acontecem a cada segundo
// pulsos do RTC DS3231 da saída SQW
wdt_enable(WDTO_8S); // inicia o temporizador watchdog, reinicia o controlador em caso de congelamento, hora,
// para o qual você precisa emitir o comando de redefinição do temporizador wdt_reset( e evitar reinicializar durante a operação normal - 8 seg.
// para testes não é recomendado definir o valor para menos de 8 segundos. Neste caso o cronômetro é zerado preferencialmente
// sacudindo, e isso acontece a cada segundo.
}
loop vazio () {
// ciclo vazio, aqui haverá controle sobre o funcionamento em fase aberta do motor elétrico
}
contagem nula() {
tft.setTextColor(ST7735_WHITE); //define a cor da fonte
t = rtc.getTime(); // tempo de leitura
tft.setCursor(5, 120); //definindo a posição do cursor
tft.fillRect(5, 120, 50, 7, ST7735_BLACK); //limpando a área de saída de tempo
tft.print(rtc.getTimeStr()); // gera leituras de clock
wdt_reset(); // reseta o watchdog a cada ciclo, ou seja, segundo
for (rc = 0; rc < 4; rc ++) // início do ciclo para verificação da conformidade do estado de entrada
//porta os bits para o estado de leitura anterior dos bits da porta D
{
pinState = (PIND >> 4) & ( b << rc );
if (pumrcounter [rc] != pinState) { // e se não corresponder, então
pumrcounter[rc] = pinState; // atribuindo à variável de status do bit da porta um novo valor 1/0
}
// indicação do estado dos objetos de controle de cores
// AZUL é uma pequena falha na tela existente (ou biblioteca?), RGB e BGR estão misturados.
if (pinState == ( b << rc )) {
tft.fillRect(15, ((rc * 10 + shift)), 7, 7, ST7735_BLUE); // para contagem de baixo nível muda de VERDE para AZUL
Else {}
tft.fillRect(15, ((rc * 10 + shift)), 7, 7, ST7735_GREEN); // para contagem de baixo nível, altere AZUL para VERDE
bomba [rc] += 1; //adiciona 1 segundo ao contador de tempo de operação
}
}
k++;
se (k == 36) {
k = 0;
tft.fillRect(30, shift, 97, 40, ST7735_BLACK); //limpando a área de exibição do tempo de operação
tft.fillRect(60, 120, 73, 7, ST7735_BLACK); // e datas
tft.setCursor(60, 120); //definindo a posição do cursor
tft.print(rtc.getDateStr()); // exibe a data na tela LCD
for (rc = 0; rc < 4; rc ++) // gera horas de operação inteiras, décimos e
{
tft.setCursor ( 30, rc * 10 + shift ); // centésimos de hora com tela deslocada para baixo em 10 pixels
tft.println(bomba [rc] /m);
}
// escrevendo valores de horas de operação “brutas” (em segundos) para EEPROM /////////////////////////////
para (rc = 0; rc < 4; rc++)
{
EEPROM.put(endereço, bomba [rc]);
endereço += sizeof(float); // incrementa a variável de endereço de gravação
}
}
// envia dados pelo canal de rádio a partir de dados que indicam quantos bytes devem ser enviados.
se ((k == 6) || (k == 18) || (k == 30)) {
dados longos não assinados;
radio.write(&start, sizeof(start));
para (eu = 0; eu < 4; eu++) {
dados = bomba [i];
radio.write(&dados, sizeof(dados));
}
}
}
Algumas notas no final. A contagem ocorre em um nível lógico baixo nas entradas.
As resistências pull-up R2-R5 são de 36 kOhm para a opção com fotorresistores GL5516. No caso de um optoacoplador e relé fototransistor, ajuste para 4,7-5,1 kOhm. O bootloader Arduino Nano v3.0 foi substituído pelo Arduino Uno utilizando o programador TL866A para o correto funcionamento do temporizador watchdog. Os fusíveis são corrigidos para operar em tensões acima de 4,3 V. O circuito de reset externo R6 C3 não foi utilizado. No programa de amostra, a frequência do transmissor não corresponde à faixa não licenciada; a faixa de 2,4 MHz é limitada às frequências 2400.0-2483.5 MHz.
O alcance do transmissor E01-ML01DP05 é 2400-2525 MHz. A largura de banda de um canal é de 1 MHz, ao definir a velocidade como “RF24_2MBPS” o canal radio.setChannel(120) especificado e o próximo será ocupado, ou seja, a banda será de 2 MHz.
Fonte: habr.com