Inicialmente, o termostato era feito simplesmente como um termômetro para controlar a temperatura fora da janela. Então, durante as geadas, as batatas começaram a congelar no subsolo e a funcionalidade foi adicionada para controlar o microclima. Dados de passaporte do relé de comutação - 250V e 10A (2,5kW). Como o calor no subsolo não é necessário, dez por quilowatt é suficiente.
Materiais e ferramentas necessários:caixa de sapatos
-USB-cobrando pelo telefone (qualquer, pelo menos 0,7A)
-
Arduino-Pro-Mini
Visor de -2 linhas e 8 caracteres (WH0802A-NGA-CT é mais compacto)
Codificador com um botão (pode ser comprado em qualquer revista de rádio, o botão não pode ser incorporado)
- criança com um relé de 5V (eu comprei vários relés chineses sem isolamento óptico de uma só vez, então precisava de outro Optocoupler PC817 e um resistor de 470 Ohm. Se você tiver isolamento óptico na placa de identificação, poderá conectar a placa de identificação diretamente à porta do arduino)
Conector USB
-2 Cabo de extensão USB de 3 metros (um para o cabo de alimentação e o segundo para soldar o DS1820)
- DS1820 (com qualquer letra)
ferro de solda
pistola de cola
Placa de identificação FTDI232
Etapa 1: Primeiro, precisamos fazer o flash do arduino, porque eu tenho um Pro Mini (ele não precisa de um conversor USB-RS232), preciso soldar uma régua com pinos no arduino. Do lado em que derivam DTR, TXD, RXD, VCC, GND, GND. Agora, conectamos o FTDI232 DTR ao DTR, o VCC ao VCC, o GND ao GND, o TXD ao RXD, o RXD ao TXD. Execute o IDE do arduino, faça o download do esboço e faça o flash (esboço no final).
Etapa 2: Agora vamos cuidar do casco. Arrancamos a esponja no “FUKS”, desengorduramos tudo bem, a parte mais profunda da caixa pode ser passada com um pano de esmeril (algo ficaria mais firmemente preso). Marque o orifício para o codificador, o conector USB (mãe) e o próprio monitor. Cole o relé na tampa da caixa. Devemos tentar colocar o relé mais distante do processador e organizar os componentes para que a tampa feche mais tarde (há muito espaço).
Etapa 3: Agora pegamos o cabo de extensão USB, cortamos o soquete do conector (mãe). Cortamos a ponta cortada, fazemos um orifício para o cabo no corpo, inserimos e cola a chave com uma pistola. Além disso, o cabo tem vermelho, menos preto (basta verificá-lo), mais o sinal de mais, menos o sinal de menos (não dou a pinagem do conector - está na Internet). Entre o sinal de mais do conector e o meio 2 (eu os tenho conectados), um resistor de 4.7kOhm deve ser soldado.
Etapa 4: Pegamos 2 cabos de extensão USB, cortamos o conector (mãe), cortamos o cabo. Por precaução, verificaremos se todos estamos soldados corretamente. Conectamos o cabo de alimentação com o carregamento USB e à rede, prendemos o cabo cortado no conector USB, olhamos o testador + em vermelho - em preto. Retiramos o cabo e soldamos o DS1820: - para 1, + para 3 os 2 fios restantes para 2. Em seguida, revesti o composto epóxi (para reparar os tanques, radiadores), deixando um pouco da caixa do sensor para fora, para que houvesse uma reação mais rápida às mudanças de temperatura.Bem, fazemos a instalação de acordo com o diagrama do circuito (conectamos a potência e o terra da placa de relé aos circuitos + e - comuns, respectivamente).
Etapa 5: Todos os componentes do circuito estão conectados. Conectamos nosso sensor (sem ele, a tela permanecerá preta), aplique energia. Na primeira linha - o valor da temperatura, em 2 se “*” estiver ligado - o relé está ligado, não está desligado. Agora vamos tentar definir os limites de comutação do relé. Pressione o eixo do codificador (ou o seu botão), o valor limite aparece no qual o relé liga girando o eixo - o valor aumenta ou diminui. Ao clicar no eixo novamente - obtemos o limite superior (o relé será desligado), defina o valor e pressione novamente. O dispositivo monitorará a temperatura, o valor dos limites será mantido quando a energia for desligada. Só isso.
#include
#include
#include
#define BUTTON_1_PIN 10 // o número de saída do botão 1 é 12
OneWire ds (12); // no pino 10 (é necessário um resistor de 4,7 K)
// inicializa a biblioteca com os números dos pinos da interface
LCD de cristal líquido (3, 2, 4, 5, 6, 7);
currentTime longo não assinado;
const int pin_A = 8; // pino 12
const int pin_B = 9; // pino 11
char não assinado enc_A;
char não assinado enc_B;
char não assinado enc_A_prev = 0;
float n_pr = 24,1;
float b_pr = 26,2;
preço booleano = false;
botão de classe {
público:
Botão (byte pin, byte timeButton); // descrição do construtor
flagPress booleano; // o botão flag está pressionado
flag booleanoClick; // botão de sinalização foi pressionado (clique)
void scanState (); // método para verificar o estado do sinal
void setPinTime (byte pin, byte timeButton); // método para definir o número de saída e o tempo de confirmação (número)
privado:
byte _buttonCount; // contador de confirmação de estado estável
byte _timeButton; // hora de confirmação do estado do botão
byte _pin; // número do pino
};
Botão button1 (BUTTON_1_PIN, 30);
void knopka () {
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (n_pr);
// button1.scanState ();
while (button1.flagClick == false) {
enc_A = leitura digital (pin_A);
enc_B = leitura digital (pin_B);
if ((! enc_A) && (enc_A_prev)) {
if (enc_B) {
n_pr = n_pr-0,1;
} mais {
n_pr = n_pr + 0,1;
}
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (n_pr);
}
enc_A_prev = enc_A;
button1.scanState ();
}
button1.flagClick = false;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (b_pr);
while (button1.flagClick == false) {
enc_A = leitura digital (pin_A);
enc_B = leitura digital (pin_B);
if ((! enc_A) && (enc_A_prev)) {
if (enc_B) {
b_pr = b_pr-0,1;
} mais {
b_pr = b_pr + 0,1;
}
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (b_pr);
}
enc_A_prev = enc_A;
button1.scanState ();
}
button1.flagClick = false;
if (n_pr> b_pr) {
float wr = n_pr;
n_pr = b_pr;
b_pr = wr;
}
int addr = 0;
EEPROM.write (endereço, 'y');
addr = 1;
EEPROM.put (endereço, n_pr);
addr + = sizeof (float);
EEPROM.put (endereço, b_pr);
atraso (300);
}
configuração nula (nula) {
pinMode (11, SAÍDA);
pinMode (pin_A, INPUT_PULLUP);
pinMode (pin_B, INPUT_PULLUP);
lcd.begin (8.2);
int addr = 0;
char c = EEPROM.read (endereço);
endereço = endereço + 1;
if (c == 'y') {
EEPROM.get (endereço, n_pr);
addr + = sizeof (float);
EEPROM.get (endereço, b_pr);
}
// Serial.begin (9600);
}
loop vazio (vazio) {
byte i;
byte presente = 0;
byte type_s;
dados de bytes [12];
byte addr [8];
float celsius;
if (! ds.search (addr)) {
ds.reset_search ();
atraso (250);
retornar
}
if (OneWire :: crc8 (endereço, 7)! = endereço [7]) {
retornar
}
// o primeiro byte da ROM indica qual chip
switch (endereço [0]) {
caso 0x10:
type_s = 1;
quebrar;
caso 0x28:
type_s = 0;
quebrar;
caso 0x22:
type_s = 0;
quebrar;
padrão:
retornar
}
ds.reset ();
ds.select (endereço);
ds.write (0x44, 1); // inicia a conversão, com o parasita ligado no final
enc_A = leitura digital (pin_A);
enc_A_prev = enc_A;
currentTime = millis ();
while ((millis () - currentTime) <2000) {
button1.scanState ();
if (button1.flagClick == true) {
// houve um clique no botão
button1.flagClick = false; // redefinir atributo de clique
knopka ();
}
}
// delay (1000); // talvez 750ms seja suficiente, talvez não
// podemos fazer um ds.depower () aqui, mas a redefinição cuidará disso.
presente = ds.reset ();
ds.select (endereço);
ds.write (0xBE); // Ler Scratchpad
para (i = 0; i <9; i ++) {// precisamos de 9 bytes
dados [i] = ds.read ();
}
// Converte os dados para a temperatura real
// porque o resultado é um número inteiro assinado de 16 bits, ele deve
// ser armazenado em um tipo "int16_t", que é sempre 16 bits
// mesmo quando compilado em um processador de 32 bits.
int16_t bruto = (dados [1] << 8) | dados [0];
if (type_s) {
bruto = bruto << 3; // padrão de resolução de 9 bits
if (dados [7] == 0x10) {
// "contagem restante" fornece resolução total de 12 bits
bruto = (bruto & 0xFFF0) + 12 - dados [6];
}
} mais {
byte cfg = (dados [4] & 0x60);
// em baixa resolução, os bits baixos são indefinidos, então vamos zerá-los
if (cfg == 0x00) bruto = bruto & ~ 7; // resolução de 9 bits, 93,75 ms
caso contrário, se (cfg == 0x20) raw = raw & ~ 3; // resolução de 10 bits, 187,5 ms
caso contrário, se (cfg == 0x40) raw = raw & ~ 1; // resolução de 11 bits, 375 ms
//// o padrão é resolução de 12 bits, tempo de conversão de 750 ms
}
celsius = (flutuante) bruto / 16,0;
lcd.clear ();
lcd.setCursor (1,0);
lcd.print (celsius);
if (priz) {
lcd.setCursor (0,1);
lcd.print ('*');
}
if (n_pr! = b_pr) {
if (celsius b_pr) {
digitalWrite (11, BAIXO);
priz = false;
}
}
}
// método de verificação do estado do botão
// flagPress = true - clicado
// flagPress = false - pressionado
// flagClick = true - foi clicado (clique)
Botão vazio :: scanState () {
if (flagPress == (! digitalRead (_pin))) {
// estado do sinal permanece o mesmo
_buttonCount = 0; // redefine o contador de status do sinal
}
mais {
// estado do sinal mudou
_buttonCount ++; // +1 no contador de estado do sinal
if (_buttonCount> = _timeButton) {
// estado do sinal não mudou o tempo especificado
// estado do sinal tornou-se estável
flagPress =! flagPress; // inverso do indicador de status
_buttonCount = 0; // redefine o contador de status do sinal
if (flagPress == true) flagClick = true; // sinal de clique no clique
}
}
}
// método para definir o número de saída e o tempo de confirmação
void Button :: setPinTime (byte pin, byte timeButton) {
_pin = pino;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // define a saída como entrada
}
// descrição do construtor da classe Button
Button :: Button (pino de byte, timeButton de byte) {
_pin = pino;
_timeButton = timeButton;
pinMode (_pin, INPUT_PULLUP); // define a saída como entrada
}
