Comeza neste sitio .
A opción máis conveniente para recuperar información sobre o acender o arrancador resultou ser a opción co optoacoplador PC817. Esquema esquemático
As placas conteñen tres circuítos idénticos, todo está colocado en caixas de plástico ABS, tamaño 100x100 mm. Foto de optoacopladores Cando se conecta a dispositivos de arranque con válvulas semicondutoras, a súa corrente de fuga é suficiente para abrir o PC817 e o contador activarase de forma falsa. Para excluír tal situación engádese un máis en serie ao circuíto do LED do optoacoplador e ao LED de indicación de funcionamento. Para iso, ábrese o puente J1 e sóldase un LED adicional LED1.
A parte receptora está feita lado 1lado 2placa de desenvolvemento conectada a ARDUINO MEGA 2560. Para iso, utilízase un conector de dobre fila ao final. Como dispositivo de visualización de información utilízase unha pantalla cunha resolución de 240x400, cunha pantalla táctil resistiva e un sensor de temperatura. HX8352B. Ademais, elimínase o conector do ICSP da placa de pantalla e non se utiliza a ranura micro SD. O caso é que o socket SD "nativo" non se pode usar debido a un conflito no bus SPI. Para a tarxeta flash, utilizouse un lector de tarxetas separado, que incluía un estabilizador de 3,3 V e un chip de memoria intermedia con tres estados de saída 74LVS125A. Aquí era onde me esperaba o anciño. Un búfer de tres estados, pero funcionaba o E01-ML01DP5 ou o lector de tarxetas. Nos comentarios da biblioteca, SdFat viu unha advertencia sobre a incompatibilidade con outros dispositivos. O conversor de nivel do TXS0108E foi eliminado e substituído por puentes, porque E01-ML01DP5 é tolerante aos sinais de 5V; non axudou. Usando un osciloscopio, detectouse unha perda de sinal na liña MISO cando se conectou un lector de tarxetas. Tras un exame coidadoso, descubriuse que as entradas dos sinais de habilitación das canles OE 4 do 74LVS125A foron simplemente soldadas a un fío común e non se podía falar de ningún terceiro estado. O chip buffer utilizouse como un conversor de nivel primitivo de 5V a 3.3V usando resistencias de 3,3 KΩ conectadas en serie coas liñas de sinal. Excepto a liña MISO. O seu interruptor inferior de saída probablemente atraeu sinais ao nivel do chan. Despois de determinar que o sinal de habilitación da liña MISO era o pin 13, arrancouse da pista esoldadosentre o pin de entrada de selección do dispositivo 9LVS74A CS (125) e a resistencia de terminación. Agora, se non hai acceso á tarxeta de memoria, o búfer MISO está desactivado e non interfire co funcionamento doutro dispositivo.Diagrama da placa de desenvolvementoReceptor en funcionamentoO DS3231 usa un bus I2C de software (TWI) para conectar o reloxo.
Programa Arduino IDE// IMPORTANTE: A BIBLIOTECA Adafruit_TFTLCD DEBE SER ESPECÍFICAMENTE
// CONFIGURADO PARA O TFT SHIELD OU PARA O BREAKOUT BOARD.
// VER OS COMENTARIOS RELEVANTES EN Adafruit_TFTLCD.h PARA A CONFIGURACIÓN.
//por Open-Smart Team e Catalex Team
//[protexido por correo electrónico]
//Almacenar:
//
//Función de demostración: mostrar gráficos, personaxes
//Arduino IDE: 1.6.5
// Placa: Arduino UNO R3, Arduino Mega2560, Arduino Leonardo
// Placa: OPEN-SMART UNO R3 5V / 3.3V, Arduino UNO R3, Arduino Mega2560
//TFT de 3.2 polgadas:
//
//OPEN-SMART UNO R3 5V / 3.3V:
//
#incluír // Biblioteca de gráficos básicos
//#incluír // Biblioteca específica de hardware
#incluír
MCUFRIEND_kbv tft;
#include "SdFat.h" // Usa a biblioteca SdFat
SdFat SD;
ficheiro SdFile;
Arquivo myFile;
#definir SD_CS_PIN SS
#incluír // Conecta a biblioteca para traballar co bus SPI
#incluír // Conecta o ficheiro de configuración da biblioteca RF24
#incluír // Conecta a biblioteca para traballar con nRF24L24+
radio RF24 (47, 49);
#incluír
DS3231 rtc(27, 25);
Tempo t;
uint16_t r = 6000;
uint32_t k = 0;
datos longos volátiles sen asinar;
flotar leb_1;
flotar leb_2;
flotar leb_3;
flotar leb_4;
tubo uint8_t;
int rc = 0;
uint8_t time_sec_prev;
uint8_t time_day_prev;
//************************************************ ****************//
// Se usa a placa de distribución OPEN-SMART TFT //
// Recoméndase engadir un circuíto de conversión de nivel 5V-3.3V.
// Por suposto que pode usar a versión OPEN-SMART UNO Black con interruptor de alimentación de 5V/3.3V,
// só precisa cambiar a 3.3V.
// Os pinos de control para a pantalla LCD pódense asignar a calquera dixital ou
// pinos analóxicos... pero usaremos os pinos analóxicos cando isto nos permita
//—————————————-|
// TFT Breakout - Arduino UNO / Mega2560 / OPEN-SMART UNO Negro
// GND - GND
// 3V3 - 3.3V
//CS - A3
// RS - A2
// WR - A1
// RD - A0
// RST - RESET
// LED - GND
// DB0 - 8
// DB1 - 9
// DB2 - 10
// DB3 - 11
// DB4 - 4
// DB5 - 13
// DB6 - 6
// DB7 - 7
// Asignar nomes lexibles por humanos a algúns valores de cores comúns de 16 bits:
#definir NEGRO 0x0000
#definir AZUL 0x001F
#definir RED 0xF800
#define VERDE 0x07E0
#definir CYAN 0x07FF
#definir MAGENTA 0xF81F
#definir AMARELO 0xFFE0
#definir BRANCO 0xFFFF
#definir GRIS 0x8C51
#definir GRAYD 0x39E7
//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Se se utiliza o escudo, todas as liñas de control e datos están fixas, e
// Opcionalmente pódese usar unha declaración máis sinxela:
// Adafruit_TFTLCD tft;
uint16_t g_identifier;
String dataString;
//String numfileMonth = "1.txt";
char perv [] = {"2.txt"};
//String *numfileMonth="1.txt" (tamaño de (numfileMonth));
//////////////////////////////////////////////////////////////////////////////////////// // //////////////////
configuración void (void) {
rtc.begin();
// Para axustar a hora, descomenta as liñas necesarias
// rtc.setDOW(6); // Día da semana
// rtc.setTime(22, 04, 0); // Hora, en formato de 24 horas.
// rtc.setDate(4, 5, 2019); // Data, 29 de outubro de 2018
Serial.begin (2000000);
//////// Inicialización da pantalla
tft.begin(0x65);
tft.reset();
tft.setRotation(0);
tft.cp437(true);
//////////////////Saída de nomes, accesorios do equipamento, nome da organización
tft.fillScreen(NEGRO);
tft.setTextColor(BRANCO);
tft.setTextSize(2);
tft.setCursor(8, 0);
tft.println("DESENVOLVADORES E CONSTRUIR");
tft.setCursor(30, 20);
tft.print (utf8rus ("Construtor V.V." ));
tft.setCursor(40, 40);
tft.print (utf8rus ("Turner I.I." ));
atraso (2000);
radio.begin(); // Iniciar o traballo nRF24L01+
radio.setChannel(120); // Especifica a canle de recepción de datos (de 0 a 127)
radio.setDataRate(RF24_250KBPS); // Especifique a velocidade de transferencia de datos (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Mbit/s
radio.setPALevel(RF24_PA_MAX); // Especifique a potencia do transmisor (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openReadingPipe(1, 0xAABBCCDD11LL); // Abrir 1 tubo co identificador de 1 transmisor 0xAABBCCDD11, para recibir datos
// Abrir o tubo 2 co ID do transmisor 2xAABBCCDD0 para recibir datos
radio.startListening(); // Acende o receptor, comeza a escoitar as tuberías abertas
// radio.stopListening();
////////Saída da información do servizo
tft.fillScreen(NEGRO);
tft.setCursor(8, 0);
tft.setTextSize(1);
////////Comezar a inicializar a tarxeta SD
Serial.println("Tarxeta SD inicial");
tft.println("Tarxeta SD inicial");
tft.setCursor(8, 10);
////////Inicialización da tarxeta
se (!SD.begin(SD_CS_PIN)) {
Serial.println("error inicial!");
tft.fillRect(8, 10, 85, 7, VERMELLO);
tft.setTextColor(NEGRO);
tft.println("Fallou a inicial!");
regreso;
}
tft.setTextColor(BRANCO);
Serial.println("inicialización feita");
tft.println("Inicialización feita");
atraso (2000);
////////Ler a data e a hora e asignalas a variables
t = rtc.getTime();
time_sec_prev = t.sec;
hora_día_prev = t.data;
////////Forza a data para non esperar a que a data cambie para mostrar
tft.setCursor(180, 0); // establecendo a posición do cursor
tft.fillRect(178, 0, 65, 7, GRIS); // borrando a área de saída do tempo
tft.setTextSize(1);
tft.print(rtc.getDateStr());
////////Sae o nome dos obxectos de control
tft.setTextSize(2);
tft.setCursor(60, 25);
tft.println (utf8rus("Winches I"));
////////Creando un ficheiro de rexistro e mostrando o resultado do intento de creación
tft.setTextSize(1);
tft.setCursor(130, 10); // se se crea o ficheiro de rexistro 2.txt, a escritura no ficheiro continuará
se (SD.existe(perv)) {
//tft.setCursor(0, 90);
tft.println(perv);
Serial.println(perv);
Else {}
myFile = SD.open(perv, FILE_WRITE); // se o ficheiro 2.txt non existe, crearase
meuFicheiro.close();
tft.println(perv);
Serial.println(perv);
}
}
bucle de void (void) {
////////Comprobando a existencia dunha solicitude para enviar un rexistro ao monitor do porto COM
se (Serial.available() > 0) {
se (1 == Serial.read());
//////// E se se acepta "1", entón a saída
Ficheiro meuFicheiro = SD.open(perv);
// se o ficheiro está dispoñible, escríbeo:
se (meu ficheiro) {
mentres (meuFicheiro.dispoñible()) {
Serial.write(myFile.read());
}
meuFicheiro.close();
}
máis {
Serial.println("erro ao abrir .txt");
}
}
////////Hora de lectura
t = rtc.getTime();
tft.setTextColor(BRANCO);
////////Se a hora cambiou, amosa as novas lecturas do reloxo
if ( time_sec_prev != t.sec) {
tft.setCursor(120, 0); // establecendo a posición do cursor
tft.fillRect(118, 0, 50, 7, GRIS); // borrando a área de saída do tempo
tft.setTextSize(1);
tft.print(rtc.getTimeStr()); // saíu as lecturas do reloxo
time_sec_prev = t.sec;
}
////////Se a data cambiou, amosa a nova data
if ( hora_día_anterior != t.data) {
tft.setCursor(180, 0); // establecendo a posición do cursor
tft.fillRect(178, 0, 65, 7, GRIS); // limpar a área de visualización da data
tft.setTextSize(1);
tft.print(rtc.getDateStr()); // mostrar lecturas da data
hora_día_prev = t.data;
}
////////Se a recepción de radio está dispoñible, entón
if (radio.available(&pipe)) {
////////comprobando se o búfer de recepción está cheo,
radio.read(&datos, sizeof(datos));
////////se o enderezo do transmisor necesario está dispoñible, entón
if (tubo == 1) {
////////estamos esperando a que se determine a secuencia de ceros de sincronización
//inicio do bloque de datos
if (datos == 0000) {
rc = 0;
Else {}
rc++;
}
//////// Gravar os valores do contador e calculalos en décimas e centésimas de hora
se (rc == 1) {
leb_1 = datos / 3600.0;
}
se (rc == 2) {
leb_2 = datos / 3600.0;
}
se (rc == 3) {
leb_3 = datos / 3600.0;
}
se (rc == 4) {
leb_4 = datos / 3600.0;
}
}
}
r++;
k++; // só un contador
//////// Actualización de datos con certa periodicidade
se ( r >= 6500) {
tft.setTextSize(2);
tft.fillRect(0, 41, 180, 64, GRAYD);
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;
}
////////Escribe datos no rexistro da SD cada 10 minutos.
se ((t.min % 10 == 0) && ( t.seg == 0)) {
tft.setTextSize(1);
tft.setCursor(200, 10);
tft.setTextColor(NEGRO);
////////Creando unha cadea en formato .csv
String dataString = String (rtc.getDateStr()) + ", "+(rtc.getTimeStr()) + ", " + (leb_1) + ", " + (leb_2)
+ ", " + (leb_3) + ", " + (leb_4) + ", ";
////////Escribe nun ficheiro e mostra os resultados do proceso de escritura
myFile = SD.open(perv, FILE_WRITE); // se non hai ningún ficheiro chamado "2.txt", crearase.
se (meu ficheiro) {
myFile.println(dataString);
meuFicheiro.close();
tft.fillRect(198, 8, 42, 10, VERDE);
tft.println("SD OK");
Serial.println("SD OK");
atraso (900); // atraso, se non, rexistra 13 lecturas idénticas ata que pase un segundo
Else {}
tft.fillRect(198, 8, 42, 10, VERMELLO);
tft.println("ERR SD");
Serial.println("ERR SD");
}
}
}Programa de conversión de caracteres/* Recodificar fontes rusas de UTF-8 a Windows-1251 */
String utf8rus (fonte da cadea)
{
int i,k;
Obxectivo de cadea;
unsigned char n;
char m[2] = { '0', ' ' };
k = fonte.lonxitude(); i = 0;
mentres que (i < k) {
n = fonte [i]; i++;
se (n >= 0xC0) {
interruptor (n) {
caso 0xD0: {
n = fonte [i]; i++;
se (n == 0x81) { n = 0xA8; romper; }
se (n >= 0x90 && n <= 0xBF) n = n + 0x30;//0x2F
romper;
}
caso 0xD1: {
n = fonte [i]; i++;
se (n == 0x91) { n = 0xB8; romper; }
se (n >= 0x80 && n <= 0x8F) n = n + 0x70;//0x6F
romper;
}
}
}
m[0] = n; target = target + String(m);
}
obxectivo de retorno;
}O programa de transcodificación de caracteres para a saída cirílica mediante a biblioteca Adafruit_GFX colócase no mesmo cartafol co programa principal. Tamén cómpre substituír o ficheiro glcdfont.c en Adafruit_GFX por outro tipo de letra. biblioteca coa substitución necesaria. Máis información sobre a rusificación pódese atopar facilmente en Internet.
Para resumir, direi que o sistema cumpriu as expectativas, fíxose máis fácil controlar o tempo de funcionamento do equipo. Aínda que todo está montado en placas, non hai queixas inmediatas sobre o traballo. Os primeiros elementos levan máis de seis meses funcionando e sobreviviron ao inverno. Desde o 9 de marzo leva funcionando para 5 unidades controladas e o tempo de funcionamento estase rexistrando oficialmente usando el.
Fonte: www.habr.com