// 12 328 bytes (38%)
#include <Adafruit_GFX.h> // Biblioteca de gráficos principais
#include <Adafruit_ST7735.h> // Biblioteca específica de hardware
#include <SPI.h>
#include <EEPROM.h>
#include <Wire.h>
#include <nRF24L01.h>
#include <RF24.h>
Rádio RF24 (9, 10); // objeto de rádio para trabalhar com a biblioteca RF24,
// e números de pinos nRF24L01 + (CE, CSN)
#include <DS3231.h>
DS3231 rtc (SDA, SCL);
Tempo t;
// # define TFT_CS 10
#define TFT_CS 8
#define TFT_RST -1 // você também pode conectar isso à redefinição do Arduino
// nesse caso, defina esse #define pin como -1!
// # define TFT_DC 9 // DC = RS = A0- opções para designar a saída da escolha do registro de comandos ou dados.
#define TFT_DC 3
Adafruit_ST7735 tft = Adafruit_ST7735 (TFT_CS, TFT_DC, TFT_RST);
// Opção 2: use quaisquer pinos, mas um pouco mais devagar!
#define TFT_SCLK 13 // defina-os como os pinos que você quiser!
#define TFT_MOSI 11 // defina-os como os pinos que você quiser!
// Adafruit_ST7735 tft = Adafruit_ST7735 (TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
#include <avr / wdt.h>
desvio de bytes = 52;
byte pinState;
bomba longa não assinada [4]; // matriz com contagem de 4 segundos
flutuador m = 3600,0;
endereço int não assinado = 0;
int rc; // variável para contadores
sumprim longo não assinado = 0;
sumsec longo não assinado = 0;
byte i = 0;
byte k = 34;
int sem sinal z = 0;
byte b = B00000001;
byte pumrcounter [4]; // array para armazenar os estados dos objetos, 1- off, 0- on
int start = 0; //
configuração nula () {
rtc.begin ();
radio.begin (); // Iniciar a operação nRF24L01 +
radio.setChannel (120); // canal de transmissão 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); // Abra o pipe com o 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); // inicialize um chip ST7735S, aba preta
// Use este inicializador (descomente) se você estiver usando um TFT de 1,44 "
//tft.initR(INITR_144GREENTAB); // inicializa um chip ST7735S, guia RED rcB
tft.setTextWrap (false); // Permite que o texto saia da borda direita
tft.setRotation (2); // para BLACK PCB e RED tft.setRotation (0) ou não.
tft.fillScreen (ST7735_BLACK); // limpa a tela
DDRD = DDRD | B00000000;
PORTD = PORTD | B11110000; // trabalhos de aperto de software, alto
// objetos monitorados “não funcionam”, “1” é gravado nas 4 portas seniores de D, a conta não vai.
para (rc = 0; rc <4; rc ++)
{
tft.setCursor (3, rc * 10 + shift); // exibe o número de posições dos objetos de controle
tft.print (rc + 1);
}
tft.setCursor (12, 0); // gera 3 linhas de texto
tft.println ("DESENVOLVEDORES E CONSTRUTORES"); // para elogiar seus entes queridos
tft.setCursor (24, 10); // ou direitos autorais mal
tft.print ("DEVELOPER MM");
tft.setCursor (28, 20);
tft.print ("BUILD-ER DD");
// recuperação de dados //////////////////////////////////////////////// ///////////
for (z = 0; z <1023; z + = 16) {// Repete todas as células de sua indústria
// e grava na matriz de 4 variáveis pump, 4 bytes cada contador, porque
// variável sem assinatura por muito tempo. Contadores 4, um registro de todos os 4 leva 16 bytes.
EEPROM.get (z, bomba [0]); // então, sem um loop for, menos volume
EEPROM.get (z + 4, bomba [1]);
EEPROM.get (z + 8, bomba [2]);
EEPROM.get (z + 12, bomba [3]);
// atribuição de um novo próximo valor da soma dos contadores 4-x
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 o valor anterior for menor ou igual à nova soma, um novo maior ou igual será 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 do bloco de 16 bytes de 4 valores
// contadores gravados ao mesmo tempo (porque ao pesquisar uma porta, todos os seus 8 bits são gravados simultaneamente
// incluindo nossos 4 bits altos desejados da porta D).
endereço = z;
}
}
// Mais uma vez, o acesso à memória epromprom no endereço inicial do bloco é de 16 bytes a partir de 4 valores dos contadores registrados
// last, i.e. valores antes de desligar ou reiniciar devido a um travamento. Gravar por último
// valores dos contadores para uma matriz 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; // aumenta o endereço para escrever o próximo bloco sem substituir os dados do último registro
// fim da recuperação de dados /////////////////////////////////////////////// /////////////////////
attachInterrupt (0, count, RISING); // pino D2, ativa a operação de interrupção, a cada segundo que eles chegam
// pulsos do RTC DS3231 da saída SQW
wdt_enable (WDTO_8S); // inicia o timer do watchdog, reinicia o controlador em caso de paralisação, hora,
// para o qual você precisa enviar o comando wdt_reset timer reset (e evite reiniciar durante a operação normal - 8 segundos).
// para testes, não é recomendável definir o valor para menos de 8 segundos.Neste caso, o timer é redefinido antes
// cavando, e a cada segundo.
}
loop vazio () {
// ciclo vazio, aqui haverá controle sobre o modo de operação fora de fase do motor elétrico
}
contagem de nulos () {
tft.setTextColor (ST7735_WHITE); // define a cor da fonte
t = rtc.getTime (); // tempo de leitura
tft.setCursor (5, 120); // define a posição do cursor
tft.fillRect (5, 120, 50, 7, ST7735_BLACK); // limpar a área de saída de tempo
tft.print (rtc.getTimeStr ()); // horas de exibição
wdt_reset (); // redefine o timer do watchdog a cada ciclo, ou seja, um segundo
for (rc = 0; rc <4; rc ++) // início do loop para verificar o estado da entrada
// bits da porta para o status 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; // atribui a variável de estado do bit da porta ao novo valor 1/0
}
// indicação do status dos objetos de controle de cores
// AZUL é uma pequena falha na tela existente (ou biblioteca?), RGB e BGR são misturados.
if (pinState == (b << rc)) {
tft.fillRect (15, ((rc * 10 + shift)), 7, 7, ST7735_BLUE); // para contas de baixo nível, altere VERDE para AZUL
} mais {
tft.fillRect (15, ((rc * 10 + shift)), 7, 7, ST7735_GREEN); // para uma conta de nível baixo, altere AZUL para VERDE
bomba [rc] + = 1; // adiciona 1 segundo ao contador de tempo de execução
}
}
k ++;
se (k == 36) {
k é 0;
tft.fillRect (30, shift, 97, 40, ST7735_BLACK); // limpe a área de saída do tempo de execução
tft.fillRect (60, 120, 73, 7, ST7735_BLACK); // e datas
tft.setCursor (60, 120); // define a posição do cursor
tft.print (rtc.getDateStr ()); // exibe a data na tela LCD
for (rc = 0; rc <4; rc ++) // gera leituras de tempo de operação em números inteiros, décimos e
{
tft.setCursor (30, rc * 10 + shift); // centésimos de hora com um deslocamento de 10 pixels na tela
tft.println (bomba [rc] / m);
}
// grava valores de tempo de operação "brutos" (em segundos) na 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 registro
}
}
// envia dados através do ar a partir de dados indicando quantos bytes enviar.
if ((k == 6) || (k == 18) || (k == 30)) {
dados longos não assinados;
radio.write (& start, sizeof (start));
para (i = 0; i <4; i ++) {
dados = bomba [i];
radio.write (& data, sizeof (data));
}
}
}