/ *
************************************************** **************
* Medidor de
potência
e SWR no visor LCD de 2x16 caracteres * * Por ON7EQ, agosto de 2011 * ******************* *******************************************
O circuito:
* pino RS LCD no pino digital 7 * pino LCD ativado no pino digital 8 * pino D4 no pino digital 9 * pino D5 no pino digital 10 * pino D5 no pino digital 11 * pino D6 no pino digital 11 * pino D7 no pino digital 12 * Pino R / W do LCD no chão * GND no pino VO do LCD (pino 3) (contraste) * pino 13 = controle da luz de fundo do LCD (1 = luz de fundo ligada). Use um seguidor de emissor (como BC639) para controlar a luz de fundo do LCD (isso atrai cerca de 120mA)
* pino 4 = conecte uma campainha piezo (outra extremidade ao terra)
* pino A0: entrada de tensão FWD da sonda SWR (tipo de ponte SWR 'MONIMATCH')
* pino A1: entrada de tensão REFL da sonda SWR
! Defina a tensão de avanço do diodo na variável 'Diode'. Para 1SS99 ou outros diodos Schottky, é de cerca de 130mV a 0,1mA
* pino A5: Entrada de tensão da fonte de alimentação
MODE SELECT: existem 2 possibilidades para selecionar o modo:
--------------------------------------- -----------------
1 ° com interruptor de 3 posições:
* pin Digital 2: interruptor de som 'bip': quando aterrado -> modo de tom SWR 'bip'
* pin digital 3: modo de PEP Switch: quando aterrado -> modo PEP
Quando o comutador está na posição central: modo normal de energia / swr, energia instantânea e leitura de dBm
Ao usar um comutador central, o pino 5 deve ser conectado a + 5v
Se um comutador de três vias estiver presente, ele será automaticamente detectado e a variável 'PushButton' definido de acordo.
2 ° com botão para modos de cilindros:
* pin Digital 5: Botão de modo: quando aterrado (pulso), o próximo modo é selecionado
Ao usar um botão, os pinos 2 e 3 devem estar conectados a + 5v!
! o modo é armazenado na EEPROM e memorizado para a próxima inicialização
SELEÇÃO DE BANDA:
-------------
Pode ser necessário aplicar diferentes parâmetros / fatores de calibração por banda.
* alfinete Digital 6: BAND: quando aterrado (pulso), a próxima banda é selecionada
! a banda é armazenada na EEPROM e memorizada para a próxima inicialização
* /
// inclua o código da biblioteca do LCD:
#include < LiquidCrystal .h>
// inclui funções matemáticas
#include "math.h"
// inclui gravação na EEPROM
#include < EEPROM .h>
// variáveis
#define TonePin (4) // Pin para o sinal sonoro
#define ToneSwitch (2) // uma extremidade do interruptor de alavanca de 3 vias
#define PEPswitch (3) // a outra extremidade do interruptor de alavanca de 3 direções
#define ModeSwitch (5) // interruptor de botão de pressão (sem interruptor de 3 vias)
#define BANDSwitch (6) // mudança de banda do botão de botão
#define LCDbacklight (13) // saída para alimentar a luz de fundo do LCD
#define VoltSupplyMini (66) // tensão mínima da bateria expressa em 100mV (se for menor, o alarme é gerado)
// // para µ7805, é necessário no mínimo 7v
// divisor de tensão em A5 - selecione os valores adequados para que a tensão nunca exceda 5v em A5!
// Com R1 = 1k2 e R2 = 4k7, tensão máxima de entrada = 25v
#define R1 (12) // de GND para A5, expresso em 100R (12 = 1200 Ohm)
#define R2 (47) // de + fonte de alimentação para A5, expresso em 100R (47 = 4700 Ohm)
// variáveis de calibração para potência direta:
// PowCal = (VoltFWD² / Potência) / 1000 (onde Potência = potência acima de 50 Ohm em Watt)
// Realize a calibração com potência suficiente!
#define PowCalHF (100) // band HF
#define PowCal6m (21) // 6m band
#define PowCal4m (30) // 4m band -> pmax @ 5000mV = 833 W (como exemplo)
#define PowCal2m (117) / / 2m band
#define PowCal70 (57) // 70cm band
#define PowCal23 (3165) // 23cm band
#define PowCal13 (64800) // 13cm band
char * myStrings [] = { "HF" , "6m" , "4m" , "2m" , "70cm" , "23cm" , "13cm" };
///////////////////////// 3 way-mode switch or pushbutton? /////////////////////////////////////
int PushButton = (1); // 1 = Botão / 0 = interruptor
// existe uma detecção automática na sub-rotina de exibição
//////////////////////////////////////////////////// //////////////////////////////////////////
// mode
byte PEP = (1); // 0 se PEP medido
byte Tom = (1); // 0 se sintonizar SWR de tom (bip)
byte MODE = (0); // Modo 0 = energia instantânea / Modo 1 = PEP / Modo 2 = Bip
byte BAND = (0); // FAIXA 0 = HF / 1 = 6m / 2 = 4m / 3 = 2m / 4 = 70cm / 5 = 23cm / 6 = 13cm
longo não assinado DisplayTime = 0; // atualização da exibição do temporizador
sem sinal longo PeakTime = 0; // o pico do timer (PEP) detecta um
sinal longo não assinado BacklightTime = 0; // tempo de espera do LCD da luz de fundo
sem sinal longo BandTime = 0; // tempo de espera da exibição da banda
flutuar VoltFWD = 0;
flutuador VoltFWDmax = 0;
float VoltPEP = 0;
flutuar VoltREF = 0;
não assinado int Diode = 130; // tensão direta do diodo, expressa em mV
não assinado int PowCal = 103; // fator de calibração para potência: PowCal = (VoltFWD² / Potência) * 1000
PWR longo não assinado = 0; // potência (expressa em 100 mW) não assinada int PowDis = 0; // potência do flutuador de exibição SWR = 0; // SWR float Vratio = 0; // Relação de voltagem VoltREF / VoltFWD
int SWRDis = 0; // cálculo de potência para exibição no display
int VoltFWDmini = 0;
PWRmax longo não assinado = 0; // a faixa de potência máxima, dependente da banda
int beeponce = (0); // emite apenas 1 sinal sonoro para alteração de modificação
int beepband = (0); // emite apenas 1 bipe para troca de banda
int SWRtonePitch = (800); // baixo solitário = baixo SWR
int SWRtoneLenght = (100); // tom longo = baixo SWR
int depurado = (0); // LED no pin13 = debug
int decay = (0); // Taxa de deterioração do PEP
unsigned int SupplyVoltage = (0); // Tensão da fonte de alimentação
byte RunOnce = (1); // detecta se no modo SETUP ou LOOP
byte DisplayCycle = (0); // conta os ciclos no modo de exibição (para alerta de baixa voltagem)
// inicializa a biblioteca com os números dos pinos da interface
LiquidCrystal lcd (7, 8, 9, 10, 11, 12);
// ************************************************** *************
// ******************** CONFIGURAÇÃO ************** **********
// **************************************** ***********************
configuração nula () {
// pinos de configuração
pinMode (LCDbacklight, OUTPUT ); // Luz de fundo da tela LCD
pinMode (PEPswitch, INPUT ); // se aterrado -> modo 'PEP'
pinMode (ToneSwitch, INPUT ); // se aterrado -> modo 'Bip'
pinMode (ModeSwitch, INPUT ); // se aterrado ->
alterna entre os modos pinMode (BANDSwitch, INPUT ); // se aterrado -> alterna entre faixas
// configura o número de colunas e linhas do
LCD : lcd. começar (16, 2);
// Modo READ da EEPROM e ajuste os parâmetros
MODE = EEPROM . leia (1);
if (MODE == 0) { // energia instantânea normal e SWR
Tom = 1;
PEP = 1; }
if (MODE == 1) { // SWR de sintonia de tons
Tom = 1;
PEP = 0; }
if (MODE == 2) { // energia PEP
Tom = 0;
PEP = 1; }
// LEIA a banda da EEPROM
BAND = EEPROM . leia (2);
if (BAND == 0) {
BANDA = 3; // Sem HF por enquanto, padrão = 2m
PowCal = PowCalHF;}
if (BAND == 1) {
PowCal = PowCal6m;}
if (BAND == 2) {
PowCal = PowCal4m;}
if (BAND == 3) {
PowCal = PowCal2m;}
if (BAND == 4) {
PowCal = PowCal70;}
if (BAND == 5) {
PowCal = PowCal23;}
if (BAND == 6) {
PowCal = PowCal13;}
// calcula o alcance máximo dessa banda
PWRmáx duplo = pow ((5000 + diodo), 2);
PWRmax = PWRmax / PowCal / 1000;
// calcula a potência mínima para o limiar de indicação 'SWR <1,5'
// SWR = 1,5 significa PWRref / PWRFwd = 0,2
// isso significa que VoltFWD = tensão do diodo / SQRT (0,2)
// para o limiar SWR = 3: substitua 0,45 por SQRT (0,5) = 0,71
VoltFWDmini = (diodo / 0,45);
VoltFWDmini = 2 * VoltFWDmini; // fator de segurança, exigido na prática
// Imprima uma mensagem no LCD.
digitalWrite (LCDbacklight, 1); // liga a luz de fundo no
lcd. setCursor (0, 0);
LCD. print ( "Medidor de Pwr e SWR" );
LCD. setCursor (0, 1);
LCD. impressão ( "6m - 13cm" );
pinMode (TonePin, OUTPUT );
tom (TonePin, 1200);
atraso (150);
tom (TonePin, 1600);
atraso (150);
tom (TonePin, 2000);
atraso (150);
noTone (TonePin);
atraso (2000);
// lcd.setCursor (0, 1);
// lcd.print ("por ON7EQ 08/2011");
// delay (2000);
// Fonte de alimentaçãoMedição e exibição de tensão
measureupplyvolt ();
atraso (1500);
// imprime potência máxima
lcd. claro ();
LCD. setCursor (2, 0);
LCD. print ( "QRV ativado" );
LCD. print (myStrings [BAND]);
clearline1 ();
LCD. setCursor (2, 1);
LCD. print ( "Pmax =" );
// se> 1kw, 1kW é suficiente: o)
if (PWRmax> = 1000) {
LCD. impressão ( "1 kW" ); }
mais {
if (PWRmax <1) {
PowDis = PWRmax * 1000;
if (PowDis> 100) { // arredonda PowDis até dez
PowDis = PowDis / 10;
PowDis = PowDis * 10;
}
// if (PowDis <100) {
// lcd.print (""));
//}
// if (PowDis <10) {
// lcd.print ("");
//}
lcd. print ((PowDis), DEC );
LCD. impressão ( "mW" );
}
mais {
PowDis = PWRmax;
// formato PowDis
if (PowDis> 100) { // arredonda PowDis até dez
PowDis = PowDis / 10;
PowDis = PowDis * 10;
}
// if (PowDis <100) {
// lcd.print (""));
//}
// if (PowDis <10) {
// lcd.print ("");
//}
lcd. print ((PowDis), DEC );
LCD. print ( "w" );
}
}
atraso (4000);
LCD. claro ();
// define os temporizadores DisplayTime
= millis ();
BacklightTime = millis ();
} // fim da configuração
// ************************************************** *************
// *********************** LOOP *********** *************
// *********************************** **************************
loop vazio () {
RunOnce = 0; // Agora estamos em loop
// Verifique se o modo a ser ciclado
if ( digitalRead (ModeSwitch) == 0) { // Botão do ciclo do modo pressionado
digitalWrite (LCDbacklight, 1); // ativa a luz de fundo em
BacklightTime = millis (); // redefine o timer para acender o LCD
if (beeponce == 0) {
tone (TonePin, 1750);
atraso (100);
tom (TonePin, 1000);
beeponce = 1;
atraso (20);
}
atraso (50); // dá o tom e
renuncia ao noTone (TonePin);
if ( digitalRead (ModeSwitch) == 1) { // liberado
beeponce = 0;
MODO = MODO + 1;
if (MODO> = 3) MODO = 0;
EEPROM . escrever (1, MODO); // armazena o novo modo permanentemente
if (MODE == 0) { // energia instantânea normal e SWR
Tom = 1;
PEP = 1; }
if (MODE == 1) { // SWR de sintonia de tons
Tom = 1;
PEP = 0; }
if (MODE == 2) { // energia PEP
Tom = 0;
PEP = 1;
VoltFWDmáx = (0);
PeakTime = millis (); }
}
}
// Verifique se a banda deve ser ciclada
if ( digitalRead (BANDSwitch) == 0) { // botão do ciclo da BAND pressionado
digitalWrite (LCDbacklight, 1); // ativa a luz de fundo em
BacklightTime = millis (); // redefine o temporizador para acender o LCD
if (beepband == 0) {
tone (TonePin, 1200);
atraso (100);
tom (TonePin, 1600);
atraso (100);
tom (TonePin, 2000);
beepband = 1;
atraso (50);
}
atraso (50); // dá o tom e
renuncia ao noTone (TonePin);
if ( digitalRead (BANDSwitch) == 1) { // lançado
beepband = 0;
BANDA = BANDA + 1;
if (BAND> = 7) BAND = 1; // defina 0 se HF estiver ativado!
EEPROM . escrever (2, BAND); // armazena o novo modo permanentemente
if (BAND == 0) { // define constantes de calibração adequadas
PowCal = PowCalHF;}
if (BAND == 1) {
PowCal = PowCal6m;}
if (BAND == 2) {
PowCal = PowCal4m;}
if (BAND == 3) {
PowCal = PowCal2m;}
if (BAND == 4) {
PowCal = PowCal70;}
if (BAND == 5) {
PowCal = PowCal23;}
if (BAND == 6) {
PowCal = PowCal13;}
// mostra banda
lcd. setCursor (11, 1);
LCD. print (myStrings [BAND]);
// mostra Pmax para esta banda
clearline0 ();
LCD. setCursor (0, 0);
LCD. print ( "Pmax =" );
// calcula o alcance máximo dessa banda
PWRmáx duplo = pow ((5000 + diodo), 2);
PWRmax = PWRmax / PowCal / 1000;
// se> 1kw, 1kW é suficiente: o)
if (PWRmax> = 1000) {
LCD. impressão ( "1 kW" ); }
mais {
if (PWRmax <1) {
PowDis = PWRmax * 1000;
if (PowDis> 100) { // arredonda PowDis até dez
PowDis = PowDis / 10;
PowDis = PowDis * 10;
}
// if (PowDis <100) {
// lcd.print (""));
//}
// if (PowDis <10) {
// lcd.print ("");
//}
lcd. print ((PowDis), DEC );
LCD. impressão ( "mW" );
}
mais {
PowDis = PWRmax;
// formato PowDis
if (PowDis> 100) { // arredonda PowDis até dez
PowDis = PowDis / 10;
PowDis = PowDis * 10;
}
// if (PowDis <100) {
// lcd.print (""));
//}
// if (PowDis <10) {
// lcd.print ("");
//}
lcd. print ((PowDis), DEC );
LCD. print ( "w" );
}
}
BandTime = millis (); // redefine o timer de exibição para a exibição de troca de banda
// delay (1000);
}
}
// ler sensores
if (PushButton == 0) { // Interruptor de 3 vias
Tone = digitalRead (ToneSwitch); // lê o botão de tom
PEP = digitalRead (PEPswitch); // leia o botão PEP
}
VoltFWD = leitura analógica (A0); // Leia a tensão do sensor FWD
VoltREF = analogRead (A1); // Leia a tensão do sensor REFL
// detecção de PEP
if (VoltFWD> VoltFWDmax) {
VoltFWDmax = VoltFWD;
PeakTime = millis ();
decaimento = 1;
}
// decair
caso contrário, if (( millis () - PeakTime)> 400) { // 400 = PEP Peak hold time
VoltFWDmax = VoltFWDmax / (decaimento + 0,3);
PeakTime = millis ();
decaimento = decaimento + 1; //decair
}
// Atualização do LCD se não houver modo de tom
if ((( millis () - DisplayTime)> 200) e (Tone == 1)) { // 200 = taxa de atualização da exibição no modo PEP e dBm DisplayTime
= millis ();
refreshdisplay ();
}
if (Tom == 0) { // no modo de tom, atualização acionada pelo tom
decaimento = 0;
refreshdisplay ();
}
}
// ================================================== =========
// ************ Atualize a tela do LCD Rotina ****************
// ===== ==================================================== ==
void refreshdisplay () {
// verifique se a bateria está fraca
DisplayCycle = DisplayCycle ++;
if (DisplayCycle> = 50) { // a cada 50 ciclos de exibição, verifique a voltagem da bateria
DisplayCycle = (0);
measureupplyvolt ();
}
// verifica se a banda muda e o display mantém
if ((( millis () - BandTime) <3000)) retorna ; // mostra parâmetros de mudança de banda
// Verifique se a chave seletora para o modo está presente, o padrão é o botão de pressão
if (( digitalRead (ToneSwitch) == 0) ou digitalRead (PEPswitch) == 0) {
Botão de pressão = (0); // a chave seletora está presente
}
// Retroiluminação do LCD
if (VoltFWD> 0) {
digitalWrite (LCDbacklight, 1); // ativa a luz de fundo em
BacklightTime = millis (); //Definir temporizador
}
caso contrário, if ((( millis () - BacklightTime)> 8000)) { // 8 segundos luz de fundo
digitalWrite (LCDbacklight, 0); // desligar a luz de fundo
}
// Detecção de overrange
if ((VoltFWD> 1022) e ( digitalRead (ModeSwitch) == 1)) {
LCD. claro ();
LCD.setCursor (1, 0);
LCD. print ( "- Overrange -" );
LCD.setCursor (2, 1);
LCD. print ( "Pmax =" );
// calcula o alcance máximo dessa banda
em dobroPWRmáx = pow ((5000 + diodo), 2);
PWRmax = PWRmax / PowCal / 1000;
// se P> 1kw, 1kW é suficiente: o)
if (PWRmax> = 1000) {
LCD. impressão ( "1 kW" ); }
mais {
if (PWRmax <1) { // Estamos medindo miliwatts
PowDis = PWRmax * 1000;
if (PowDis> 100) { // arredonda PowDis até dez
PowDis = PowDis / 10;
PowDis = PowDis * 10;
}
E se (PowDis <100) {
LCD. print ("" );
}
E se (PowDis <10) {
LCD. print ("" );
}
LCD. print ((PowDis), DEC );
LCD. impressão ( "mW" );
}
mais {
PowDis = PWRmax; // Estamos medindo watts
// formato PowDis
if (PowDis> 100) { // arredonda PowDis até dez
PowDis = PowDis / 10;
PowDis = PowDis * 10;
}
if (PowDis <100) {
LCD. print ( "" );
}
E se (PowDis <10) {
LCD. imprimir ( "" );
}
LCD. print ((PowDis), DEC );
LCD. print ( "w" );
}
}
tom (TonePin, 2500);
atraso (200);
noTone (TonePin);
if ( digitalRead (ModeSwitch) == 1) delay (2000);
LCD. claro ();
retorno ;
}
// tensão do processo FWD
VoltFWD = mapa (VoltFWD, 0,1023,0,5000);
VoltFWD = (VoltFWD + diodo); // corrige a queda de tensão do diodo
// processo REF
VoltREF = mapa (VoltREF, 0,1023,0,5000);
VoltREF = (VoltREF + diodo); // corrige a queda de tensão do diodo
// POWER Display
lcd. setCursor (0, 0);
LCD. print ( "Pwr" );
/ * ROTINA DE CALIBRAGEM PARA TENSÃO DIANTEIRA //////////////////////
Esta rotina imprime no LCD a tensão FWD medida. // Quando não há energia aplicada, a tensão FWD exibida será a tensão do diodo em mV // Para calcular o fator de calibração, faça a leitura (incluindo tensão do diodo) // Remova o comentário desta rotina para entrar no modo de calibração lcd.setCursor (0, 0 ); lcd.print ("VoltFWD ="); lcd.print (VoltFWD, DEC); atraso (500); * / ////////////////////////////////////////////////// //////
// calcultate Poder Max, vamos precisar dele mais tarde
duplo PWRmax = pow ((5000 + Diode), 2);
PWRmax = PWRmax / PowCal / 1000;
if (PEP == 1) { // MODO DE ENERGIA Instantâneo
double PWR = pow (VoltFWD, 2);
PWR = PWR / PowCal / 1000;
E se (VoltFWD <(diodo + 2)) {
PWR = 0;
}
if (PWRmax <1) { // leitura de miliwatt
PowDis = PWR * 1000;
E se (PowDis <100) {
LCD. imprimir ( "" );
}
E se (PowDis <10) {
LCD. imprimir ( "" );
}
LCD. print ((PowDis), DEC );
LCD. impressão ( "mW" );
if ((PWR> 0) & (Tom == 1)) {
if ((10 * log10 (PWR * 1000))> = 0) {lcd. print ( "+" );} // + dBm
lcd. impressão (10 * log10 (PWR * 1000)); // cálculo de dBm
}
caso contrário, se (Tom == 1) {
LCD. print ( "(dBm)" );
}
if (Tom == 0) lcd. print ( "(Bip)" );
}
mais {
PowDis = PWR * 10;
E se (PowDis / 10 <100) {
LCD. print ( "" );
}
if (PowDis / 10 <10) {
LCD. print ( "" );
}
LCD. print ((PowDis / 10), DEC ); lcd. print ( "." );
LCD. print ((PowDis)% 10, DEC );
LCD. print ( "w" );
if ((PWR> 0) & (Tom == 1)) {
if ((10 * log10 (PWR * 1000))> = 0) {lcd. print ( "+" );} // + dBm
lcd. impressão (10 * log10 (PWR * 1000)); // cálculo de dBm
}
caso contrário, se (Tom == 1) {
LCD. print ( "(dBm)" );
}
if (Tom == 0) lcd. print ( "(Bip)" );
}
}
caso contrário, se (PEP == 0) { // PEP POWER MODE
Tom == 1; // Redefinir o modo Tom
VoltPEP = mapa (VoltFWDmax, 0,1023,0,5000);
VoltPEP = (VoltPEP + diodo); // corrige a tensão do diodo
PWR duplo = pow (VoltPEP, 2);
PWR = PWR / PowCal / 1000;
if (VoltPEP <(diodo + 2)) {
PWR = 0;
}
if (PWRmax <1) { // leitura de miliwatt
PowDis = PWR * 1000;
if (PowDis <100) {
LCD. print ( "" );
}
if (PowDis <10) {
LCD. print ( "" );
}
LCD. print ((PowDis), DEC );
LCD. print ( "mW (PEP)" );
}
mais {
PowDis = PWR * 10;
if (PowDis / 10 <100) {
LCD. print ( "" );
}
if (PowDis / 10 <10) {
LCD. print ( "" );
}
LCD. print ((PowDis / 10), DEC ); lcd. print ( "." );
LCD. print ((PowDis)% 10, DEC );
LCD. print ( "w (PEP)" );
}
}
// exibição SWR
// imprime a banda
LCD. setCursor (11, 1);
LCD. print (myStrings [BAND]);
LCD. setCursor (0, 1);
LCD. print ( "SWR" );
if ((VoltFWD <= (diodo + 2)) ou (PEP == 0)) { // Sem energia = sem SWR para detectar o
lcd. print ( "-.-" );
}
caso contrário, se ((VoltFWD> (diodo + 1)) & (VoltFWD <(VoltFWDmini)) & (VoltREF <= (diodo + 1))) { // a baixa potência, sem exibição de SWR ou <1,5
lcd. impressão ( "<1,5" );
}
mais {
Vratio = VoltREF / VoltFWD;
// Marque ROUTINE
//lcd.print(VoltREF, DEC); // DEBUG
//lcd.print(Vratio, DEC); // DEBUG
SWR = ((1 + Vratio) / (1 - Vratio));
if ((SWR> 3.1) & (PEP == 1)) {
LCD. impressão ( "> 3" );
tom (TonePin, 2500);
atraso (60);
noTone (TonePin);
}
mais {
SWRDis = SWR * 10;
if (SWRDis <10) { // SWR não pode ser menor que 1,0
SWRDis = 10;
}
if (SWRDis / 10 <10) {
LCD. print ( "" );
}
LCD. print ((SWRDis / 10), DEC ); lcd. print ( "." );
LCD. print ((SWRDis)% 10, DEC );
LCD. print ( "" );
/// SWR 'Bip' MODE
if ((Tom == 0) e ( digitalRead (ModeSwitch) == 1)) {
SWRtonePitch = mapa ((SWRDis * SWRDis), 100.900.300.200);
SWRtoneLenght = map ((SWRDis * SWRDis), 100.900.300,60);
tom (TonePin, SWRtonePitch);
atraso (SWRtoneLenght);
noTone (TonePin);
}
}
}
if ((Tom == 0) e ( digitalRead (ModeSwitch) == 1)) {
delay (SWRtoneLenght / 3); // deixa o silêncio entre os bipes do SWR, somente se nenhuma mudança de modo for necessária
}
}
void clearline0 () { // subrotina limpar linha superior exibir
lcd. setCursor (0, 0);
LCD. print ( "" );
}
void clearline1 () { // subrotina limpar linha inferior exibir
lcd. setCursor (0, 1);
LCD. imprimir ( "" );
}
void measureupplyvolt () { // Fonte de alimentaçãoVoltage measure
Tensão de alimentação = leitura analógica (A5); // Leia a tensão da fonte de alimentação
SupplyVoltage = map (SupplyVoltage, 0,1023,0, (50 * (R2 + R1) / R1));
if (SupplyVoltage <= 50) retorna ; // não funciona com baterias!
if (SupplyVoltage> = 84) SupplyVoltage = SupplyVoltage + 6; // funcionando com energia ext, corrija a queda de tensão do diodo 0.6v
// imprime a tensão da fonte de alimentação se a inicialização ou a bateria estiver fraca
if ((RunOnce == 1) ou (SupplyVoltage <= VoltSupplyMini)) {
LCD. claro ();
LCD. setCursor (0, 0);
LCD. print ( "Batt Volt =" );
E se (SupplyVoltage <100) {
LCD. print ( "" );
}
if (SupplyVoltage <10) {
LCD. print ( "" );
}
LCD. print ((SupplyVoltage / 10), DEC );
LCD. print ( "." );
LCD. print ((SupplyVoltage)% 10, DEC );
LCD. print ( "v" );
E se (SupplyVoltage <= VoltSupplyMini) {
LCD. setCursor (2, 1);
LCD. print ( "BATERIA FRACA!" );
}
atraso (1500);
}
}
Comentários
Postar um comentário