Sistema di acquisizione dati locale autonomo (continua)

Inizia su questo sito collegamento.
L'opzione più conveniente per recuperare le informazioni sull'accensione dell'avviatore si è rivelata l'opzione con l'accoppiatore ottico PC817. Schema schematicoLe schede contengono tre circuiti identici, il tutto è collocato in scatole di plastica ABS, dimensione 100x100 mm. Foto di optoaccoppiatori Se collegati a dispositivi di avviamento con valvole a semiconduttore, la loro corrente di dispersione è sufficiente per aprire il PC817 e il contatore si attiverà erroneamente. Per escludere una situazione del genere un altro viene aggiunto in serie al circuito del LED fotoaccoppiatore e al LED di indicazione del funzionamento. A tale scopo viene aperto il ponticello J1 e viene saldato un ulteriore LED LED1.
La parte ricevente è realizzata lato 1lato 2scheda di sviluppo collegata ad ARDUINO MEGA 2560. Per questo, all'estremità viene utilizzato un connettore a doppia fila. Come dispositivo di visualizzazione delle informazioni viene utilizzato uno schermo con una risoluzione di 240x400, dotato di touchscreen resistivo e sensore di temperatura. HX8352B. Inoltre viene rimosso il connettore dell'ICSP sulla scheda dello schermo e lo slot micro SD non viene utilizzato. Il fatto è che la presa SD “nativa” non può essere utilizzata a causa di un conflitto sul bus SPI. Per la scheda flash è stato utilizzato un lettore di schede separato, che includeva uno stabilizzatore da 3,3 V e un chip buffer con tre stati di uscita 74LVS125A. È qui che mi aspettava il rastrello. Un buffer a tre stati, ma funzionavano sia l'E01-ML01DP5 che il lettore di schede. Nei commenti della biblioteca, SdFat ha visto un avviso di incompatibilità con altri dispositivi. Il convertitore di livello sul TXS0108E è stato rimosso e sostituito con ponticelli, perché E01-ML01DP5 tollera i segnali a 5 V: non è stato d'aiuto. Utilizzando un oscilloscopio è stata rilevata una perdita di segnale sulla linea MISO quando era collegato un lettore di schede. Dopo un attento esame, si è riscontrato che gli ingressi dei segnali di abilitazione dei canali OE 4 del 74LVS125A erano semplicemente saldati su un filo comune e non si poteva parlare di un terzo stato. Il chip buffer è stato utilizzato come convertitore di livello primitivo da 5 V a 3.3 V utilizzando resistori da 3,3 KΩ collegati in serie con le linee di segnale. Fatta eccezione per la linea MISO. Il suo interruttore inferiore in uscita probabilmente attirava segnali al livello del suolo. Dopo aver determinato che il segnale di abilitazione della linea MISO era il pin 13, è stato staccato dal binario esaldatotra il pin di ingresso di selezione del dispositivo CS 9LVS74A (125) e il resistore di terminazione. Ora, se non è possibile accedere alla scheda di memoria, il buffer MISO è disabilitato e non interferisce con il funzionamento di un altro dispositivo.Diagramma della scheda di sviluppoRicevitore in funzioneIl DS3231 utilizza un bus I2C software (TWI) per collegare l'orologio.
Programma IDE di Arduino// IMPORTANTE: LA LIBRERIA Adafruit_TFTLCD DEVE ESSERE SPECIFICAMENTE
// CONFIGURATO PER LO SCUDO TFT O PER LA SCHEDA BREAKOUT.
// VEDI I COMMENTI PERTINENTI IN Adafruit_TFTLCD.h PER LA CONFIGURAZIONE.
//da Open-Smart Team e Catalex Team
//[email protected]
//Negozio: dx.com
// open-smart.aliexpress.com/store/1199788
//Funzione demo: visualizza grafica, caratteri
//IDE Arduino: 1.6.5
// Scheda: Arduino UNO R3, Arduino Mega2560, Arduino Leonardo

// Scheda:OPEN-SMART UNO R3 5V / 3.3V, Arduino UNO R3, Arduino Mega2560
//TFT DA 3.2 POLLICI:
// www.aliexpress.com/store/product/3-2-TFT-LCD-Display-module-Touch-Screen-Shield-board-onboard-temperature-sensor-w-Touch-Pen/1199788_32755473754.html?spm=2114.12010615.0.0.bXDdc3
//OPEN-SMART UNO R3 5V / 3.3V:
// www.aliexpress.com/store/product/OPEN-SMART-5V-3-3V-Compatible-UNO-R3-CH340G-ATMEGA328P-Development-Board-with-USB-Cable-for/1199788_32758607490.html?spm=2114.12010615.0.0.ckMTaN

#includere // Libreria grafica principale
//#includere // Libreria specifica dell'hardware
#includere
MCUFRIEND_kbv tft;
#include "SdFat.h" // Utilizza la libreria SdFat
SDFat SD;
File SDFile;
File mioFile;
#define SD_CS_PIN SS

#includere // Collega la libreria per lavorare con il bus SPI
#includere // Collega il file delle impostazioni dalla libreria RF24
#includere // Collega la libreria per lavorare con nRF24L24+
Radio RF24(47, 49);

#includere

DS3231 rtc(27, 25);
Tempo t;

uint16_tr = 6000;
uint32_t k = 0;

dati lunghi volatili senza segno;
float leb_1;
float leb_2;
float leb_3;
float leb_4;

uint8_t pipa;
intero rc = 0;

uint8_t time_sec_prev;
uint8_t ora_giorno_prev;

//************************************************ ****************/ /
// Se utilizzi la scheda breakout TFT OPEN-SMART //
// Ti consiglio di aggiungere un circuito di conversione del livello 5V-3.3V.
// Ovviamente puoi utilizzare la versione OPEN-SMART UNO Black con interruttore di alimentazione da 5 V/3.3 V,
// devi solo passare a 3.3 V.
// I pin di controllo per l'LCD possono essere assegnati a qualsiasi digitale o
// pin analogici...ma useremo i pin analogici poiché questo ci consente di farlo
//—————————————-|
// Breakout TFT - Arduino UNO / Mega2560 / OPEN-SMART UNO Nero
// TERRA-TERRA
// 3V3 - 3.3V
//CS-A3
// RS-A2
// WR - A1
//RD-A0
// RST-RESET
//LED-TERRA
//DB0-8
//DB1-9
//DB2-10
//DB3-11
//DB4-4
//DB5-13
//DB6-6
//DB7-7

// Assegna nomi leggibili ad alcuni comuni valori di colore a 16 bit:
#define NERO 0x0000
#define BLU 0x001F
#define ROSSO 0xF800
#define VERDE 0x07E0
#define CIANO 0x07FF
#define MAGENTA 0xF81F
#define GIALLO 0xFFE0
#define BIANCO 0xFFFF
#define GRIGIO 0x8C51
#define GRAYD 0x39E7

//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Se si utilizza lo scudo, tutte le linee di controllo e dati sono fisse e
// facoltativamente può essere utilizzata una dichiarazione più semplice:
// Adafruit_TFTLCD tft;
uint16_t identificatore_g;

Stringa dataString;
//String numfileMonth = "1.txt";
char pervertito [] = {"2.txt"};
//String *numfileMonth="1.txt" (sizeof (numfileMonth));
////////////////////////////////////////////////// /////////////////

configurazione vuota (vuota) {

rtc.begin();

// Per impostare l'ora, decommentare le righe necessarie
// rtc.setDOW(6); // Giorno della settimana
// rtc.setTime(22, 04, 0); // Ora, nel formato 24 ore.
// rtc.setDate(4, 5, 2019); // Data, 29 ottobre 2018

Serial.begin (2000000);
//////// Inizializzazione dello schermo
tft.begin(0x65);
tft.reset();
tft.setRotazione(0);
tft.cp437(vero);
//////////////////Output di nomi, accessori dell'attrezzatura, nome dell'organizzazione
tft.fillScreen(NERO);
tft.setTextColor(BIANCO);
tft.setTextSize(2);
tft.setCursor(8, 0);
tft.println("SVILUPPATORI E COSTRUZIONE");
tft.setCursor(30, 20);
tft.print (utf8rus("Costruttore V.V." ));
tft.setCursor(40, 40);
tft.print (utf8rus("Turner I.I." ));
ritardo(2000);

radio.begin(); // Avvia il lavoro nRF24L01+
radio.setChannel(120); //Specifica il canale di ricezione dei dati (da 0 a 127)
radio.setDataRate(RF24_250KBPS); // Specificare la velocità di trasferimento dati (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Mbit/s
radio.setPALevel(RF24_PA_MAX); // Specificare la potenza del trasmettitore (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openReadingPipe(1, 0xAABBCCDD11LL); // Aprire 1 tubo con l'identificatore di 1 trasmettitore 0xAABBCCDD11, per ricevere i dati
// Aprire il tubo 2 con ID trasmettitore 2xAABBCCDD0 per ricevere i dati
radio.inizioAscolto(); // Accendi il ricevitore, inizia ad ascoltare i tubi aperti
// radio.stopListening();
////////Output delle informazioni di servizio
tft.fillScreen(NERO);
tft.setCursor(8, 0);
tft.setTextSize(1);
////////Avvia l'inizializzazione della scheda SD
Serial.println("Scheda SD iniziale");
tft.println("Scheda SD iniziale");
tft.setCursor(8, 10);
////////Inizializzazione della scheda
if (!SD.begin(SD_CS_PIN)) {
Serial.println("iniziale fallita!");
tft.fillRect(8, 10, 85, 7, ROSSO);
tft.setTextColor(NERO);
tft.println("Iniziale fallita!");
ritorno;
}
tft.setTextColor(BIANCO);
Serial.println("inizializzazione completata");
tft.println("Inizializzazione eseguita");
ritardo(2000);
////////Leggere ora e data e assegnarle a variabili
t = rtc.getTime();
tempo_sec_prev = t.sec;
time_day_prev = t.data;
////////Emette forzatamente la data in modo da non attendere che la data cambi per la visualizzazione
tft.setCursor(180, 0); // imposta la posizione del cursore
tft.fillRect(178, 0, 65, 7, GRIGIO); // cancella l'area di output del tempo
tft.setTextSize(1);
tft.print(rtc.getDateStr());
////////Emette in output il nome degli oggetti di controllo
tft.setTextSize(2);
tft.setCursor(60, 25);
tft.println (utf8rus("Verricelli I"));
////////Creazione di un file di registro e output del risultato del tentativo di creazione
tft.setTextSize(1);
tft.setCursor(130, 10); // se viene creato il file di registro 2.txt, la scrittura nel file continuerà
se (SD.esiste(perv)) {
//tft.setCursor(0, 90);
tft.println(pervertito);
Serial.println(pervertito);
} Else {
mioFile = SD.open(perv, FILE_WRITE); // se il file 2.txt non esiste, verrà creato
mioFile.close();
tft.println(pervertito);
Serial.println(pervertito);
}
}

ciclo vuoto (vuoto) {
////////Verifica dell'esistenza di una richiesta di output di un registro sul monitor della porta COM
if (Serial.available() > 0) {
if (1 == Serial.read());
////////E se "1" viene accettato, allora l'output
File mioFile = SD.open(perv);
// se il file è disponibile, scrivilo:
if (mioFile) {
mentre (mioFile.disponibile()) {
Serial.write(mioFile.read());
}
mioFile.close();
}
else {
Serial.println("errore durante l'apertura del .txt");
}
}
////////Momento della lettura
t = rtc.getTime();
tft.setTextColor(BIANCO);
////////Se l'ora è cambiata, visualizza le nuove letture dell'orologio
if ( time_sec_prev != t.sec) {
tft.setCursor(120, 0); // imposta la posizione del cursore
tft.fillRect(118, 0, 50, 7, GRIGIO); // cancella l'area di output del tempo
tft.setTextSize(1);
tft.print(rtc.getTimeStr()); // letture dell'orologio in uscita
tempo_sec_prev = t.sec;
}
////////Se la data è cambiata, visualizza la nuova data
if ( ora_giorno_prev != t.data) {
tft.setCursor(180, 0); // imposta la posizione del cursore
tft.fillRect(178, 0, 65, 7, GRIGIO); // cancella l'area di visualizzazione della data
tft.setTextSize(1);
tft.print(rtc.getDateStr()); // visualizza le letture della data
time_day_prev = t.data;
}
////////Se la ricezione radio è disponibile, allora
if (radio.available(&pipe)) {
////////verifica se il buffer di ricezione è pieno,
radio.read(&data, sizeof(data));
////////se l'indirizzo del trasmettitore richiesto è disponibile, allora
se (tubo == 1) {
////////in attesa di una sequenza di sincronizzazione di zeri da determinare
//inizio del blocco dati
se (dati == 0000) {
RC = 0;
} Else {
RC++;
}
////////Registrazione dei valori dei contatori e calcolo in decimi e centesimi di ora
se (rc == 1) {
leb_1 = dati/3600.0;
}

se (rc == 2) {
leb_2 = dati/3600.0;
}

se (rc == 3) {
leb_3 = dati/3600.0;
}

se (rc == 4) {
leb_4 = dati/3600.0;
}
}
}
r++;
k++; // solo un contatore
//////// Aggiornamento dei dati con una certa periodicità
se (r >= 6500) {
tft.setTextSize(2);
tft.fillRect(0, 41, 180, 64, GRIGIO);
Serial.println("Lebedki 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;
}
////////Scrivere i dati sul registro sulla SD ogni 10 minuti.
if ((t.min % 10 == 0) && ( t.sec == 0)) {
tft.setTextSize(1);
tft.setCursor(200, 10);
tft.setTextColor(NERO);
////////Creazione di una stringa in formato .csv
String dataString = String (rtc.getDateStr()) + ", "+(rtc.getTimeStr()) + ", " + (leb_1) + ", " + (leb_2)
+ ", " + (leb_3) + ", " + (leb_4) + ", ";
////////Scrivere in un file e visualizzare i risultati del processo di scrittura
mioFile = SD.open(perv, FILE_WRITE); // se non è presente alcun file denominato "2.txt", verrà creato.
if (mioFile) {
mioFile.println(dataString);
mioFile.close();
tft.fillRect(198, 8, 42, 10, VERDE);
tft.println("SD OK");
Serial.println("SD OK");
ritardo(900); // ritarda, altrimenti registra 13 letture identiche finché non è trascorso un secondo
} Else {
tft.fillRect(198, 8, 42, 10, ROSSO);
tft.println("ERRORE SD");
Serial.println("ERRORE SD");
}
}
}Programma di conversione dei caratteri/* Ricodifica i caratteri russi da UTF-8 a Windows-1251 */

Stringa utf8rus(Sorgente stringa)
{
int i,k;
Bersaglio stringa;
carattere senza segno n;
char m[2] = { '0', ' ' };

k = sorgente.lunghezza(); io = 0;

mentre (i < k) {
n = sorgente[i]; io++;

se (n >= 0xC0) {
interruttore (n) {
caso 0xD0: {
n = sorgente[i]; io++;
se (n == 0x81) { n = 0xA8; rottura; }
se (n >= 0x90 && n <= 0xBF) n = n + 0x30;//0x2F
break;
}
caso 0xD1: {
n = sorgente[i]; io++;
se (n == 0x91) { n = 0xB8; rottura; }
se (n >= 0x80 && n <= 0x8F) n = n + 0x70;//0x6F
break;
}
}
}
m[0] = n; bersaglio = bersaglio + String(m);
}
obiettivo di ritorno;
}Il programma di transcodifica dei caratteri per l'output in cirillico utilizzando la libreria Adafruit_GFX si trova nella stessa cartella del programma principale. È inoltre necessario sostituire il file glcdfont.c in Adafruit_GFX con un carattere diverso. Qui libreria con la sostituzione richiesta. Maggiori informazioni sulla russificazione possono essere facilmente trovate su Internet.
Riassumendo, dirò che il sistema è stato all'altezza delle aspettative, è diventato più facile monitorare il tempo di funzionamento dell'apparecchiatura. Anche se tutto è assemblato su breadboard, non ci sono lamentele immediate sul lavoro. I primi elementi hanno funzionato per più di sei mesi e sono sopravvissuti all'inverno. Ultimo disegno È in funzione per 9 unità controllate dal 5 marzo e il tempo di funzionamento viene ufficialmente registrato utilizzandolo.

Fonte: habr.com