แแแแฌแงแแ แแ แกแแแขแแ
แกแขแแ แขแแ แแก แฉแแ แแแแก แจแแกแแฎแแ แแแคแแ แแแชแแแก แแแกแแแแแแแแแ แงแแแแแแ แแแกแแฎแแ แฎแแแแแ แแแ แแแแขแ แแฆแแแฉแแแ PC817 แแแขแแแฃแแแแ แแก แแแ แแแแขแ. แกแฅแแแแก แแแแแ แแแแแแคแแแ แจแแแชแแแก แกแแ แแแแแขแฃแ แฌแ แแก, แงแแแแแคแแ แ แแแแแแกแแแฃแแแ ABS แแแแกแขแแแกแแก แงแฃแแแแจแ, แแแแ 100x100 แแ. แแแขแแแฃแแแแ แแก แคแแขแ แแแฎแแแแ แแแแขแแ แฃแแ แกแแ แฅแแแแแแแก แกแแกแขแแ แขแ แแแฌแงแแแแแแแแแแแ แแแแแแจแแ แแแแกแแก, แแแแ แแแแแแแแก แแแแ แกแแแแแ แแกแแ PC817-แแก แแแกแแฎแกแแแแแ แแ แแ แแชแฎแแแแ แชแ แฃ แแแแฅแขแแฃแ แแแแ. แแกแแแ แกแแขแฃแแชแแแก แแแแแ แแชแฎแแแก แแแแแแ
แแแแฆแแแ แแแฌแแแ แแแแแแแแ แแฎแแ แ 1แแฎแแ แ 2ARDUINO MEGA 2560-แแแ แแแแแแจแแ แแแฃแแ แแแแแแแแแ แฃแแ แแแคแ. แแแแกแแแแก แแแแแจแ แแแแแแงแแแแแ แแ แ แแแแแแ แแแแแฅแขแแ แ. แแแ แแแ 240x400 แแแ แฉแแแแแแแแ, แ แแแแแกแแช แแฅแแก แ แแแแกแขแแแขแฃแแ แกแแแกแแ แฃแแ แแแ แแแ แแ แขแแแแแ แแขแฃแ แแก แกแแแกแแ แ, แแแแแแงแแแแแ แแแคแแ แแแชแแแก แฉแแแแแแแก แแแฌแงแแแแแแแแ. HX8352B. แแแ แแ แแแแกแ, แแแ แแแแก แแแคแแแ ICSP-แแก แแแแแฅแขแแ แ แแแแฆแแแฃแแแ แแ แแแแ แ SD แกแแแขแ แแ แแแแแแงแแแแแ. แคแแฅแขแแ, แ แแ "แแจแแแแแฃแ แ" SD แกแแแแขแแก แแแแแงแแแแแ แจแแฃแซแแแแแแแ SPI แแแขแแแฃแกแจแ แแแแคแแแฅแขแแก แแแแ. แคแแแจ แแแ แแแแกแแแแก แแแแแแงแแแแก แชแแแแ แแแ แแแแก แฌแแแแแแฎแแแแ, แ แแแแแแช แแแแชแแแแ 3,3 แ แกแขแแแแแแแแขแแ แก แแ แแฃแคแแ แฃแ แฉแแแก แกแแแ แแแแแแแแแแ แแแแแแแ แแแแแ 74LVS125A. แแฅ แ แแแ แแแแแแ. แกแแแ แแแแแแแ แแแแแก แแฃแคแแ แ, แแแแ แแ E01-ML01DP5 แแ แแแ แแแแก แฌแแแแแแฎแแแแ แแฃแจแแแแแ. แแแแแแแแแแแก แแแแแแขแแ แแแจแ SdFat-แแ แแแแแแฎแ แแแคแ แแฎแแแแแ แกแฎแแ แแแฌแงแแแแแแแแแแแ แจแแฃแแแแกแแแแแแแก แจแแกแแฎแแ. แแแแแก แแแแแแงแแแแ TXS0108E-แแ แแแแแฆแแก แแ แจแแชแแแแแก แฏแแแแ แแแ, แ แแแแแ E01-ML01DP5 แขแแแแ แแแขแฃแแแ 5V แกแแแแแแแแแก แแแแแ แ - แแก แแ แแแแฎแแแ แ. แแกแแแแกแแแแแก แแแแแงแแแแแแ, MISO แฎแแแแ แแแแแแแแแแ แกแแแแแแแก แแแแแ แแแ แแแ แแแแก แฌแแแแแแฎแแแแแก แแแแ แแแแแกแแก. แกแแแฃแแแแแฃแแ โโแจแแแแฌแแแแแก แจแแแแแแ แแแแแแแแ, แ แแ 4LVS74A-แแก OE 125 แแ แฎแแก แฉแแแ แแแแแ แกแแแแแแแแแก แจแแงแแแแ แฃแแ แแแแ แกแแแ แแ แแแแแฃแแแ แแงแ แแแแแแ แแแฃแแ แแ แแแกแแแ แแแแแแแ แแแแแแ แกแแฃแแแ แ แแ แแงแ. แแฃแคแแ แฃแแ แฉแแแ แแแแแแงแแแแแแแ แ แแแแ แช แแ แแแแขแแฃแแ แแแแแก แแแแแแงแแแแ 5V-แแแ 3.3V-แแแ 3,3 Kฮฉ แ แแแแกแขแแ แแแแก แแแแแงแแแแแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แกแแแแแแแก แฎแแแแแแแ แกแแ แแแจแ. แแแ แแ MISO แฎแแแแกแ. แแแกแ แแแแแแแแแแ แฅแแแแ แแแแแแ แแแแแ แกแแแแ แแฃแแแ แแแแแแแแ แกแแแแแแแแก แแแฌแแก แแแแแแ. แแแก แจแแแแแ แ แแช แแแแแแแแ, แ แแ MISO แฎแแแแก แฉแแ แแแแก แกแแแแแแ แแงแ แแแแ 13, แแแ แแแแแฆแแก แขแ แแกแแแแ แแแจแแแฃแฆแแแฃแแ9LVS74A CS แแแฌแงแแแแแแแแก แจแแ แแก แแแ แฉแแแ แจแแงแแแแแก แแแแ (125) แแ แแแกแ แฃแแแแแก แ แแแแกแขแแ แก แจแแ แแก. แแฎแแ, แแฃ แแแฎแกแแแ แแแแก แแแ แแแแ แฌแแแแแ แแ แแ แแก, MISO แแฃแคแแ แ แแแแแ แแฃแแแ แแ แแ แฃแจแแแก แฎแแแก แกแฎแแ แแแฌแงแแแแแแแแก แแฃแจแแแแแก.แแแแแแแแ แแแแก แแแคแแก แแแแแ แแแแแแแฆแแแ แแฃแจแแแแกDS3231 แแงแแแแแก แแ แแแ แแแฃแ I2C แแแขแแแฃแกแก (TWI) แกแแแแแก แแแกแแแแแจแแ แแแแแ.
Arduino IDE แแ แแแ แแแ// แแแแจแแแแแแแแแแ: Adafruit_TFTLCD แแแแแแแแแแ แฃแแแ แแงแแก แแแแแ แแขแฃแแแ
// แแแแคแแแฃแ แแ แแแฃแแแ แแ TFT SHIELD-แแกแแแแก แแ BREAKout board-แแกแแแแก.
// แแแงแแแแแแก แแแแแแ แแฎแแแแ แจแแกแแแแแแกแ แแแแแแขแแ แแแ Adafruit_TFTLCD.h-แจแ.
//Open-Smart Team แแ Catalex Team-แแก แแแแ
//[แแ.แคแแกแขแแ แแแชแฃแแแ]
//แแแฆแแแแ:
//
//แแแแ แคแฃแแฅแชแแ: แแ แแคแแแแก, แกแแแแแแแแแแก แฉแแแแแแ
//Arduino IDE: 1.6.5
// แแแคแ: Arduino UNO R3, Arduino Mega2560, Arduino Leonardo
// แแแคแ:OPEN-SMART UNO R3 5V / 3.3V, Arduino UNO R3, Arduino Mega2560
//3.2 แแแฉแแแแ TFT:
//
//OPEN-SMART UNO R3 5V / 3.3V:
//
#แจแแแชแแแก // แซแแ แแแแแ แแ แแคแแแฃแแ แแแแแแแแแแ
//#แจแแแชแแแก // แแแแ แแขแฃแ แแก แกแแแชแแคแแแฃแ แ แแแแแแแแแแ
#แจแแแชแแแก
MCUFRIEND_kbv tft;
#include "SdFat.h" // แแแแแแงแแแแ SdFat แแแแแแแแแแ
SdFat SD;
SdFile แคแแแแ;
แคแแแแ myFile;
#define SD_CS_PIN SS
#แจแแแชแแแก // แแแแแแแจแแ แแ แแแแแแแแแแ SPI แแแขแแแฃแกแแแ แแฃแจแแแแแกแแแแก
#แจแแแชแแแก // แแแแแแแจแแ แแ แแแ แแแแขแ แแแแก แคแแแแ RF24 แแแแแแแแแแแแแ
#แจแแแชแแแก // แแแแแแแจแแ แแ แแแแแแแแแแ nRF24L24+-แแแ แแฃแจแแแแแกแแแแก
RF24 แ แแแแ(47, 49);
#แจแแแชแแแก
DS3231 rtc(27, 25);
แแ แ t;
uint16_t r = 6000;
uint32_t k = 0;
แแ แแกแขแแแแแฃแ แ แฎแแแแแฃแฌแแ แแแ แแ แซแแแ แแแแแชแแแแแ;
float leb_1;
float leb_2;
float leb_3;
float leb_4;
uint8_t แแแแ;
int rc = 0;
uint8_t time_sec_prev;
uint8_t time_day_prev;
//************************************************ ****************//
// แแฃ แแงแแแแแ OPEN-SMART TFT แแแ แฆแแแแแก แแแคแแก //
// แแแ แฉแแแ แแแแแแขแแ 5V-3.3V แแแแแก แแแแแแ แขแแชแแแก แฌแ แ.
// แ แ แแฅแแ แฃแแแ, แจแแแแซแแแแ แแแแแแงแแแแ OPEN-SMART UNO แจแแแ แแแ แกแแ 5V/3.3V แแแแแก แแแแแแ แแแแแแ,
// แแฅแแแ แฃแแ แแแแ แแญแแ แแแแแ แแแแแ แแแ 3.3 แ.
// LCD-แแก แกแแแแแขแ แแแ แฅแแแซแแกแแแแแแ แจแแแซแแแแ แแแแแแญแแก แแแแแกแแแแ แชแแคแ แฃแ แแ
// แแแแแแแฃแ แ แฅแแแซแแกแแแแแแ...แแแแ แแ แฉแแแ แแแแแแแงแแแแแ แแแแแแแฃแ แฅแแแซแแกแแแแแแก, แ แแแแ แช แแก แแแแซแแแแก แแแแก แกแแจแฃแแแแแแก
//โโโโโโโโโโโโโโ-|
// TFT Breakout - Arduino UNO / Mega2560 / OPEN-SMART UNO แจแแแ
// GND - GND
// 3V3 - 3.3V
//CS - A3
// RS - A2
// WR - A1
// RD - A0
// RST - แแแแแขแแแ แแแ
// LED - GND
// DB0 - 8
// DB1 - 9
// DB2 - 10
// DB3 - 11
// DB4 - 4
// DB5 - 13
// DB6 - 6
// DB7 - 7
// แแแแแแญแแ แแแแแแแแแก แแแแ แฌแแกแแแแแฎแ แกแแฎแแแแแ แแแแแแ แ แกแแแ แแ 16-แแแขแแแ แคแแ แแ แแแแจแแแแแแแแก:
#define BLACK 0x0000
#define BLUE 0x001F
#define RED 0xF800
#define GREEN 0x07E0
#define CYAN 0x07FF
#define MAGENTA 0xF81F
#define YELLOW 0xFFE0
#define WHITE 0xFFFF
#define GRAY 0x8C51
#define GRAYD 0x39E7
//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// แคแแ แแก แแแแแงแแแแแแก แจแแแแฎแแแแแจแ, แงแแแแ แกแแแแแขแ แแแ แแ แแแแแชแแแแ แฎแแแ แคแแฅแกแแ แแแแ แแ
// แกแฃแ แแแแแกแแแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แฃแคแ แ แแแ แขแแแ แแแแแแ แแชแแ:
// Adafruit_TFTLCD tft;
uint16_t g_identifier;
แกแแแแแแแแ dataString;
//String numfileMonth = "1.txt";
char perv [] = {"2.txt"};
//แกแขแ แแฅแแแ *numfileMonth="1.txt" (sizeof (numfileMonth));
////////////////////////////////////////////////// //////////////////
แแแแแแ แแแงแแแแแ (แแแแแแแ) {
rtc.begin();
// แแ แแแก แแแกแแงแแแแแแแ, แแแแฃแฅแแแ แกแแญแแ แ แฎแแแแแ
// rtc.setDOW(6); // แแแแ แแก แแฆแ
// rtc.setTime (22, 04, 0); // แแ แ, 24 แกแแแแแแแ แคแแ แแแขแแ.
// rtc.setDate(4, 5, 2019); // แแแ แแฆแ, 29 แแฅแขแแแแแ แ, 2018 แฌ
แกแแ แแแแ. แแแกแแฌแงแแกแ (2000000);
//////// แแแ แแแแก แแแแชแแแแแแแชแแ
tft.begin(0x65);
tft.reset();
tft.setRotation(0);
tft.cp437 (true);
//////////////////แกแแฎแแแแแแก แแแแแแแแแแ, แแฆแญแฃแ แแแแแแแก แแฅแกแแกแฃแแ แแแ, แแ แแแแแแแชแแแก แกแแฎแแแ
tft.fillScreen(BLACK);
tft.setTextColor(WHITE);
tft.setTextSize(2);
tft.setCursor(8, 0);
tft.println("DEVELOPERS & BUILD");
tft.setCursor(30, 20);
tft.print (utf8rus ("Constructor V.V." ));
tft.setCursor(40, 40);
tft.print (utf8rus ("Turner I.I." ));
แแแแแแแแแแแ (2000);
radio.begin(); // แแฃแจแแแแแก แแแฌแงแแแ nRF24L01+
radio.setChannel(120); // แแแฃแแแแแ แแแแแชแแแแ แแแฆแแแแก แแ แฎแ (0-แแแ 127-แแแ)
radio.setDataRate (RF24_250KBPS); // แแแฃแแแแแ แแแแแชแแแแ แแแแแชแแแแก แกแแฉแฅแแ แ (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Mbit/s
radio.setPALevel(RF24_PA_MAX); // แแแฃแแแแแ แแแแแแชแแแแก แกแแแซแแแแ แ (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openReadingPipe(1, 0xAABBCCDD11LL); // แแแฎแกแแแแ 1 แแแแ 1 แแแแแแชแแแแก แแแแแขแแคแแแแขแแ แแ 0xAABBCCDD11, แแแแแชแแแแแแก แแแกแแฆแแแแ
// แแแฎแกแแแแ แแแแ 2 แแแแแแชแแแแก ID 2xAABBCCDD0 แแแแแชแแแแแแก แแแกแแฆแแแแ
radio.startListening(); // แฉแแ แแแ แแแแฆแแแ, แแแแฌแงแแ แฆแแ แแแแแแแก แแแกแแแแ
// radio.stopListening();
////////แกแแ แแแกแแก แแแคแแ แแแชแแแก แแแแแแแแแแ
tft.fillScreen(BLACK);
tft.setCursor(8, 0);
tft.setTextSize(1);
////////แแแแฌแงแแ SD แแแ แแแแก แแแแชแแแแแแแชแแ
Serial.println ("แกแแฌแงแแกแ SD แแแ แแแ");
tft.println ("แกแแฌแงแแกแ SD แแแ แแแ");
tft.setCursor(8, 10);
////////แแแ แแแแก แแแแชแแแแแแแชแแ
if (!SD.begin(SD_CS_PIN)) {
Serial.println ("แกแแฌแงแแกแ แแแ แแแฎแแ แฎแแ!");
tft.fillRect(8, 10, 85, 7, RED);
tft.setTextColor(BLACK);
tft.println ("แกแแฌแงแแกแ แแแ แแแฎแแ แฎแแ!");
แแแแ แฃแแแแแแ;
}
tft.setTextColor(WHITE);
Serial.println("แแแแชแแแแแแแชแแ แจแแกแ แฃแแแแฃแแแ");
tft.println ("แแแแชแแแแแแแชแแ แจแแกแ แฃแแแแฃแแแ");
แแแแแแแแแแแ (2000);
////////แแ แแแกแ แแ แแแ แแฆแแก แฌแแแแแฎแแ แแ แชแแแแแแแแกแแแแก แแแแ แแแแแญแแแ
t = rtc.getTime();
แแ แ_แฌแ_แฌแแ = t.sec;
แแ แ_แแฆแ_แฌแแ = t.แแแ แแฆแ;
////////แแซแฃแแแแแ แแแแแแขแแแแ แแแ แแฆแ, แ แแแ แแ แแแแแแแแ แแแ แแฆแแก แจแแชแแแแก แฉแแแแแแแกแแแแก
tft.setCursor(180, 0); // แแฃแ แกแแ แแก แแแแแชแแแก แแแงแแแแแ
tft.fillRect(178, 0, 65, 7, GRAY); // แแ แแแก แแแแแแแแแแ แแ แแแแแก แแแกแฃแคแแแแแแ
tft.setTextSize(1);
tft.print(rtc.getDateStr());
////////แแแแแแขแแแแ แกแแแแแขแ แแแ แแแแแฅแขแแแแก แกแแฎแแแ
tft.setTextSize(2);
tft.setCursor(60, 25);
tft.println (utf8rus ("Winches I"));
////////แแแแแก แคแแแแแก แจแแฅแแแ แแ แจแแฅแแแแก แแชแแแแแแแก แจแแแแแแก แแแแแขแแแ
tft.setTextSize(1);
tft.setCursor(130, 10); // แแฃ log แคแแแแ 2.txt แจแแแฅแแแ, แแแจแแ แคแแแแจแ แฉแแฌแแ แ แแแแ แซแแแแแแ
if (SD.exists(perv)) {
//tft.setCursor(0, 90);
tft.println(perv);
Serial.println(perv);
} Else {
myFile = SD.open(perv, FILE_WRITE); // แแฃ แคแแแแ 2.txt แแ แแ แกแแแแแก, แแก แจแแแฅแแแแแ
myFile.close();
tft.println(perv);
Serial.println(perv);
}
}
แแแแแแ แแแ แงแฃแแ (แแแแแแแ) {
////////แแแแฎแแแแแก แแ แกแแแแแแก แจแแแแฌแแแแ COM แแแ แขแแก แแแแแขแแ แแ แแฃแ แแแแแก แแแแแขแแแแก แจแแกแแฎแแ
if (Serial.available() > 0) {
if (1 == Serial.read());
////////แแ แแฃ "1" แแแฆแแแฃแแแ, แแแจแแ แแแแแแแแแแ
แคแแแแ myFile = SD.open(perv);
// แแฃ แคแแแแ แฎแแแแแกแแฌแแแแแแ, แฉแแฌแแ แแ:
แแฃ (myFile) {
while (myFile.available()) {
Serial.write(myFile.read());
}
myFile.close();
}
แกแฎแแแแแ {
Serial.println ("แจแแชแแแแ แแแฎแกแแแก .txt");
}
}
////////แฒแแแฎแแแก แแ แ
t = rtc.getTime();
tft.setTextColor(WHITE);
////////แแฃ แแ แ แจแแแชแแแแ, แแแจแแ แแฉแแแแแ แแฎแแแ แกแแแแแก แฉแแแแแแแแ
แแฃ (time_sec_prev != t.sec) {
tft.setCursor(120, 0); // แแฃแ แกแแ แแก แแแแแชแแแก แแแงแแแแแ
tft.fillRect(118, 0, 50, 7, GRAY); // แแ แแแก แแแแแแแแแแ แแ แแแแแก แแแกแฃแคแแแแแแ
tft.setTextSize(1);
tft.print(rtc.getTimeStr()); // แแแแแแแแแแ แกแแแแแก แฉแแแแแแแแ
แแ แ_แฌแ_แฌแแ = t.sec;
}
////////แแฃ แแแ แแฆแ แจแแแชแแแแ, แแแจแแ แแฉแแแแแ แแฎแแแ แแแ แแฆแ
แแฃ (time_day_prev != t.date) {
tft.setCursor(180, 0); // แแฃแ แกแแ แแก แแแแแชแแแก แแแงแแแแแ
tft.fillRect(178, 0, 65, 7, GRAY); // แแแ แแฆแแก แฉแแแแแแแก แแ แแแแแก แแแกแฃแคแแแแแแ
tft.setTextSize(1);
tft.print(rtc.getDateStr()); // แแแ แแฆแแก แฉแแแแแแ
แแ แ_แแฆแ_แฌแแ = t.แแแ แแฆแ;
}
////////แแฃ แ แแแแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแ, แแแจแแ
if (แ แแแแ.แฎแแแแแกแแฌแแแแแแ(&pipe)) {
////////แจแแแแฌแแแแ แแ แแก แแฃ แแ แ แแแแฆแแแแก แแฃแคแแ แ แกแแแกแ,
radio.read(&data, sizeof(data));
////////แแฃ แกแแญแแ แ แแแแแแชแแแแก แแแกแแแแ แแ แฎแแแแแกแแฌแแแแแแ, แแแจแแ
แแฃ (แแแแ == 1) {
////////แแแแแแแ แแฃแแแแแก แกแแแฅแ แแแแแแแฃแแ แแแแแแแแแแ แแแแก แแแแกแแแฆแแ แแก
//แแแแแชแแแแ แแแแแแก แแแกแแฌแงแแกแ
แแฃ (แแแแแชแแแแแ == 0000) {
rc = 0;
} Else {
rc++;
}
////////แแ แแชแฎแแแแแก แแแแจแแแแแแแแแแก แฉแแฌแแ แ แแ แแแแ แแแแแแแแ แกแแแแแก แแ-10 แแ 100-แจแ
แแฃ (rc == 1) {
leb_1 = แแแแแชแแแแแ / 3600.0;
}
แแฃ (rc == 2) {
leb_2 = แแแแแชแแแแแ / 3600.0;
}
แแฃ (rc == 3) {
leb_3 = แแแแแชแแแแแ / 3600.0;
}
แแฃ (rc == 4) {
leb_4 = แแแแแชแแแแแ / 3600.0;
}
}
}
r++;
k++; // แฃแแ แแแแ แแ แแชแฎแแแแ
//////// แแแแแชแแแแ แแแแแฎแแแแ แแแ แแแแฃแแ แแแ แแแแฃแแแแแ
แแฃ (r >= 6500) {
tft.setTextSize(2);
tft.fillRect(0, 41, 180, 64, GRAYD);
Serial.println("แแแแแแแ I");
tft.setCursor(0, 41);
tft.println(leb_1);
Serial.println(leb_1);
tft.println(leb_2);
Serial.println(leb_2);
tft.println(leb_3);
Serial.println(leb_3);
tft.println(leb_4);
Serial.println(leb_4);
Serial.println(k);
r = 0;
}
//////// แฉแแฌแแ แแ แแแแแชแแแแแ แแฃแ แแแแจแ SD-แแ แงแแแแ 10 แฌแฃแแจแ.
แแฃ ((t.min % 10 == 0) && (t.sec == 0)) {
tft.setTextSize(1);
tft.setCursor(200, 10);
tft.setTextColor(BLACK);
////////แกแขแ แแฅแแแแก แจแแฅแแแ .csv แคแแ แแแขแจแ
แกแแแแแแแแ dataString = แกแขแ แแฅแแแ (rtc.getDateStr()) + ", "+(rtc.getTimeStr()) + ", " + (leb_1) + ", " + (leb_2)
+ ", " + (leb_3) + ", " + (leb_4) + ", ";
////////แฉแแฌแแ แแ แคแแแแจแ แแ แแแแแแขแแแแ แฌแแ แแก แแ แแชแแกแแก แจแแแแแแแ
myFile = SD.open(perv, FILE_WRITE); // แแฃ แแ แแ แแก แคแแแแ แกแแฎแแแแ "2.txt", แแก แจแแแฅแแแแแ.
แแฃ (myFile) {
myFile.println(dataString);
myFile.close();
tft.fillRect(198, 8, 42, 10, แแฌแแแแ);
tft.println ("SD OK");
Serial.println ("SD OK");
แแแแแแแแแแแ(900); // แแแแแแแแแแแ, แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ แฉแแแฌแแ แก 13 แแแแแขแฃแ แแแแฎแแแก แฌแแแแก แแแกแแแแแแ
} Else {
tft.fillRect(198, 8, 42, 10, RED);
tft.println ("SD ERR");
Serial.println("SD ERR");
}
}
}แกแแแแแแแแแแก แแแแแแ แขแแชแแแก แแ แแแ แแแ/* แ แฃแกแฃแแ แจแ แแคแขแแแแก แแแแแแแแ UTF-8-แแแ Windows-1251-แแแ */
แกแแแแแแแแ utf8rus (แกแขแ แแฅแแแแก แฌแงแแ แ)
{
int i,k;
แกแแแแแแแแ แกแแแแแแ;
แฎแแแแแฃแฌแแ แแแ char n;
char m[2] = { '0', ' ' };
k = แฌแงแแ แ.แกแแแ แซแ(); i = 0;
แฎแแแ (i < k) {
n = แฌแงแแ แ[i]; แแ++;
แแฃ (n >= 0xC0) {
แจแแชแแแ (n) {
แกแแฅแแ 0xD0: {
n = แฌแงแแ แ[i]; แแ++;
แแฃ (n == 0x81) {n = 0xA8; แจแแกแแแแแแ; }
แแฃ (n >= 0x90 && n <= 0xBF) n = n + 0x30;//0x2F
แจแแกแแแแแแ;
}
แกแแฅแแ 0xD1: {
n = แฌแงแแ แ[i]; แแ++;
แแฃ (n == 0x91) {n = 0xB8; แจแแกแแแแแแ; }
แแฃ (n >= 0x80 && n <= 0x8F) n = n + 0x70;//0x6F
แจแแกแแแแแแ;
}
}
}
m[0] = n; แกแแแแแแ = แกแแแแแแ + แกแขแ แแฅแแแ(แ);
}
แแแแ แฃแแแแแก แกแแแแแแ;
}Adafruit_GFX แแแแแแแแแแแก แแแแแงแแแแแแ แกแแแแแแแแ แขแ แแแกแแแแแ แแแแก แแ แแแ แแแ แแแ แแแแชแแก แแแแแแแแแแแกแแแแก แแแแแแกแแแฃแแแ แแแแแ แกแแฅแแฆแแแแแจแ แแแแแแ แแ แแแ แแแแกแแแ แแ แแแ. แแฅแแแ แแกแแแ แฃแแแ แจแแชแแแแแ glcdfont.c แคแแแแ Adafruit_GFX-แจแ แกแฎแแ แจแ แแคแขแแ.
แจแแฏแแแแแแกแแแแก, แแ แแแขแงแแ, แ แแ แกแแกแขแแแแ แแแแแแ แแแ แแแแแแแแ, แฃแคแ แ แแแแแแ แแแฎแแ แแฆแญแฃแ แแแแแแแก แแฃแจแแแแแก แแ แแแก แแแแแขแแ แแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แงแแแแแคแแ แ แแฃแ แแก แแแคแแแแแ แแฌแงแแแแแ, แกแแแฃแจแแแแ แแงแแกแแแ แ แแ แแขแแแแแ แแ แแ แกแแแแแก. แแแ แแแแ แแแแแแแขแแแ แแฅแแก แแแแแ แแแขแแ แแฃแจแแแแก แแ แแแแแแ แก แแแแแฃแ แฉแ.
แฌแงแแ แ: www.habr.com