แแแแแแแแแ แจแแแซแแแ NEKST-M แแแแแขแแ แแแแแก แแแกแขแแแ, แ แแแแแแแช แฌแแ แแแแแฃแแแ แฅแแแงแแแแจแ Next Technologies-แแก แแแแ . แกแแขแฃแแแ แแแแแแแแ แแแแก แแฃแจแแแแแก แแแแฃแแแแแแชแแแก แฃแแ แฃแแแแแกแแงแแคแแ,
แฎแแแซแแ แกแแฌแแแแแฆแแแแแ แแ แฃแกแแคแ แแฎแแแแแก แกแแแแแแแแแชแแ, แซแแแแแก แแ แกแแแแแ แแแแฌแงแแแแแแ, แแแแฎแแก แขแแแแแ แแขแฃแ แ, แแแแแฃแแแแแแ แฌแงแแแก แแแแ. NEKST-M-แแก แแฃแแ แแ แแก ATMEGA 1280 แแ แแก แคแแฅแขแ แแแแแแฎแแแแแแแแแ แแแแแ แแขแฃแแ แกแแญแแ แแแแแกแแแแก แกแแแฃแแแ แ แแแแ แแแแก แจแแฅแแแแก แจแแกแแซแแแแแแแแก แแแแแกแแแ แแกแแ.
แแแกแแฎแฃแแ แแงแ แแแแชแแแ, แ แแ แฃแแแแแแก แแ แแจแ แแ แแแแแแแแฃแ แคแแกแแ แจแแแฅแแแแ แกแ แฃแแแแ แแแขแแแแแแฃแ แ แแแแแแแแ แแแ แแแกแแแขแฉแแ แแแแชแแแก แกแแกแขแแแ แแแแแ แแขแฃแแ แกแแญแแ แแแแแกแแแแก. แกแแคแฃแซแแแแ แแ แแก แแแแ แแแแแขแ แแแแ แ. แแแแแแแแ แแแ, แฌแแ แแแแแ, แจแแฅแแแแแ แแแแแ แแแ แกแแแแแแก แแแแ .
แกแแกแขแแแ แฃแแแ แแฃแจแแแแแแก แคแแญแฃแ แฅแกแแแแแแ, แกแแ แแแ แแแแ, แแแขแแ แแแขแแ แแ แ แแแแแกแแฎแจแแ แฃแแ แ แแกแฃแ แกแแแแก แแแแแงแแแแแแก แแแชแแแแแ แแแแก แกแแกแขแแแแแ แแแแแแแแแแฃแแแแแก แแแ แแจแ, แแ แแแแแแงแแแแก แแแแแแฃแขแแ แแแ แแแแแขแแ แแแแแกแ แแ แแแแขแ แแแแก แกแแกแขแแแแก แแฃแจแแแแแจแ แแ, แแแฅแกแแแฃแ, แแแ แแแแฃแแแ แแแแแแงแแแแก แแแแขแแแแแ, แฌแแแแแแก แแแ แแจแ. แแแแแฅแขแแแ แแแแ แฎแแแก แแแแแแแแแแแจแ (6-9 แแแ). แฅแกแแแแก แแแแคแแแฃแ แแชแแแก แแฅแแก แ แแแแแแฃแ แ แกแขแ แฃแฅแขแฃแ แ. แแแแแชแแแแแ แแ แแแแแแ แแ แ แแแแแแขแจแ แแ แจแแแแแ แแแแแแแแแ แแแกแแแฃแจแแแแแแแ แฉแแแฃแแแแ แแแ แกแแแแแฃแแแแแชแแ แแ แฎแแแแ แแ แแแญแแฃแ แ แแกแแแก แกแแฎแแ.
แกแแกแขแแแแ แฃแแแ แฃแแ แฃแแแแแงแแก:
- แกแแขแฃแแแ แแแแแแแแ แแแแก แแฃแจแแแแแก แแแแแขแแ แแแแ
- แขแแฅแแแแแแแฃแ แ แแแขแแแแขแแแแชแแ
- แแแชแแ แกแแแแแแแแ แแแ แแแแแแก แจแแแแแแแแกแแแ
- แกแแแแแแแแ แกแแแแแแแแแชแแ
- แแแแ แแชแแฃแแ แแ แแแก แแแแแแแ แแจแแแ
- แแแฎแแแ แแแฃแแ แแแแฅแขแ แแแแแ แแแแก แ แแแแแแแแแก แแแแแแแ แแจแแแ
- แแฆแญแฃแ แแแแแแแก แขแแแแแ แแขแฃแ แแก แแแแขแ แแแ
- แฃแกแแคแ แแฎแแแแ แแ แฎแแแซแแ แกแแฌแแแแแฆแแแแแ แกแแแแแแแแแชแแ
- แแแคแแ แแแชแแแก แแแ แแแแฃแแ แแแกแขแแแชแแฃแ แ แฉแแฌแแ แ
- แฃแชแแแแ แแแแแแแแ แแแแฎแแแแแแ
แฒกแแแฃแจแแ แแแ แแแแแ:
- แแแคแแ แแแก แคแแ แแ 1 แแ.แแ.
- แแแ แแแแแ แ แฎแแแแแแแแ แแแแแฅแขแแแก แจแแ แแก
- แขแแแแแ แแขแฃแ แ +50-แแแ -50C-แแแ
- แขแแแแแแแแ 100% -แแแ
- แแแแแแแแฃแ แแ แแฅแขแแฃแ แ แแแแแแแขแแแ (แแแงแ แ, แกแฃแแคแแขแแก แจแแแแแชแแ แแแแแ แแแฅแขแแ แแแแ)
- 1-2 แแแแกแแแแก แแแแฅแแแแแแก แแแแ แแชแแ, แแ แ แฃแแแขแแก, GOST ISO 10816-1-97 แแแฎแแแแแ
- แแแแฅแขแ แแแแแแแขแฃแ แ แแแ แแแ - แแแแฅแขแ แแซแ แแแแแแก แแแแแ แแแ KT 6053 แแแแขแแฅแขแแ แแแแ, RVS-DN แ แแแแ แแแแฌแงแแ แแแฌแงแแแแแแแแ, SIEMENS MICROMASTER PID แกแแแแแขแ แแแ แแแฌแงแแแแแแแ, แแแแแกแฎแแแแแ ISM แแ GSM แแแแแแแแแจแ แแ แแแฌแงแแแแแแแแแแก แแแแฎแแแแแแแก แจแแกแแแแแแกแแ, แฎแแแแ แ แแแแแก แจแแแฃแฆแแแ แแแแแแแ.
- แฅแกแแแแก แแแแแญแแ แแแแฃแแ แซแแแแ, แแแแฅแขแ แแแแแแ แแแแแแก แแแแแแแแแแแแ แจแแคแแ แฎแแแแแ, แแแแแกแแแฃแ แ แแแแแซแแแแ, แคแแแฃแ แ แแแกแแแแแแกแ, แ แแแแกแแช แกแแฐแแแ แ แฎแแแแก แแแแแฃแแ แแจแแแแ 6-10 แแ แแแแแแแฌแแแแแแ แฅแกแแแแแจแ.
แแแฃแฎแแแแแแ แแกแแแ แแแแชแ แ แแแแฎแแแแแแแกแ, แแแแแ แแแ แกแแแแแแ แแแ แขแแแแ แแ แแแแแแแก แแขแแแแแ แแแแ แแแแแญแ แแกแแก.
แงแแแแแคแ แแก แแแแแแแแกแฌแแแแแแ, "Arduino Nano 3.0" แแแคแ แแแฎแแ แแแแแแก "แขแแแแ". robotdyn แแแคแแก แแฅแแก ATMEGA 328 แแแแขแ แแแแ แ, แกแแญแแ แ 3,3V แซแแแแแก แกแขแแแแแแแแขแแ แ.
แแแแแแแแ แ 800 mA แแ แแแแแแงแแแแ CH340G UART-USB.
แฃแแแ แแแแแก แงแแแแแกแ, แจแแแฅแแแ แกแแแฃแจแแ แกแแแแแแแก แแ แแชแฎแแแแแแ, แ แแแแ แช แงแแแแแแ แแแแแฎแแแแฃแแ. แแแ แ แแแแแงแแแแแฃแแ แกแแแ แแฌแแแแ แแ แแชแฎแแแแแแ, แ แแแแแแแช แแฌแงแแแแแ แแงแ PIC-แแแแ แขแ แแแกแคแแ แแแขแแ แแก แแแแฅแขแ แแแแแแ แแแแแแก แกแฅแแแแ, แแแ แแแฎแแ แฎแแ แซแแแแแก แแแขแแแแก แแแแ แแฅแกแแแฃแแขแแชแแแแแ แแ แแ แฌแแแก แแแแแแแแแแแจแ. แฎแแแฃแฎแแแแแแ แแแ แฉแ แแฎแแแแ แแกแแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แฎแแแแแแแแ 5V แแแแแก แฌแงแแ แแแแแ. แแแกแขแแแแชแแแกแ แแ แแแแจแแ แแก แแ แแแแแคแแ แแแแแแแก แแแกแแฉแฅแแ แแแแแ, แกแแแแแแ แแ แแแฃแแแแแก แแแแแแแ แแแแแก แจแแกแแฎแแ แแฆแแแฃแแแ แแแแแ แแแแก แแแฌแงแแแแแแแแแแก แขแแ แแแแแแแแแแแ, แ.แ. 1-แแ แคแแแแก แซแแแแแก แแ แกแแแแแแก แ แแแแกแขแ แแชแแ 380 แ แกแแแคแแแแแแ แแแแฅแขแ แแแแแแ แแแแแแ. แแแแขแ แแแแ แแแ แแแแ แแแแแชแแแกแแแแก แแแแแแงแแแแแ แจแฃแแแแแฃแ แ แ แแแ 220 แ แแ แแแแแแแ แแ แแแขแแแฃแแแแ แ, แ แแแแแแช แจแแแแแแ LED-แแกแแแ แแ GL5516 แคแแขแแ แแแแกแขแแ แแกแแแ แแ PC817 แแแขแแแฃแแแแ แแกแแแ. แงแแแแ แแแ แแแแขแ แแแแแชแแแแ แแงแ. LED แแแแแแแแ แแแแแกแฌแแ แแแฃแแ แซแแแแแ แแแแแก แจแแแฆแฃแแแแ, แแ แ SVV22 แแแแแแแกแแขแแ แแก แแแแแงแแแแแแ, แ แแแแแแแช แจแแฅแแแแแแ 630 แ แซแแแแแกแแแแก, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แกแแ แแแแจแ แฃแกแแคแ แแฎแแแแแกแแแแก แแแแแฐแแแขแ แแ แกแฅแแแแแแก แจแแแแฎแแแแแแ แขแแกแขแแ แแแแก แแ แแก.
แกแแแฃแจแแ แแ แแแก แฌแแแแแฎแแ ST7735S LCD แแแ แแแแก แแแแแงแแแแแแ, แ แแแแฃแ แแ แแจแ แแแแแชแแแแ แแแแแชแแแ แ แแแแแก แกแแจแฃแแแแแแ E01-ML01DP05 แแแแฃแแแก แแแแแงแแแแแแ 2,4 MHz แกแแฎแจแแ แแแ. แแก แแแฌแงแแแแแแแ แจแแแชแแแก nRF24L01+ แฉแแแก แแ RFX2401C แแแแแแชแแ/แแแแฆแแ แแแแแซแแแแ แแแแแก,
แแแแแแแแแแ แกแแแซแแแแ แ 100 แแแข-แแแ. แแแแแแ แแแแแฃแแแขแแ แจแ แกแแกแฃแ แแแแ แแแแแแแแแแกแแแแก แแแแแฃแแแแแแ แฎแแแฃแแ แแแขแแแแแ
แแฃแ แแก แแแคแ
4-แแ แฎแแแแ แแ แแชแฎแแแแ. แจแแงแแแแแแแ แแ แแก LC แคแแแขแ แแแ, แ แแแ แแแแชแแแ แฉแแ แแแแแ แแ แแฎแแแ แฌแงแแแแแก แกแแแแแฃแแแแแชแแ แฎแแแแ. แกแแแแแขแ แแแ แแแแแฅแขแแแแก แแแแแแแ แแแแแก แจแแกแแฎแแ แแแแแชแแแแแ แแฃแแแแแแ แแแแแฎแแแ แฌแแแจแ แแ แแฎแแ แแ แแแฉแแแแแแแ แคแแ แแแ LCD แแแ แแแแ. แฌแแแแแฎแแแแ แแฎแแแแแ แแ แฉแแแฌแแ แแแ แแ แแกแขแแแแแฃแ แแแฎแกแแแ แแแแจแ แงแแแแ 1 แฌแแแจแ. 36 แฌแแแ แแ แแก แกแแแแแก 36/1, แแก แแก แคแแ แแแขแแ, แ แแแแแจแแช แแแแแชแแแแแแ แกแแญแแ แ. แงแแแแ 100 แฌแแแจแ. แแแคแแ แแแชแแ แแแแแแชแแแ แแแแแแฃแแ แกแแแแแขแ แแแ แแ แแแฃแแแก แแฃแจแแแแแก แฌแแแแแแก แ แแแแแแแแแก แจแแกแแฎแแ. EEPROM แแแฎแกแแแ แแแแก แแฅแแก แฉแแฌแแ แแก แฌแแจแแแก แชแแแแแแแก แจแแแฆแฃแแฃแแ แ แแแแแแแแ, แแฌแแ แแแแแแแก แแฅแแแ, 12-แฏแแ . แงแแแแแแ แชแฃแแ แแแ แแแแขแแ, แ แแแแกแแช แกแฃแ แแชแแ แ แแ แแ แฃแฏแ แแแ แแฃแแแแแแ แแแแแฎแแแแแ. แแแ แแแแ แแ แแชแฎแแแแแก แแแชแฃแแแแ แแ แแก 100000 แแแแขแ, แแก แแ แแก แแ แซแแแ แคแแ แแแขแแก แแแแแ แ, 1 แแ แแชแฎแแแแ, แกแฃแ 4 แแแแขแ แแแแแแแก แแ แ แฉแแแแฌแแ แก. แแแแ แแกแฅแแแแก แแแฎแกแแแ แแแแก แกแแแ แซแแ 4 แแแแขแ, 16 แแ แแชแฎแแแแแก 1024 แฉแแแแฌแแ แแก แจแแแแแ แฉแแฌแแ แ แแแแแแแ แแแแฌแงแแแ. EEPROM แแแแแแแแแแแจแ EEPROM.put แแแแแแ แแ แแฌแแ แแแ; แแฃ แฃแฏแ แแแแก แแแแจแแแแแแแ แแ แฉแแฌแแ แแแ แแแคแแ แแแชแแ แแแแฎแแแแ, แฃแฏแ แแแแแแก แแแแ แแแแชแแ แแ แแฅแแแแ. แจแแแแแแ, แแแฎแกแแแ แแแแก แแฃแจแแแแแก แแแ แแแขแแ แแแฃแแ แแ แ 64 แฌแแแแ แแแขแ แแฅแแแแ. แจแแกแแซแแ, แแแแ แแ แแ แ แแแ แแแขแแ แแแฃแแ แกแแแฃแจแแแก แแ แ แจแแแซแแแแ แแแชแแแแแแ แแ แซแแแ แแงแแก.
แฒฌแ แแฃแแ แแแแแ แแแ
แแ แแแ แแแ Arduino IDE-แจแ//12 แแแแขแ (328%)
#แจแแแชแแแก // แซแแ แแแแแ แแ แแคแแแฃแแ แแแแแแแแแแ
#แจแแแชแแแก // แแแแ แแขแฃแ แแก แกแแแชแแคแแแฃแ แ แแแแแแแแแแ
#แฉแแ แแแ
#แจแแแชแแแก
# แฉแแ แแแ
#แจแแแชแแแก
#แจแแแชแแแก
RF24 แ แแแแ(9, 10); // แ แแแแ แแแแแฅแขแ RF24 แแแแแแแแแแแกแแแ แแฃแจแแแแแกแแแแก,
// แแ แแแแแก แแแแ แแแ nRF24L01+ (CE, CSN)
#แจแแแชแแแก
DS3231 rtc(SDA, SCL);
แแ แ t;
//#define TFT_CS 10
#define TFT_CS 8
#define TFT_RST -1 // แแกแแแ แจแแแแซแแแแ แแแแแแแจแแ แแ แแก Arduino-แก แแแแแขแแแ แแแแกแแแ
// แแ แจแแแแฎแแแแแจแ แแแแงแแแแ แแก #define แแแแ -1-แแ!
//#define TFT_DC 9 // DC=RS=A0 - แแฆแแแจแแแแก แแแ แแแแขแแแ แแ แซแแแแแแก แแ แแแแแชแแแแ แ แแแแกแขแ แแก แแกแแ แฉแแแแ.
#define TFT_DC 3
Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);
// แแแ แแแแขแ 2: แแแแแแงแแแแ แแแแแกแแแแ แ แฅแแแซแแกแแแแแแ, แแแแ แแ แแแแแ แแแแ!
#define TFT_SCLK 13 // แแแแงแแแแ แแกแแแ, แ แแแแ แช แแก, แ แแช แแแแฌแแแ!
#define TFT_MOSI 11 // แแแแงแแแแ แแกแแแ, แ แแแแ แช แแก, แ แแช แแแแฌแแแ!
//Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_MOSI, TFT_SCLK, TFT_RST);
#แจแแแชแแแก
แแแแขแแก แชแแแ = 52;
แแแแขแ pinState;
แฎแแแแแฃแฌแแ แแแ แแ แซแแแ แขแฃแแแ[4];// แแแกแแแ 4 แฌแแแแก แแ แแชแฎแแแแแก แแแแจแแแแแแแแแแ
แแแฌแแแแแ m = 3600.0;
แฎแแแแแฃแฌแแ แแแ int แแแกแแแแ แแ = 0;
int rc;// แชแแแแแ แแ แแชแฎแแแแแแแกแแแแก
แฎแแแแแฃแฌแแ แแแ แแ แซแแแ แฏแแแ = 0;
แฎแแแแแฃแฌแแ แแแ แแ แซแแแ แฏแแแ = 0;
แแแแขแ i = 0;
แแแแขแ k = 34;
แฎแแแแแฃแฌแแ แแแ int z = 0;
แแแแขแ b = B00000001;
แแแแขแ pumrcounter[4]; // แแแกแแแ แแแแแฅแขแแก แแแแแแแ แแแแแก แจแแกแแแแฎแแ, 1 - แแแแแ แแฃแแ, 0 - แฉแแ แแฃแแ.
int start = 0; //
แแแแแแ แแแงแแแแแ () {
rtc.begin();
radio.begin(); // แแฃแจแแแแแก แแแฌแงแแแ nRF24L01+
radio.setChannel(120); // แแแแแชแแแแ แแ แฎแ (0-แแแ 127-แแแ).
radio.setDataRate (RF24_250KBPS); // แแแแแชแแแแ แแแแแชแแแแก แกแแฉแฅแแ แ (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS).
radio.setPALevel(RF24_PA_MAX); // แแแแแแชแแแแก แกแแแซแแแแ แ (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm,
// RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openWritingPipe(0xAABBCCDD11LL); // แแแฎแกแแแแ แแแแ แแแแแขแแคแแแแขแแ แแ แแแแแชแแแแ แแแแแชแแแแกแแแแก
// แแ แแแก แแแกแแงแแแแแแแ, แแแแฃแฅแแแ แกแแญแแ แ แฎแแแแแ
//rtc.setDOW(1); // แแแแ แแก แแฆแ
//rtc.setTime(21, 20, 0); // แแ แ, 24 แกแแแแแแแ แคแแ แแแขแแ.
//rtc.setDate(29, 10, 2018); // แแแ แแฆแ, 29 แแฅแขแแแแแ แ, 2018 แฌ
tft.initR(INITR_BLACKTAB); // ST7735S แฉแแแแก, แจแแแ แฉแแแแ แแแก แแแแชแแแแแแแชแแ
// แแแแแแงแแแแ แแก แแแแชแแแแแขแแ แ (แฃแแแแแแขแแ แ), แแฃ แแงแแแแแ 1.44" TFT-แก
//tft.initR(INITR_144GREENTAB); // ST7735S แฉแแแแก, RED rcB แฉแแแแ แแแก แแแแชแแแแแแแชแแ
tft.setTextWrap(false); // แแแแ แแแแชแแ แขแแฅแกแขแก แแแ แฏแแแแ แแแแแแ แแแจแแแแ
tft.setRotation(2); // BLACK PCB-แกแแแแก แแ RED tft.setRotation(0)-แกแแแแก แแฃ แแ แ.
tft.fillScreen(ST7735_BLACK); // แแแ แแแแก แแแกแฃแคแแแแแแ
DDRD = DDRD | B00000000;
PORTD = PORTD | B11110000; // แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแแชแ แแแ แแฃแจแแแแก, แแแฆแแแ แแแแ -
// แแแแขแ แแแแ แแแแแ แแแแแฅแขแแแ โแแ แแฃแจแแแแกโ, โ4โ แแฌแแ แแแ แแแฎแแแ แแแแแแ แแแ แขแจแ D, แแแแแแ แแ แฎแแแแ.
for (rc = 0; rc <4; rc++)
{
tft.setCursor ( 3, rc * 10 + shift ); // แกแแแแแขแ แแแ แแแแแฅแขแแแแก แแแแแชแแแก แแแแ แแแแก แฉแแแแแแ
tft.print(rc + 1);
}
tft.setCursor(12, 0); // แขแแฅแกแขแแก 3 แกแขแ แแฅแแแแก แแแแแขแแแ
tft.println("DEVELOPERS & BUILD"); // แจแแแฅแ แจแแแ แกแแงแแแ แแแ แแแแแแแแแแ
tft.setCursor(24, 10); // แแ แแแ แแขแ แกแแแแขแแ แ แฃแคแแแแแแ
tft.print("DEVELOPER MM");
tft.setCursor(28, 20);
tft.print("BUILD-ER DD");
//แแแแแชแแแแ แแฆแแแแแ////////////////////////////////////////////// ///////////
for (z = 0; z <1023; z += 16) { // แแแแแ แแแก แแแแฃแกแขแ แแแก แงแแแแ แฃแฏแ แแแก
//แแ แฌแแ แก 4 แขแฃแแแแก แชแแแแแแก แแแกแแแจแ, 4 แแแแขแ แแแแแแฃแแ แแ แแชแฎแแแแแกแแแแก, แ แแแแแ
// แฎแแแแแฃแฌแแ แแแ แแ แซแแแ แชแแแแแ. แแ แแก 4 แแ แแชแฎแแแแ, 4-แแก แแ แแ แฉแแแแฌแแ แ แแฆแแแก 16 แแแแขแก.
EEPROM.get(z, แขแฃแแแ[0]); // แแกแ แ แแ, for loop-แแก แแแ แแจแ, แแแแแแแ แแแชแฃแแแแ
EEPROM.get(z+4, แขแฃแแแ[1]);
EEPROM.get(z+8, แขแฃแแแ[2]);
EEPROM.get(z+12, แขแฃแแแ[3]);
// แแฎแแแ แจแแแแแแ แแแแจแแแแแแแแก แแแแแญแแแ 4 แแ แแชแฎแแแแแก แฏแแแแกแแแแก
sumprim = (แขแฃแแแ [0] + แขแฃแแแ [1] + แขแฃแแแ [2] + แขแฃแแแ [3]);
// แแแแ แแแก sumprim แชแแแแแแก 4 แแ แแชแฎแแแแแก แฏแแแแก แแฎแแ แแแแจแแแแแแแแก แชแแแแแแก แฌแแแ แแแแจแแแแแแแแกแแแ
// sumsec แแ แแฃ แฌแแแ แฏแแแ แแแแแแแแ แแ แขแแแแ แแฎแแ แฏแแแก, แแแแญแแแ แแฎแแแ แแแแ แแ แขแแแ
// sumsec แแแแจแแแแแแแ.
แแฃ (sumsec <= sumprim) {
sumsec = sumprim; //
//แแ แแแแแแแแ แ แแแแจแแแแแแแ z แแแแญแแแ แแแกแแแแ แแแก แชแแแแแก, z แแ แแก 16-แแแแขแแแแ 4 แแแแจแแแแแแแแก แแแแแแก แแแกแแฌแงแแกแแก แแแกแแแแ แแ.
// แแ แแแ แแฃแแแ แฉแแฌแแ แแแ แแ แแชแฎแแแแแแ (แแแก แจแแแแแ, แ แแช แแแ แขแแก แแแแแแแแฎแแแกแแก, แแแกแ 8 แแแขแ แแ แแแ แแฃแแแ แแฌแแ แแแ,
// แฉแแแแ แแฃแชแแแแแแแ แแแฆแแแ 4 แแแขแแแแ D แแแ แขแแก แฉแแแแแแ).
แแแกแแแแ แแ = z;
}
}
// แแแแแ แแ แแฎแแ แฌแแแแแ eeprom แแแฎแกแแแ แแแแแ 16 แฉแแฌแแ แแแ แแ แแชแฎแแแแแก 4 แแแแขแแแแ แแแแแแก แแแกแแฌแงแแกแแก แแแกแแแแ แแแ
// แแแแ, แ.แ. แแแแจแแแแแแแแแ แแแงแแแแแก แแแแ แแแแแ แแแแแแ แแ แแแแแขแแแ แแแแแแ. แฃแแฎแแแกแ แฉแแฌแแ แ
// แแ แแชแฎแแแแแก แแแแจแแแแแแแแแ 4 แชแแแแแ แขแฃแแแแก แแแกแแแจแ.
EEPROM.get(แแแกแแแแ แแ, แขแฃแแแ[0]);
EEPROM.get(แแแกแแแแ แแ + 4, แขแฃแแแ[1]);
EEPROM.get(แแแกแแแแ แแ + 8, แขแฃแแแ[2]);
EEPROM.get(แแแกแแแแ แแ + 12, แขแฃแแแ[3]);
แแแกแแแแ แแ += 16; //แจแแแแแแ แแแแแแก แฉแแฌแแ แแกแแแแก แแแกแแแแ แแแก แแแแ แแ แแแแ แฉแแแแฌแแ แแก แแแแแชแแแแแแก แแแแแฌแแ แแก แแแ แแจแ
//แแแแแชแแแแแแก แแฆแแแแแแก แแแกแแกแ แฃแแ///////////////////////////////////////////////////////////////// //////////////////
attachInterrupt(0, count, RISING); // pin D2, แฉแแ แแแ แจแแคแแ แฎแแแแแ, แแแแ แงแแแแ แฌแแแก
// แแแแฃแแกแแแ RTC DS3231-แแแ SQW แแแแแกแแกแแแแแแแแ
wdt_enable (WDTO_8S); // แแแฃแจแแแ แแชแแแแ แขแแแแแ แ, แแแแแขแแแ แแแ แแแแขแ แแแแ แ แแแงแแแแแก แจแแแแฎแแแแแจแ, แแ แ,
// แ แแกแแแแกแแช แแฅแแแ แฃแแแ แแแกแชแแ แขแแแแแ แแก แแแแแขแแแ แแแแก แแ แซแแแแแ wdt_reset( แแ แแแแแแแ แแแชแแแแ แแแแแขแแแ แแแ แแแ แแแแฃแ แ แแฃแจแแแแแก แแ แแก - 8 แฌแ.
// แขแแกแขแแแแกแแแแก แแ แแ แแก แ แแแแแแแแแ แแแฃแแ แแแแจแแแแแแแแก แแแงแแแแแ 8 แฌแแแแ แแแแแแแแ.แแ แจแแแแฎแแแแแจแ แกแแกแฃแ แแแแแ แขแแแแแ แแก แแแแแขแแแ แแแ
// แฎแขแฃแแแ แแ แแก แงแแแแ แฌแแแก แฎแแแแ.
}
แแแแแแ แแแ แงแฃแแ () {
// แชแแ แแแแ แชแแแแ, แแฅ แแฅแแแแ แแแแขแ แแแ แแแแฅแขแ แแซแ แแแแก แฆแแ แคแแแแก แแฃแจแแแแแแ
}
แแแแแแ แ แแแแแแแแ() {
tft.setTextColor(ST7735_WHITE); // แแแแงแแแแ แจแ แแคแขแแก แคแแ แ
t = rtc.getTime(); // แฌแแแแแฎแแแก แแ แ
tft.setCursor(5, 120); // แแฃแ แกแแ แแก แแแแแชแแแก แแแงแแแแแ
tft.fillRect(5, 120, 50, 7, ST7735_BLACK); // แแ แแแก แแแแแแแแแแ แแ แแแแแก แแแกแฃแคแแแแแแ
tft.print(rtc.getTimeStr()); // แแแแแแแแแแ แกแแแแแก แฉแแแแแแแแ
wdt_reset(); // แแชแแแแแก แแแแแขแแแ แแแ แงแแแแ แชแแแแจแ, แแแฃ แฌแแแจแ
(rc = 0; rc <4; rc ++) // แชแแแแแก แแแกแแฌแงแแกแ แจแแงแแแแแก แแแแแแแ แแแแแก แจแแกแแแแแแกแแแแก แจแแกแแแแฌแแแแแแ
// แแแ แขแแก แแแขแ D แแแ แขแแก แฌแแแ แฌแแแแแฎแแแก แแแแแแแ แแแแแแแ
{
pinState = (PIND >> 4) & ( b << rc );
if (pumrcounter [rc] != pinState) { // แแ แแฃ แแ แแแแฎแแแแ, แแแจแแ
pumrcounter[rc] = pinState; // แแแ แขแแก แแแขแแก แกแขแแขแฃแกแแก แชแแแแแแก แแแแแญแแแ แแฎแแแ แแแแจแแแแแแแแก 1/0
}
// แคแแ แแก แแแแขแ แแแแก แแแแแฅแขแแแแก แแแแแแแ แแแแแก แแแแแแแแ
// BLUE แแ แแก แแ แกแแแฃแแ แแแ แแแแก (แแ แแแแแแแแแแแก?) แแชแแ แ แฎแแ แแแแ, RGB แแ BGR แแแ แแ.
if (pinState == (b << rc )) {
tft.fillRect(15, ((rc * 10 + shift)), 7, 7, ST7735_BLUE); // แแแแแแ แแแแแก แแแแแแแกแแแแก แจแแชแแแแแ แแฌแแแแ แแฃแ แฏแแ
} Else {
tft.fillRect(15, ((rc * 10 + shift)), 7, 7, ST7735_GREEN); // แแแแแแ แแแแแก แแแแแแแกแแแแก แจแแชแแแแแ แแฃแ แฏแ แแฌแแแแแ
แขแฃแแแ [rc] += 1; // แแแแแแขแแ 1 แฌแแแ แกแแแฃแจแแ แแ แแแก แแ แแชแฎแแแแก
}
}
k++;
แแฃ (k == 36) {
k = 0;
tft.fillRect(30, shift, 97, 40, ST7735_BLACK); // แแแแ แแชแแฃแแ แแ แแแก แฉแแแแแแแก แแ แแแแแก แแแกแฃแคแแแแแแ
tft.fillRect(60, 120, 73, 7, ST7735_BLACK); // แแ แแแ แแฆแแแ
tft.setCursor(60, 120); // แแฃแ แกแแ แแก แแแแแชแแแก แแแงแแแแแ
tft.print(rtc.getDateStr()); // แแแ แแฆแแก แฉแแแแแแ LCD แแแ แแแแ
(rc = 0; rc <4; rc ++) //แแแแแแแแแแ แกแแแฃแจแแ แกแแแแแแ แแแแแแแแแแจแ, แแแแแแแ แแ
{
tft.setCursor ( 30, rc * 10 + shift ); // แกแแแแแก แแแแกแแแ แแแ แแแแก 10 แแแฅแกแแแแ แแแฌแแแแ
tft.println(แขแฃแแแ [rc] / แ);
}
// EEPROM-แแ "แแแแแ" แกแแแฃแจแแ แกแแแแแแแก แแแแจแแแแแแแแแแก (แฌแแแแแจแ) แฉแแฌแแ แ ////////////////////////////
for (rc = 0; rc <4; rc++)
{
EEPROM.put(แแแกแแแแ แแ, แขแฃแแแ [rc]);
แแแกแแแแ แแ += sizeof(float); // แฉแแฌแแ แแก แแแกแแแแ แแแก แชแแแแแแก แแแแ แแ
}
}
// แแแแแแแแแ แแแแแชแแแแแ แ แแแแ แแ แฎแแ แแแแแชแแแแแแแแ, แกแแแแช แแแแแแแแฃแแแ แ แแแแแแ แแแแขแ แฃแแแ แแแแแแแแแแก.
แแฃ ((k == 6 ) || (k == 18 ) || (k == 30 )) {
แฎแแแแแฃแฌแแ แแแ แแ แซแแแ แแแแแชแแแแแ;
radio.write(&แแแฌแงแแแ, sizeof(แแแฌแงแแแ));
for (i = 0; i <4; i++) {
แแแแแชแแแแแ = แขแฃแแแ [i ];
radio.write( &data, sizeof( data));
}
}
}
แ แแแแแแแแ แจแแแแจแแแ แแแกแแกแ แฃแแก. แแแแแแ แฎแแแแ แแแแแ แแแแแแฃแ แแแแแแ แจแแงแแแแแแแ.
แแฌแแแแก แฌแแแแฆแแแแแ R2-R5 แแ แแก 36 kOhm แคแแขแแ แแแแกแขแแ แแแแ GL5516 แแแ แแแแขแแกแแแแก. แคแแขแแขแ แแแแแกแขแแ แ แแแขแแแฃแแแแ แแกแ แแ แ แแแแก แจแแแแฎแแแแแจแ แแแงแแแแแฃแแแ 4,7-5,1 kOhm-แแ. Arduino Nano v3.0 แฉแแแขแแแ แแแแแ แจแแแชแแแแ Arduino Uno-แแ TL866A แแ แแแ แแแแกแขแแ แแแแแแแ แแแแแแก แขแแแแแ แแก แกแฌแแ แ แแฃแจแแแแแกแแแแก. แกแแแ แแแแแ แจแแกแฌแแ แแแฃแแแ แแแแกแแแแก, แ แแ แแฃแจแแแแแแก 4,3 แ-แแ แแแแแ แซแแแแแแ. แแแ แ แแแแแขแแแ แแแแก แฌแ แ R6 C3 แแ แแงแ แแแแแงแแแแแฃแแ. แกแแแแแฃแจแ แแ แแแ แแแแจแ แแแแแแชแแแแก แกแแฎแจแแ แ แแ แจแแแกแแแแแแแ แแ แแแแชแแแแแ แแแฃแ แแแแแแแแแก; 2,4 MHz แแแแแแแแแ แจแแแแแคแแ แแแแแ 2400.0-2483.5 MHz แกแแฎแจแแ แแแแแ.
E01-ML01DP05 แแแแแแชแแแแก แแแแแแแแแ แแ แแก 2400-2525 MHz. แแ แแ แแ แฎแแก แแแแขแแ แฃแแแ แแแแแแ แแ แแก 1 MHz, แกแแฉแฅแแ แแก โRF24_2MBPSโ แแแงแแแแแแกแแก แแแแแแแแฃแแ radio.setChannel(120) แแ แฎแ แแฅแแแแ แแแแแแแแฃแแ, แ.แ. แแแแแแแแแ แแฅแแแแ 2 MHz.
แฌแงแแ แ: www.habr.com