Sistema Autónomo Local de Adquisición de Datos (continuación)

Comience en este sitio enlace.
La opción más conveniente para recuperar información sobre cómo encender el motor de arranque resultó ser la opción con el optoacoplador PC817. Diagrama esquemáticoLos tableros contienen tres circuitos idénticos, todo está colocado en cajas de plástico ABS de tamaño 100x100 mm. Foto de optoacopladores Cuando se conectan a dispositivos de arranque con válvulas semiconductoras, su corriente de fuga es suficiente para abrir el PC817 y el contador se disparará falsamente. Para excluir tal situación Se agrega uno más en serie al circuito del LED del optoacoplador y al LED de indicación de operación. Para ello se abre el puente J1 y se suelda un LED LED1 adicional.
La parte receptora se realiza en lado 1lado 2Placa de desarrollo conectada a ARDUINO MEGA 2560. Para ello se utiliza un conector de doble fila en el extremo. Como dispositivo de visualización de información se utiliza una pantalla con una resolución de 240x400, que tiene una pantalla táctil resistiva y un sensor de temperatura. HX8352B. Además, se retira el conector al ICSP en la placa de pantalla y no se utiliza la ranura micro SD. El hecho es que el zócalo SD "nativo" no se puede utilizar debido a un conflicto en el bus SPI. Para la tarjeta flash se utilizó un lector de tarjetas independiente, que incluía un estabilizador de 3,3 V y un chip buffer con tres estados de salida 74LVS125A. Aquí es donde me esperaba el rastrillo. Un búfer de tres estados, pero el E01-ML01DP5 o el lector de tarjetas funcionaron. En los comentarios de la biblioteca, SdFat vio una advertencia sobre la incompatibilidad con otros dispositivos. El convertidor de nivel en el TXS0108E fue retirado y reemplazado con puentes, porque E01-ML01DP5 tolera señales de 5 V; no ayudó. Usando un osciloscopio, se detectó una pérdida de señal en la línea MISO cuando se conectó un lector de tarjetas. Tras un examen cuidadoso, se encontró que las entradas de las señales de habilitación de los canales OE 4 del 74LVS125A simplemente estaban soldadas a un cable común y no se podía hablar de ningún tercer estado. El chip buffer se usó como un convertidor de nivel primitivo de 5 V a 3.3 V usando resistencias de 3,3 KΩ conectadas en serie con las líneas de señal. Excepto por la línea MISO. Su interruptor inferior de salida probablemente atraía señales al nivel del suelo. Habiendo determinado que la señal de habilitación de la línea MISO era el pin 13, se arrancó de la pista ysoldadoentre el dispositivo CS 9LVS74A, seleccione el pin de entrada (125) y la resistencia de terminación. Ahora, si no hay acceso a la tarjeta de memoria, el búfer MISO está desactivado y no interfiere con el funcionamiento de otro dispositivo.Diagrama de la placa de desarrolloReceptor en funcionamientoEl DS3231 utiliza un bus I2C de software (TWI) para conectar el reloj.
Programa Arduino IDE// IMPORTANTE: LA BIBLIOTECA Adafruit_TFTLCD DEBE ESTAR ESPECÍFICAMENTE
// CONFIGURADO PARA EL ESCUDO TFT O LA TABLA DE DESCONEXIÓN.
// VEA LOS COMENTARIOS RELEVANTES EN Adafruit_TFTLCD.h PARA LA CONFIGURACIÓN.
//por el equipo Open-Smart y el equipo Catalex
//[email protected]
//Almacenar: dx.com
// open-smart.aliexpress.com/store/1199788
//Función de demostración: mostrar gráficos, caracteres
//ArduinoIDE: 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 PULGADAS:
// 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

#incluir // Biblioteca de gráficos central
//#incluir // Biblioteca específica de hardware
#incluir
MCUFRIEND_kbv tft;
#include "SdFat.h" // Usa la biblioteca SdFat
SdFat SD;
Archivo SDFile;
Archivo miArchivo;
#definir SD_CS_PIN SS

#incluir // Conecta la biblioteca para trabajar con el bus SPI
#incluir // Conecta el archivo de configuración de la biblioteca RF24
#incluir // Conecta la biblioteca para trabajar con nRF24L24+
radioRF24(47, 49);

#incluir

DS3231 rtc(27, 25);
Tiempo t;

uint16_t r = 6000;
uint32_t k = 0;

datos largos volátiles sin firmar;
flotador leb_1;
flotador leb_2;
flotador leb_3;
flotador leb_4;

tubería uint8_t;
int rc = 0;

uint8_t time_sec_prev;
uint8_t hora_día_prev;

//************************************************ ****************/ /
// Si utiliza la placa de conexión TFT OPEN-SMART //
// Le recomendamos agregar un circuito convertidor de nivel de 5V-3.3V.
// Por supuesto, puedes usar la versión OPEN-SMART UNO Black con interruptor de alimentación de 5V/3.3 V,
// solo necesitas cambiar a 3.3V.
// Los pines de control para la pantalla LCD se pueden asignar a cualquier digital o
// pines analógicos...pero usaremos los pines analógicos ya que esto nos permite
//—————————————-|
// Conexión TFT - Arduino UNO / Mega2560 / OPEN-SMART UNO Negro
// TIERRA - TIERRA
// 3V3 - 3.3V
//CS-A3
// RS - A2
// WR - A1
// RD - A0
// PRIMERO - REINICIAR
// LED - TIERRA
// DB0 - 8
// DB1 - 9
// DB2 - 10
// DB3 - 11
// DB4 - 4
// DB5 - 13
// DB6 - 6
// DB7 - 7

// Asigna nombres legibles por humanos a algunos valores de color comunes de 16 bits:
#definir NEGRO 0x0000
#definir AZUL 0x001F
#definir ROJO 0xF800
#definir VERDE 0x07E0
#definir CIAN 0x07FF
#definir MAGENTA 0xF81F
#definir AMARILLO 0xFFE0
#definir BLANCO 0xFFFF
#definir GRIS 0x8C51
#definir GRIS 0x39E7

//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Si se usa el escudo, todas las líneas de control y datos son fijas, y
// opcionalmente se puede utilizar una declaración más sencilla:
// Adafruit_TFTLCD tft;
uint16_t g_identificador;

Cadena de datosCadena;
//Cadena numfileMonth = "1.txt";
char pervertido [] = {"2.txt"};
//Cadena *numfileMonth="1.txt" (sizeof (numfileMonth));
////////////////////////////////////////////////// /////////////////

configuración nula (nula) {

rtc.begin();

// Para configurar la hora, descomentar las líneas necesarias
// rtc.setDOW(6); // Día de la semana
// rtc.setTime(22, 04, 0); // Hora, en formato de 24 horas.
// rtc.setDate(4, 5, 2019); // Fecha, 29 de octubre de 2018

Serial.begin (2000000);
//////// Inicialización de pantalla
tft.begin(0x65);
tft.reset();
tft.setRotation(0);
tft.cp437(verdadero);
//////////////////Salida de nombres, accesorios de equipos, nombre de la organización
tft.fillScreen(NEGRO);
tft.setTextColor(BLANCO);
tft.setTextSize(2);
tft.setCursor(8, 0);
tft.println("DESARROLLADORES Y CONSTRUCCIÓN");
tft.setCursor(30, 20);
tft.print (utf8rus("Constructor V.V." ));
tft.setCursor(40, 40);
tft.print (utf8rus("Turner I.I."));
retraso (2000);

radio.begin(); // Iniciar trabajo nRF24L01+
radio.setChannel(120); // Especifica el canal de recepción de datos (de 0 a 127)
radio.setDataRate(RF24_250KBPS); // Especifica la velocidad de transferencia de datos (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Mbit/s
radio.setPALevel(RF24_PA_MAX); // Especifica la potencia del transmisor (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openReadingPipe(1, 0xAABBCCDD11LL); // Abre 1 tubería con el identificador de 1 transmisor 0xAABBCCDD11, para recibir datos
// Abra la tubería 2 con ID de transmisor 2xAABBCCDD0 para recibir datos
radio.startListening(); // Enciende el receptor, comienza a escuchar las tuberías abiertas.
// radio.stopListening();
////////Salida de información de servicio
tft.fillScreen(NEGRO);
tft.setCursor(8, 0);
tft.setTextSize(1);
////////Comienza a inicializar la tarjeta SD
Serial.println("Tarjeta SD inicial");
tft.println("Tarjeta SD inicial");
tft.setCursor(8, 10);
////////Iniciando la tarjeta
si (!SD.begin(SD_CS_PIN)) {
Serial.println ("¡falló la inicial!");
tft.fillRect(8, 10, 85, 7, ROJO);
tft.setTextColor(NEGRO);
tft.println("¡La inicial falló!");
volver;
}
tft.setTextColor(BLANCO);
Serial.println("inicialización realizada");
tft.println("Inicialización realizada");
retraso (2000);
////////Leer la hora y la fecha y asignarlas a variables
t = rtc.getTime();
time_sec_prev = t.seg;
time_day_prev = t.fecha;
//////// Imprime la fecha a la fuerza para no esperar a que cambie la fecha para mostrarla
tft.setCursor(180, 0); // estableciendo la posición del cursor
tft.fillRect(178, 0, 65, 7, GRIS); // limpiando el área de salida de tiempo
tft.setTextSize(1);
tft.print(rtc.getDateStr());
//////// Muestra el nombre de los objetos de control.
tft.setTextSize(2);
tft.setCursor(60, 25);
tft.println (utf8rus("Cabrestes I"));
////////Crear un archivo de registro y generar el resultado del intento de creación
tft.setTextSize(1);
tft.setCursor(130, 10); // si se crea el archivo de registro 2.txt, se continuará escribiendo en el archivo
si (SD.existe (pervertido)) {
//tft.setCursor(0, 90);
tft.println(pervertido);
Serial.println(pervertido);
} Else {
miArchivo = SD.open(pervertido, FILE_WRITE); // si el archivo 2.txt no existe, se creará
miArchivo.close();
tft.println(pervertido);
Serial.println(pervertido);
}
}

bucle vacío (vacío) {
//////// Comprobando la existencia de una solicitud para enviar un registro al monitor del puerto COM
si (Serie.disponible() > 0) {
if (1 == Serie.read());
////////Y si se acepta “1”, entonces la salida
Archivo miArchivo = SD.open(pervertido);
// si el archivo está disponible, escríbelo:
si (miArchivo) {
mientras (miArchivo.disponible()) {
Serial.write(myFile.read());
}
miArchivo.close();
}
else {
Serial.println("error al abrir .txt");
}
}
////////Tiempo de leer
t = rtc.getTime();
tft.setTextColor(BLANCO);
////////Si la hora ha cambiado, muestre las nuevas lecturas del reloj
si (time_sec_prev! = t.sec) {
tft.setCursor(120, 0); // estableciendo la posición del cursor
tft.fillRect(118, 0, 50, 7, GRIS); // limpiando el área de salida de tiempo
tft.setTextSize(1);
tft.print(rtc.getTimeStr()); // lecturas del reloj de salida
time_sec_prev = t.seg;
}
////////Si la fecha ha cambiado, muestra la nueva fecha
si (hora_día_prev! = t.fecha) {
tft.setCursor(180, 0); // estableciendo la posición del cursor
tft.fillRect(178, 0, 65, 7, GRIS); // borrar área de visualización de fecha
tft.setTextSize(1);
tft.print(rtc.getDateStr()); // mostrar lecturas de fecha
time_day_prev = t.fecha;
}
////////Si hay recepción de radio disponible, entonces
if (radio.disponible(&tubería)) {
//////// comprobando si el buffer de recepción está lleno,
radio.read(&datos, tamaño de(datos));
////////si la dirección del transmisor requerida está disponible, entonces
si (tubería == 1) {
////////esperando una secuencia de sincronización de ceros para determinar
//comienzo del bloque de datos
si (datos == 0000) {
rc = 0;
} Else {
rc++;
}
////////Registrar valores de contador y calcularlos en décimas y centésimas de hora
si (rc == 1) {
leb_1 = datos/3600.0;
}

si (rc == 2) {
leb_2 = datos/3600.0;
}

si (rc == 3) {
leb_3 = datos/3600.0;
}

si (rc == 4) {
leb_4 = datos/3600.0;
}
}
}
r++;
k++; // solo un contador
//////// Actualización de datos con cierta periodicidad
si ( r >= 6500) {
tft.setTextSize(2);
tft.fillRect(0, 41, 180, 64, GRIS);
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);
Serie.println(k);
r = 0;
}
////////Escribe datos en el registro en la SD cada 10 minutos.
si ((t.min % 10 == 0) && (t.seg == 0)) {
tft.setTextSize(1);
tft.setCursor(200, 10);
tft.setTextColor(NEGRO);
////////Creando una cadena en formato .csv
Cadena cadena de datos = Cadena (rtc.getDateStr()) + ", "+(rtc.getTimeStr()) + ", " + (leb_1) + ", " + (leb_2)
+ ", " + (leb_3) + ", " + (leb_4) + ", ";
////////Escribir en un archivo y generar los resultados del proceso de escritura.
miArchivo = SD.open(pervertido, FILE_WRITE); // si no hay ningún archivo llamado “2.txt”, se creará.
si (miArchivo) {
myFile.println(cadena de datos);
miArchivo.close();
tft.fillRect(198, 8, 42, 10, VERDE);
tft.println("SD OK");
Serial.println("SD OK");
retraso(900); // retraso, de lo contrario registra 13 lecturas idénticas hasta que haya pasado un segundo
} Else {
tft.fillRect(198, 8, 42, 10, ROJO);
tft.println("ERR SD");
Serial.println("ERR SD");
}
}
}Programa de conversión de personajes/* Recodificar fuentes rusas de UTF-8 a Windows-1251 */

Cadena utf8rus (fuente de cadena)
{
int i,k;
Objetivo de cadena;
carácter sin firmar n;
char m[2] = { '0', ' ' };

k = fuente.longitud(); yo = 0;

mientras (yo <k) {
n = fuente[i]; yo ++;

si (n >= 0xC0) {
cambiar (n) {
caso 0xD0: {
n = fuente[i]; yo ++;
si (n == 0x81) { n = 0xA8; romper; }
si (n >= 0x90 && n <= 0xBF) n = n + 0x30;//0x2F
break;
}
caso 0xD1: {
n = fuente[i]; yo ++;
si (n == 0x91) { n = 0xB8; romper; }
si (n >= 0x80 && n <= 0x8F) n = n + 0x70;//0x6F
break;
}
}
}
metro[0] = norte; objetivo = objetivo + Cadena (m);
}
objetivo de retorno;
}El programa de transcodificación de caracteres para salida cirílica usando la biblioteca Adafruit_GFX se coloca en la misma carpeta que el programa principal. También debe reemplazar el archivo glcdfont.c en Adafruit_GFX con una fuente diferente. es biblioteca con el reemplazo requerido. Se puede encontrar fácilmente más información sobre la rusificación en Internet.
En resumen, diré que el sistema estuvo a la altura de las expectativas, se ha vuelto más fácil monitorear el tiempo de funcionamiento del equipo. Aunque todo está montado sobre placas de pruebas, no hay quejas inmediatas sobre el trabajo. Los primeros elementos llevan más de seis meses trabajando y han sobrevivido al invierno. Último diseño Ha estado funcionando para 9 unidades controladas desde el 5 de marzo y se está registrando oficialmente el tiempo de operación con él.

Fuente: habr.com