Sistema Autônomo Local de Aquisição de Dados (continuação)

Comece neste site по ссылке.
A opção mais conveniente para recuperar informações sobre como ligar o starter acabou sendo a opção com o optoacoplador PC817. Diagrama esquemáticoAs placas contêm três circuitos idênticos, tudo é colocado em caixas plásticas ABS, tamanho 100x100 mm. Foto de optoacopladores Quando conectados a dispositivos de partida com válvulas semicondutoras, sua corrente de fuga é suficiente para abrir o PC817 e o contador disparará falsamente. Para excluir tal situação mais um é adicionado em série ao circuito do LED do acoplador óptico e do LED de indicação de operação. Para isso, o jumper J1 é aberto e um LED LED1 adicional é soldado.
A parte receptora é feita em lado 1lado 2placa de desenvolvimento conectada ao ARDUINO MEGA 2560. Para isso, é utilizado um conector de duas fileiras na extremidade. Uma tela com resolução de 240x400, possuindo tela sensível ao toque resistiva e sensor de temperatura, é utilizada como dispositivo de exibição de informações. HX8352B. Além disso, o conector para ICSP na placa da tela é removido e o slot micro SD não é usado. O fato é que o soquete SD “nativo” não pode ser utilizado devido a um conflito no barramento SPI. Para o cartão flash, foi usado um leitor de cartão separado, que incluía um estabilizador de 3,3V e um chip buffer com três estados de saída 74LVS125A. É aqui que o ancinho estava esperando por mim. Um buffer de três estados, mas o E01-ML01DP5 ou o leitor de cartão funcionaram. Nos comentários da biblioteca, o SdFat viu um aviso sobre incompatibilidade com outros dispositivos. O conversor de nível do TXS0108E foi removido e substituído por jumpers, pois E01-ML01DP5 é tolerante a sinais de 5V - não ajudou. Usando um osciloscópio, foi detectada uma perda de sinal na linha MISO quando um leitor de cartão foi conectado. Após um exame cuidadoso, descobriu-se que as entradas dos sinais de habilitação dos canais OE 4 do 74LVS125A foram simplesmente soldadas a um fio comum e não se podia falar de nenhum terceiro estado. O chip buffer foi usado como um conversor de nível primitivo de 5V para 3.3V usando resistores de 3,3 KΩ conectados em série com as linhas de sinal. Exceto a linha MISO. Sua chave inferior de saída provavelmente atraiu sinais para o nível do solo. Tendo determinado que o sinal de habilitação da linha MISO era o pino 13, ele foi arrancado da pista esoldadoentre o pino de entrada de seleção do dispositivo 9LVS74A CS (125) e o resistor de terminação. Agora, se não houver acesso ao cartão de memória, o buffer MISO fica desabilitado e não interfere no funcionamento de outro dispositivo.Diagrama da placa de desenvolvimentoReceptor em operaçãoO DS3231 usa um barramento I2C de software (TWI) para conectar o relógio.
Programa Arduino IDE// IMPORTANTE: A BIBLIOTECA Adafruit_TFTLCD DEVE SER ESPECIFICAMENTE
// CONFIGURADO PARA O TFT SHIELD OU PARA A BREAKOUT BOARD.
// VEJA COMENTÁRIOS RELEVANTES EM Adafruit_TFTLCD.h PARA CONFIGURAÇÃO.
//pela equipe Open-Smart e equipe Catalex
//[email protegido]
//Loja: dx.com
// open-smart.aliexpress.com/store/1199788
//Função Demo: Exibir gráficos, caracteres
//IDE do Arduino: 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 POLEGADAS:
// 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 gráfica principal
//#incluir // Biblioteca específica de hardware
#incluir
MCUFRIEND_kbvtft;
#include "SdFat.h" // Use a biblioteca SdFat
SdFat SD;
Arquivo SDFile;
Arquivo meuArquivo;
#define SD_CS_PIN SS

#incluir //Conecta a biblioteca para trabalhar com o barramento SPI
#incluir //Conecta o arquivo de configurações da biblioteca RF24
#incluir //Conecta a biblioteca para trabalhar com nRF24L24+
rádio RF24(47, 49);

#incluir

DS3231rtc(27, 25);
Tempo t;

uint16_t r = 6000;
uint32_t k = 0;

dados longos não assinados e voláteis;
flutuar leb_1;
flutuar leb_2;
flutuar leb_3;
flutuar leb_4;

tubo uint8_t;
intrc = 0;

uint8_t time_sec_prev;
uint8_t time_day_prev;

//************************************************ ****************/ /
// Se você usar a placa de breakout OPEN-SMART TFT //
// Recomendo que você adicione um circuito de conversão de nível 5V-3.3V.
// Claro que você pode usar a versão OPEN-SMART UNO Black com interruptor de alimentação 5V/3.3V,
// você só precisa mudar para 3.3V.
// Os pinos de controle do LCD podem ser atribuídos a qualquer sinal digital ou
// pinos analógicos... mas usaremos os pinos analógicos, pois isso nos permite
//——————————|
// TFT Breakout - Arduino UNO / Mega2560 / OPEN-SMART UNO Preto
// GND - GND
//3V3 - 3.3V
//CS - A3
//RS-A2
//WR-A1
//RD-A0
//RST - REINICIAR
//LED - GND
//DB0 - 8
//DB1 - 9
//DB2 - 10
//DB3 - 11
//DB4 - 4
//DB5 - 13
//DB6 - 6
//DB7 - 7

// Atribua nomes legíveis a alguns valores de cores comuns de 16 bits:
#define PRETO 0x0000
#define AZUL 0x001F
#define VERMELHO 0xF800
#define VERDE 0x07E0
#define CIANO 0x07FF
#define MAGENTA 0xF81F
#define AMARELO 0xFFE0
#define BRANCO 0xFFFF
#define CINZA 0x8C51
#define GREYD 0x39E7

//Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);
// Se estiver usando o escudo, todas as linhas de controle e dados são fixas, e
// uma declaração mais simples pode ser usada opcionalmente:
//Adafruit_TFTLCDtft;
uint16_t g_identifier;

String dadosString;
//String numfileMês = "1.txt";
char perv [] = {"2.txt"};
//String *numfileMonth="1.txt" (sizeof (numfileMonth));
////////////////////////////////////////////////////// ///////////////////

void setup (void) {

rtc.begin();

// Para definir a hora, remova o comentário das linhas necessárias
//rtc.setDOW(6); // Dia da semana
//rtc.setTime(22, 04, 0); //Hora, no formato de 24 horas.
//rtc.setDate(4, 5, 2019); // Data, 29 de outubro de 2018

Serial.begin (2000000);
//////// Inicialização da tela
tft.begin(0x65);
tft.reset();
tft.setRotation(0);
tft.cp437(verdadeiro);
/////////////////Saída de nomes, acessórios de equipamentos, nome da organização
tft.fillScreen(PRETO);
tft.setTextColor(BRANCO);
tft.setTextSize(2);
tft.setCursor(8, 0);
tft.println("DESENVOLVEDORES E CONSTRUÇÃO");
tft.setCursor(30, 20);
tft.print (utf8rus("Construtor V.V." ));
tft.setCursor(40, 40);
tft.print (utf8rus("Turner I.I." ));
atraso (2000);

radio.begin(); // Inicia o trabalho nRF24L01+
radio.setChannel(120); // Especifique o canal de recepção de dados (de 0 a 127)
radio.setDataRate(RF24_250KBPS); // Especifique a taxa de transferência de dados (RF24_250KBPS, RF24_1MBPS, RF24_2MBPS), RF24_1MBPS - 1Mbit/s
radio.setPALevel(RF24_PA_MAX); // Especifique a potência do transmissor (RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_HIGH=-6dBm, RF24_PA_MAX=0dBm)
radio.openReadingPipe(1, 0xAABBCCDD11LL); //Abre 1 pipe com o identificador de 1 transmissor 0xAABBCCDD11, para receber dados
//Abre o pipe 2 com ID do transmissor 2xAABBCCDD0 para receber dados
radio.startListening(); //Ligue o receptor, comece a ouvir canos abertos
// radio.stopListening();
////////Saída de informações de serviço
tft.fillScreen(PRETO);
tft.setCursor(8, 0);
tft.setTextSize(1);
////////Iniciar inicialização do cartão SD
Serial.println("Cartão SD inicial");
tft.println("Cartão SD inicial");
tft.setCursor(8, 10);
////////Inicializando o cartão
se (!SD.begin(SD_CS_PIN)) {
Serial.println("falha inicial!");
tft.fillRect(8, 10, 85, 7, VERMELHO);
tft.setTextColor(PRETO);
tft.println("Falha inicial!");
voltar;
}
tft.setTextColor(BRANCO);
Serial.println("inicialização concluída");
tft.println("Inicialização concluída");
atraso (2000);
////////Lendo hora e data e atribuindo-as a variáveis
t = rtc.getTime();
tempo_sec_prev = t.sec;
hora_dia_prev = t.data;
////////Exibir a data à força para não esperar que a data mude para exibição
tft.setCursor(180, 0); //definindo a posição do cursor
tft.fillRect(178, 0, 65, 7, CINZA); //limpando a área de saída de tempo
tft.setTextSize(1);
tft.print(rtc.getDateStr());
////////Saída do nome dos objetos de controle
tft.setTextSize(2);
tft.setCursor(60, 25);
tft.println (utf8rus("Guinchos I"));
////////Criando um arquivo de log e exibindo o resultado da tentativa de criação
tft.setTextSize(1);
tft.setCursor(130, 10); // se o arquivo de log 2.txt for criado, a gravação no arquivo continuará
if (SD.exists(perv)) {
//tft.setCursor(0, 90);
tft.println(pervertido);
Serial.println(perv);
Else {}
meuArquivo = SD.open(perv, FILE_WRITE); // se o arquivo 2.txt não existir, ele será criado
meuArquivo.close();
tft.println(pervertido);
Serial.println(perv);
}
}

void loop (void) {
////////Verificando a existência de uma solicitação para enviar um log para o monitor da porta COM
if (Serial.available() > 0) {
if (1 == Serial.read());
////////E se “1” for aceito, então a saída
Arquivo meuArquivo = SD.open(perv);
// se o arquivo estiver disponível, escreva nele:
if (meuArquivo) {
while (meuArquivo.disponível()) {
Serial.write(meuArquivo.read());
}
meuArquivo.close();
}
else {
Serial.println("erro ao abrir .txt");
}
}
////////Tempo de leitura
t = rtc.getTime();
tft.setTextColor(BRANCO);
////////Se a hora mudou, então exibe as novas leituras do relógio
if (time_sec_prev! = t.sec) {
tft.setCursor(120, 0); //definindo a posição do cursor
tft.fillRect(118, 0, 50, 7, CINZA); //limpando a área de saída de tempo
tft.setTextSize(1);
tft.print(rtc.getTimeStr()); // gera leituras de clock
tempo_sec_prev = t.sec;
}
////////Se a data mudou, então exibe a nova data
if (hora_dia_prev! = t.data) {
tft.setCursor(180, 0); //definindo a posição do cursor
tft.fillRect(178, 0, 65, 7, CINZA); //limpa a área de exibição da data
tft.setTextSize(1);
tft.print(rtc.getDateStr()); // exibe leituras de data
hora_dia_prev = t.data;
}
////////Se a recepção de rádio estiver disponível, então
if (radio.available(&pipe)) {
////////verificando se o buffer de recebimento está cheio,
radio.read(&dados, sizeof(dados));
////////se o endereço do transmissor necessário estiver disponível, então
if (tubo == 1) {
////////aguardando uma sequência sincronizada de zeros para determinar
//início do bloco de dados
se (dados == 0000) {
rc = 0;
Else {}
rc++;
}
////////Gravando valores do contador e calculando-os em 10 e 100 de hora
se (rc == 1) {
leb_1 = dados / 3600.0;
}

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

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

se (rc == 4) {
leb_4 = dados / 3600.0;
}
}
}
r++;
k++; // apenas um contador
//////// Atualização de dados com certa periodicidade
se ( r >= 6500) {
tft.setTextSize(2);
tft.fillRect(0, 41, 180, 64, CINZA);
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;
}
////////Grava dados no log no SD a cada 10 minutos.
if ((t.min % 10 == 0) && ( t.sec == 0)) {
tft.setTextSize(1);
tft.setCursor(200, 10);
tft.setTextColor(PRETO);
////////Criando uma string no formato .csv
String dataString = String (rtc.getDateStr()) + ", "+(rtc.getTimeStr()) + ", " + (leb_1) + ", " + (leb_2)
+ ", " + (leb_3) + ", " + (leb_4) + ", ";
////////Grave em um arquivo e produza os resultados do processo de escrita
meuArquivo = SD.open(perv, FILE_WRITE); // se não houver nenhum arquivo chamado “2.txt”, ele será criado.
if (meuArquivo) {
meuArquivo.println(dataString);
meuArquivo.close();
tft.fillRect(198, 8, 42, 10, VERDE);
tft.println("SD OK");
Serial.println("SD OK");
atraso(900); //atraso, caso contrário registra 13 leituras idênticas até que um segundo tenha passado
Else {}
tft.fillRect(198, 8, 42, 10, VERMELHO);
tft.println("ERRO SD");
Serial.println("ERRO SD");
}
}
}Programa de conversão de caracteres/* Recodifica fontes russas de UTF-8 para Windows-1251 */

String utf8rus (fonte da string)
{
int eu,k;
Alvo de string;
caractere não assinado n;
char m[2] = { '0', ' ' };

k = fonte.comprimento(); eu = 0;

enquanto (eu <k) {
n = fonte[i]; eu++;

se (n >= 0xC0) {
mudar (n) {
caso 0xD0: {
n = fonte[i]; eu++;
se (n == 0x81) { n = 0xA8; quebrar; }
se (n >= 0x90 && n <= 0xBF) n = n + 0x30;//0x2F
break;
}
caso 0xD1: {
n = fonte[i]; eu++;
se (n == 0x91) { n = 0xB8; quebrar; }
se (n >= 0x80 && n <= 0x8F) n = n + 0x70;//0x6F
break;
}
}
}
m[0] =n; alvo = alvo + String(m);
}
alvo de retorno;
}O programa de transcodificação de caracteres para saída cirílica usando a biblioteca Adafruit_GFX é colocado na mesma pasta do programa principal. Você também precisa substituir o arquivo glcdfont.c em Adafruit_GFX por uma fonte diferente. é biblioteca com a substituição necessária. Mais informações sobre a russificação podem ser facilmente encontradas na Internet.
Resumindo, direi que o sistema correspondeu às expectativas, ficou mais fácil monitorar o tempo de funcionamento dos equipamentos. Embora tudo seja montado em protoboards, não há reclamações imediatas sobre a obra. Os primeiros elementos estão funcionando há mais de seis meses e sobreviveram ao inverno. Projeto mais recente Está funcionando em 9 unidades controladas desde 5 de março e o tempo de operação está sendo registrado oficialmente por meio dele.

Fonte: habr.com