Local autonomous data collection system

// 12 328 bytes (38%)



#include <Adafruit_GFX.h> // Core graphics library

#include <Adafruit_ST7735.h> // Hardware-specific library

#include <SPI.h>

#include <EEPROM.h>

#include <Wire.h>

#include <nRF24L01.h>

#include <RF24.h>

RF24 radio (9, 10); // radio object for working with RF24 library,

// and pin numbers nRF24L01 + (CE, CSN)

#include <DS3231.h>

DS3231 rtc (SDA, SCL);

Time t;



// # define TFT_CS 10

#define TFT_CS 8

#define TFT_RST -1 // you can also connect this to the Arduino reset

// in which case, set this #define pin to -1!

// # define TFT_DC 9 // DC = RS = A0- variants of notation for the output of the selection of the register of commands or data.

#define TFT_DC 3



Adafruit_ST7735 tft = Adafruit_ST7735 (TFT_CS, TFT_DC, TFT_RST);



// Option 2: use any pins but a little slower!

#define TFT_SCLK 13 // set these to be whatever you like!

#define TFT_MOSI 11 // set these to be whatever you like!

// Adafruit_ST7735 tft = Adafruit_ST7735 (TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);

#include <avr / wdt.h>



byte shift = 52;

byte pinState;

unsigned long pump [4]; // array with 4 values ​​of seconds counters

float m = 3600.0;

unsigned int address = 0;

int rc; // variable for counters

unsigned long sumprim = 0;

unsigned long sumsec = 0;

byte i = 0;

byte k = 34;

unsigned int z = 0;

byte b = B00000001;

byte pumrcounter [4]; // array for storing object states, 1- off, 0- on.

int start = 0; //



void setup () {



rtc.begin ();

radio.begin (); // Initiate nRF24L01 + operation

radio.setChannel (120); // data transmission channel (from 0 to 127).

radio.setDataRate (RF24_250KBPS); // data transfer rate (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS).

radio.setPALevel (RF24_PA_MAX); // transmitter power (RF24_PA_MIN = -18dBm, RF24_PA_LOW = -12dBm,

// RF24_PA_HIGH = -6dBm, RF24_PA_MAX = 0dBm)

radio.openWritingPipe (0xAABBCCDD11LL); // Open the pipe with the identifier for data transfer



// To set the time - uncomment the necessary lines

//rtc.setDOW (1); // Day of the week

//rtc.setTime (21, 20, 0); // Time, in the format of 24 hours.

//rtc.setDate (2929, 10, 2018); // Date, October 29, 2018



tft.initR (INITR_BLACKTAB); // initialize a ST7735S chip, black tab

// Use this initializer (uncomment) if you are using a 1.44 "TFT

//tft.initR(INITR_144GREENTAB); // initialize a ST7735S chip, RED rcB tab

tft.setTextWrap (false); // Allow text to run off right edge

tft.setRotation (2); // for BLACK PCB and RED tft.setRotation (0) or not.

tft.fillScreen (ST7735_BLACK); // clear the screen



DDRD = DDRD | B00000000;

PORTD = PORTD | B11110000; // software tightening works, high level-

// monitored objects “do not work”, all 4 senior ports D are recorded as “1”, no counting is going on.



for (rc = 0; rc <4; rc ++)

{

tft.setCursor (3, rc * 10 + shift); // output position numbers of control objects

tft.print (rc + 1);

}



tft.setCursor (12, 0); // output 3 lines of text

tft.println ("DEVELOPERS & BUILD"); // to praise your loved ones

tft.setCursor (24, 10); // or evil copyright

tft.print ("DEVELOPER MM");

tft.setCursor (28, 20);

tft.print ("BUILD-ER DD");



//data recovery////////////////////////////////////////////// ///////////



for (z = 0; z <1023; z + = 16) {// Enumerates all the cells of its industry

// and writes to the array of 4 pump variables, 4 bytes each counter, since

// variable unsigned long. Counters 4, one record of all 4 takes 16 bytes.

EEPROM.get (z, pump [0]); // so, without a for loop, less volume

EEPROM.get (z + 4, pump [1]);

EEPROM.get (z + 8, pump [2]);

EEPROM.get (z + 12, pump [3]);



// assignment of the next new value of the sum of 4-x counters

sumprim = (pump [0] + pump [1] + pump [2] + pump [3]);



// compares the new value of the sum of 4 counters in the variable sumprim with the previous value in the variable

// sumsec and if the previous amount is less than or equal to the new amount, a new greater or equal is assigned

// sumsec value.



if (sumsec <= sumprim) {

sumsec = sumprim; //



// and the current value z is assigned to the variable z, z is the address of the beginning of the block of 16 bytes from 4 values

// counters recorded at the same time (since when a port is polled, all its 8 bits are recorded simultaneously,

// including our needed high 4 bits of port D).

address = z;

}

}



// once again, accessing the memory of the e-industry at the address of the beginning of the block is 16 bytes from the 4 values ​​of the counters recorded

// last, i.e. values ​​before shutting down or rebooting due to a hang. Last record

// values ​​of counters in an array of 4 pump variables.



EEPROM.get (address, pump [0]);

EEPROM.get (address + 4, pump [1]);

EEPROM.get (address + 8, pump [2]);

EEPROM.get (address + 12, pump [3]);



address + = 16; // increment the address to write the next block without erasing the last record



// end of data recovery ///////////////////////////////////////////// ///////////////////



attachInterrupt (0, count, RISING); // pin D2, resolution of work of interruption, every second come

// pulses from RTC DS3231 from SQW output



wdt_enable (WDTO_8S); // start the watchdog timer, reload the controller in case of a hang, time

// for which you need to issue a wdt_reset timer reset command (and avoid rebooting during normal operation - 8 seconds.

// for tests it is not recommended to set the value to less than 8 seconds. In this case, the timer is reset in

// digging, but it is every second.



}



void loop () {

// empty cycle, there will be control over the non-phase-phase operation of the electric motor

}



void count () {



tft.setTextColor (ST7735_WHITE); // set the font color

t = rtc.getTime (); // read time

tft.setCursor (5, 120); // set the cursor position

tft.fillRect (5, 120, 50, 7, ST7735_BLACK); // clear time display area

tft.print (rtc.getTimeStr ()); // display hours



wdt_reset (); // reset the watchdog timer every cycle, i.e. a second



for (rc = 0; rc <4; rc ++) // the beginning of the state input matching cycle

// bits of the port to the previous read state of the bits of port D

{

pinState = (PIND >> 4) & (b << rc);



if (pumrcounter [rc]! = pinState) {// and if it doesn't match, then

pumrcounter [rc] = pinState; // assignment of the state variable of the port bit to the new value 1/0

}

// indication of the state of objects of color control

// BLUE is a small glitch of the available screen (or library?), RGB and BGR are confused.

if (pinState == (b << rc)) {

tft.fillRect (15, ((rc * 10 + shift)), 7, 7, ST7735_BLUE); // for low counting, change GREEN to BLUE

} else {

tft.fillRect (15, ((rc * 10 + shift)), 7, 7, ST7735_GREEN); // for low counting, change BLUE to GREEN

pump [rc] + = 1; // add to the time counter 1 second

}

}



k ++;

if (k = 36) {

k = 0;



tft.fillRect (30, shift, 97, 40, ST7735_BLACK); // clear the running time display area

tft.fillRect (60, 120, 73, 7, ST7735_BLACK); // and dates



tft.setCursor (60, 120); // set the cursor position

tft.print (rtc.getDateStr ()); // display date on LCD screen



for (rc = 0; rc <4; rc ++) // output of the operating time readings in integers, tenths and

{

tft.setCursor (30, rc * 10 + shift); // hundredths of an hour with screen down by 10 pixels

tft.println (pump [rc] / m);

}



// write raw values ​​(in seconds) in the EEPROM //////////////////////////////



for (rc = 0; rc <4; rc ++)

{

EEPROM.put (address, pump [rc]);

address + = sizeof (float); // increment of the variable address of the entry

}

}



// send data by radio from data indicating how many bytes should be sent.

if ((k == 6) || (k == 18) || (k == 30)) {



unsigned long data;



radio.write (& start, sizeof (start));



for (i = 0; i <4; i ++) {

data = pump [i];

radio.write (& data, sizeof (data));

}

}

}