ONCRETO, facilmente assimilável ou entendida – Todos que atuam nessa ÁREA são considerados MALUCOS ! ! ! ! ! !
Recomendo iniciar, dando uma lida sobre o Tema / Assunto o que está disponível no Wilkpédia (Link abaixo), certo que perceberá que a Humanidade, ainda, Muito MAL conhece o Mundo da Matéria que representa apenas 50 % do TOTAL (Mundo da Matéria + Mundo da Anti–Matéria).
http://pt.wikipedia.org/wiki/Antimat%C3%A9ria
Através de uma Busca poderá encontrar muitos TRABALHOS interessantes, mas fique certo que a maior parte das informações existentes são TEÓRICAS e pouca há de Dados Experimentais.
Tudo que é QUENTE tende–se a perder Energia e Tudo que FRIO tende–se a ganhar Energia, como consequência a tendência é parar / finalizar num Ponto de Equilíbrio ou ESTADO de EQUILÍBRIO. Outros Fenômenos Naturais, também, tendem a parar / finalizar num Ponto de Equilíbrio.
A Tendência Universal é o ESTADO de EQUILÍBRIO => |Mundo da Matéria| = |Mundo da Anti–Matéria|.
Na Atualidade o UNIVERSO está em EXPANSÃO, segundo Renomados Pesquisadores, e por isso a |MASSA do Mundo da Matéria| é MAIOR (! ? ! ? ! ? ! ?) que a |MASSA do Mundo da Anti–Matéria|, mas no Futuro Distante (Bilhões ou Trilhões de Anos ! ? ! ? ! ? ! ?) o processo se INVERTERÁ iniciando–se a sua CONTRAÇÃO – é o Único Moto Perpétuo que Nunca irá PARAR.
Há vários Motos Quase–Perpétuos, com base nas principais Fontes Energéticas que estão ao nosso alcance:
1) Radiação Solar
2) Forças das ÁGUAS (Correntes Marinhas / Rios e Represas)
3) Ventos
4) Calor Geotérmicas
5) Outras
Todas as Fontes Energéticas são GRATUITAS – temos alguns PROJETOS, em andamento, para Produção de Energia Elétrica a CUSTO “ZERO”, mas só será divulgado depois que for encontrado a SOLUÇÃO que seguramente evite o USO NÃO–ÉTICO do RECURSO.
A Equipe BR do AGUAPÉ agradece e aguarda Manifestações dos Colegas Garagistas.
NOTA: “Quando Sonhamos SOZINHOS é só um SONHO, mas quando Sonhamos JUNTOS é o início de uma Nova Realidade” (D. Helder Câmara) - apresente as suas MANIFESTAÇÕES (Críticas, Sugestões, ETC.), utilizando o Endereço Eletrônico: missao.tanizaki@gmail.com, certo que muitos na Sociedade Brasileira, inclusive a Equipe BR do A G U A P É, te agradeçerão.
Um Abraço Fraterno aos Interessados pelo A G U A P É,
MISSAO TANIZAKI
Servidor Público Federal
Bacharel em Química
missao.tanizaki@gmail.com (Usual)
missaotanizaki@yahoo.com.br (Alternativo)
OSCIPE (*) - Equipe BR do A G U A P É
TUDO POR UM BRASIL & MUNDO MELHOR
(*) REF.: Definições do SEBRAE
…
postou aqui, e em algumas descrições que vc também postou.
Os dois pontos fundamentais, são a grande distância entre o Arduino e o Sensor Biométrico (que vc disse precisar de até 50m), e a distribuição adequada da Alimentação sem sobrecarregar os dispositivos que fornecem essa alimentação.
Tendo estes pontos em mente, segue o Diagrama : Acesso_Bio_01.pdf
Este mesmo Diagrama, vc pode ver na figura a seguir:
(clique na figura para "zoom")
Atente para os seguintes pontos importantes:
1) a alimentação do módulo "StepDown" (desses "comuns" com LM2596), deve ser "puxada" o mais próximo possível do ponto que também alimenta o Arduino. Ou seja: a linha de 12V e a linha de GND do módulo "StepDown" devem estar conectadas o mais próximo possível do conector de alimentação do Arduino. Mas o comprimento destas linhas é flexível e pode ser até uns 50cm conforme vc precisar. (mas não "puxe" a linha de GND do módulo "StepDown", de algum ponto da placa do Arduino!!!)
2) acredito que vc saiba, mas vou esclarecer mesmo assim: o "IN-" na plaquinha do módulo "StepDown", é o próprio "OUT-" desta mesma plaquinha. Eles estão interconectados pelo próprio traçado de cobre na plaquinha. Ou seja: como o "IN-" está conectado ao GND da Fonte (e portanto ao GND do Arduino), então o "OUT-" também é uma linha de GND. Porém, observe no Diagrama que o "OUT-" (linha na cor marrom), não se conecta ao GND do Arduino. Isto é para evitar que a corrente consumida pelo seu Sistema "Remoto" (onde fica o Sensor Biométrico, Buzzer, etc), use a placa do Arduino como "caminho de retorno". Em outras palavras: não interligue a "linha marrom" ao GND do Arduino (em nenhum ponto!). Isso é muito importante, pois o seu "Remoto" estará a uma grande distância. Siga esta regra e a regra do item "1", e assim não terá problemas com instantâneos de energia que possam ocorrem devido ao grande comprimento dos cabos.
3) a linha de 5V na cor laranja no Diagrama, não pode ser ligada ao Arduino (mas veja que ela alimenta os módulos RS485, e está conectada a alguns sinais nestes módulos).
4) todos os 4 pares de fios do CAT5 foram usados. Veja que procurei usar cores realísticas para os fios do cabo CAT. Use para os sinais, os fios com as cores que eu usei no Diagrama. Isto é fundamental para que as correntes do RS485 fiquem "confinadas" aos pares trançados "próprios".
5) atenção especial aos sinais "A" e "B" dos módulos RS485. Veja que o sinal "A" de um lado deve ir ao sinal "A" do outro lado. Se trocar, os sinais estarão invertidos e não vai funcionar. Basta seguir o Digrama.
6) veja que na alimentação do Sistema Remoto, há um Capacitor Eletrolítico de 1000uF (e 25V) ligado justamente entre a linha "marrom" e "laranja". Vc pode também usar valores maiores, como 2200uF, 3300uF, 4700uF. Atenção à polaridade do eletrolítico. Não é necessário usar capacitor cerâmico em paralelo com este eletrolítico, pois todas as plaquinhas no Remoto já possuem estes capacitores (e com valores adequados).
7) ligue os sinais "DE" e "RE" dos módulos RS485, exatamente como mostrado no Diagrama.
8) o Capacitor de 470 kpF, deve ser obrigatoriamente do tipo Cerâmico.
9) os diodos 1N4148 (são 6 no total) podem até serem dispensados. Mas se eu fosse vc, montaria os mesmos. Eles protegem os pinos correspondentes aos sinais, contra spikes de alta tensão que aparecem no cabo devido ao grande comprimento destes cabos. Sem eles, em algum momentos o Arduino poderá queimar (ou começar a apresentar mal-funcionamento), o mesmo se aplicando ao sensor de obstáculo. Para o Buzzer, o Transistor existente na plaquinha, certamente suportará os skipes, mas se não quiser arriscar, pode ligar dois 1N4148 da mesma forma que está ligado para o sensor de obstáculo. Atenção: não use diodos da série 4001 (como 1N4001, 1N4002, ... 1N4007, e por aí vai), pois estes diodos não são adequados para a função necessária. E claro: atenção à polaridade desses diodos, conforme indicado no Diagrama.
10) não esqueça de ajustar a saída do módulo "StepDown" para obter os 5V para alimentar os módulos RS485 e o próprio Sistema Remoto. O ajuste deve ser feito antes de vc alimentar tudo, e uma boa forma de fazer isso é antes de montar tudo, ligando apenas o módulo "StepDown" à fonte de 12V. Porém depois que ligar tudo, pode ser que vc tenha que ajustar para algo ligeiramente acima de 5V (devido ao grande comprimento dos cabos). Mas não ultrapasse os 5.5V (é preferível fazer este ajuste com o sensor Biométrico operando).
11) e finalmente: não sei qual é o ARM usado neste sensor Biométrico, mas certamente ele é alimentado por 3.3V a partir de algum regulador existente na placa do sensor. Ou seja: os níveis lógicos para os pinos TX e RX do Sensor, são relativos a 3.3V. Normalmente, os pinos das USARTs dos Processadores ARM, são tolerantes a 5V, e portanto nenhum tratamento "especial" seria necessário. Mas caso vc descubra que este não é caso do ARM deste sensor, então um Resistor de 1K deve ser ligado entre a saída "RO" do RS485 e a entrada "RX" do sensor Biométrico (ou seja, "em série" com o sinal). Eu acredito que isto não será necessário, devido ao que relatei sobre a tolerância a 5V, mas caso vc não queira se arriscar, acrescente o Resistor. Já para o sinal "TX", nenhuma ação é necessária.
Espero não ter esquecido de nada, e espero ter ajudado.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 9:36 em 19 março 2020
ódulo eu testei com o Arduino e funcionou bem, estou usando pullups como manda, logo o problema não é com o módulo.
Se alguém puder dar uma olhada no algoritmo e me falar o que posso estar fazendo de errado vai ser legal.
Obrigado!
_________________________________________________________________________________
//******* *************************************************************************
/** I N C L U D E S **********************************************************/
#include <p18cxxx.h> // Necessário para que o compilador adicione a biblioteca
// com as definições do PIC selecionado no projeto, neste
// caso, o modelo 18F4550.
#include <i2c.h> // Biblioteca com funções I2C
#include <timers.h> // Biblioteca dos timers
#include <delays.h> // Bilioteca com funções de atraso (delay)
#include "displayLCD.h" // Bibioteca com funções do display
/** BITS DE CONFIGURAÇÃO DO DISPOSITIVO***************************************/
#pragma config FOSC = HSPLL_HS // Habilita PLL, CPU e USB com cristal de alta velocidade (High Speed)
#pragma config PLLDIV = 5 // Oscilador de entrada de 20 MHz
#pragma config CPUDIV = OSC1_PLL2 // Clock CPU = 96MHz PLL/2
#pragma config USBDIV = 2 // Clock da USB = 96MHz PLL/2
#pragma config FCMEN = OFF // Fail Safe Clock Monitor
#pragma config IESO = OFF // Mudança do Oscilador int/ext
#pragma config PWRT = OFF // Power up Timer
#pragma config BOR = OFF // Brown-out Reset
#pragma config BORV = 3 // Tensão de Brown-out Reset = 2.05V
#pragma config VREGEN = ON // Regulator Interno da USB de 3,3V
#pragma config WDT = OFF // Watch Dog Timer
#pragma config WDTPS = 32768 // Postcaler do Watch Dog Timer
#pragma config MCLRE = ON // Master Clear Reset pino RE3
#pragma config LPT1OSC = OFF // Timer1 em Low-Power Oscilator
#pragma config PBADEN = OFF // PORTB<4:0> Analogicas no Reset
#pragma config CCP2MX = ON // CCP2 Mux ligado a RC1(ON) ou RB3(OFF)
#pragma config STVREN = ON // Stack Full / Overflow Reset
#pragma config LVP = OFF // Single Supply ICSP, Low-Voltage ICSP
#pragma config DEBUG = OFF // Pinos RB6 e RB7 dedicados para In Circuit Debug
#pragma config ICPRT = OFF // Pinos RB6 e RB7 dedicados para gravação ICSP
#pragma config XINST = OFF // Instruções Extendidas
// Proteção contra Leitura Externa dos Blocos da Flash
#pragma config CP0 = OFF // Bloco0
#pragma config CP1 = OFF // Bloco1
#pragma config CP2 = OFF // Bloco2
#pragma config CP3 = OFF // Bloco3
#pragma config CPB = OFF // Bloco Boot
#pragma config CPD = OFF // EEPROM
// Proteção contra Escrita nos Blocos da Flash
#pragma config WRT0 = OFF // Bloco0
#pragma config WRT1 = OFF // Bloco1
#pragma config WRT2 = OFF // Bloco2
#pragma config WRT3 = OFF // Bloco3
#pragma config WRTB = OFF // Bloco Boot
#pragma config WRTC = OFF // Bits de Configuração
#pragma config WRTD = OFF // EEPROM
// Proteção contra Leitura do Bloco via TBLRD localizadas em outros blocos
#pragma config EBTR0 = OFF // Bloco0
#pragma config EBTR1 = OFF // Bloco1
#pragma config EBTR2 = OFF // Bloco2
#pragma config EBTR3 = OFF // Bloco3
#pragma config EBTRB = OFF // Bloco Boot
/** D E F I N E S ************************************************************/
// Saidas Digitais
#define LED_VERMELHO LATAbits.LATA0 // Led vermelho
#define LED_AMARELO LATDbits.LATD0 // Led Amarelo
#define LED_VERDE LATCbits.LATC0 // Led Verde
//Entradas Digitais
/** V A R I A V E I S G L O B A I S ****************************************/
char num = 0 ; // Variável para armazenar o byte de leitura
int i = 0 ; // Variável para armazenar o valor da conversão
/** P R O T O T I P O S P R I V A D O S ***********************************/
void ConfiguraSistema(void) ; // Função para reunir as configurações
void ConfiguraInterrupcao(void) ; // Função para reunir config. de inter.
void ISR_alta_prioridade(void) ; // Função para alta prioridade
void ISR_baixa_prioridade(void) ; // Função para bixa prioridade
char bcd2dec(char num) ; // Função de conversão BCD para DECIMAL
/** F U N C O E S ************************************************************/
/******************************************************************************
* Funcao: void main(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: Função principal do programa.
*****************************************************************************/
void main(void)
{
ConfiguraSistema(); // Configura as portas e periféricos do PIC.
ConfiguraInterrupcao(); // Configura todas as interrupções
DesligaCursor(); // Chama a fuo que desliga o cursor
LimpaDisplay(); // Chama a função que limpa o display
//Inicia saidas digitais desligadas
LED_VERMELHO = 0;
LED_AMARELO = 0;
LED_VERDE = 0;
while(1) // Laço infinito que executa o funcionamento principal do projeto.
{
IdleI2C() ; // Aguarda ate que o barramento esteja livre
StartI2C() ; // Inicia a comunicação I2C
IdleI2C() ; // Aguarda ate que o barramento esteja livre
WriteI2C(0b10101110); // Control Byte enviado para "Random Read"
IdleI2C() ; // Aguarda ate que o barramento esteja livre
AckI2C() ; // Gera a condição de Acknowledge
IdleI2C() ; // Aguarda ate que o barramento esteja livre
WriteI2C(0x01) ; // Envia o "Address byte", referente aos minutos
IdleI2C() ; // Aguarda ate que o barramento esteja livre
num = ReadI2C() ; // Faz a leitura no barramento I2C de um unico byte
IdleI2C() ; // Aguarda ate que o barramento esteja livre
NotAckI2C() ; // Gera a condição de "Not Acknowlege"
IdleI2C() ; // Aguarda ate que o barramento I2C esteja livre
StopI2C() ; // Gera a condição de STOP no barramento
i= bcd2dec(num) ; // Faz a conversão de BCD para decimal
LED_AMARELO = 1 ; // Liga o led amarelo
Delay10KTCYx(100) ; // Delay CPU
PosicaoCursorLCD(1,1); // Posiciona o cursor na linha 1 coluna 1
EscreveFraseRomLCD("Leitura "); // Escreve no display
EscreveInteiroLCD(i) ; // Escreve no display o valor da leitura do I2C
LED_AMARELO = 0 ; // Desliga o led amarelo
Delay10KTCYx(100) ; // Delay CPU
}//end while(1)
}//end main
char bcd2dec(char num) // Função de conversão
{
return ((num/16 * 10) + (num % 16));
}
/******************************************************************************
* Funcao: void ConfiguraSistema(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: ConfiguraSistema é a rotina de configuração principal do PIC.
* Seu objetivo é configurar as portas de I/O e os periféricos
* do microcontrolador para que os mesmos trabalhem da maneira
* desejada no projeto.
*****************************************************************************/
void ConfiguraSistema(void)
{
// Desabilita todas as analógicas
ADCON1 = ADCON1 | 0x0F;
// Configurações
ConfiguraLCD();
OpenI2C(MASTER,SLEW_OFF); // Configurações do I2C
SSPADD = 49; // Configuração de velocidade de comunicação no protocolo I2C
// Configura saidas digitais
TRISDbits.TRISD1 = 0 ; // Led vermelho
TRISDbits.TRISD0 = 0 ; // Led amarelo
TRISCbits.TRISC0 = 0 ; // Led verde
// Configura entradas digitais
TRISBbits.TRISB1 = 1 ; // Configura pino usado no bus i2c como entrada
TRISBbits.TRISB0 = 1 ; // Configura pino usado no bus i2c como entrada
}//end ConfiguraSistema
/******************************************************************************
* Funcao: void ConfiguraInterrupcao(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: Função que configura as interrupções utilizadas no projeto
*****************************************************************************/
void ConfiguraInterrupcao(void)
{
}// end ConfiguraInterrupcao
/****************************************************************************
* Funcao: void ISR_alta_prioridade(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: Função de tratamento das interrupções de ALTA prioridade
* Nessa função deve-se lembrar de fazer a seguinte lista:
* 1- verificar qual foi a causa da interrupção, comparando
* os flags de cada tipo de interrupção.
* 2- tratar a interrupção selecionada.
* 3- limpar o flag que causou a interrupção!!! Importante
* para garantir que não ocorrerá uma chamada indesejada ao sair
* do tratamento da interrupção.
*
* Ao sair dessa função é usado o retorno do tipo "retfie fast",
* pois esta função é declarada como ALTA prioridade com a diretiva
* #pragma interrupt
*****************************************************************************
#pragma interrupt ISR_alta_prioridade
void ISR_alta_prioridade(void)
{
}// end Tratamento_High_Interrupt
/***************************************************************************
* Funcao: void ISR_baixa_prioridade(void)
* Entrada: Nenhuma (void)
* Saída: Nenhuma (void)
* Descrição: Função de tratamento das interrupções de BAIXA prioridade
* Nessa função deve-se lembrar de fazer a seguinte lista:
* 1- verificar qual foi a causa da interrupção, comparando
* os flags de cada tipo de interrupção.
* 2- tratar a interrupção selecionada.
* 3- limpar o flag que causou a interrupção!!! Importante
* para garantir que não ocorrerá uma chamada indesejada ao sair
* do tratamento da interrupção.
*
* Ao sair dessa função é usado o retorno do tipo "retfie",
* pois esta função é declarada como BAIXA prioridade com a diretiva
* #pragma interruptlow
*****************************************************************************
#pragma interrupt ISR_baixa_prioridade
void ISR_baixa_prioridade(void)
{
}//end Tratamento_Low_Interrupt
/********* PRAGMAS PARA AS INTERRUPÇÕES **************************************/
#pragma code int_alta = 0x08 //Endereço Vetor de interrupção de alta prioridade
void int_alta(void)
{
_asm GOTO ISR_alta_prioridade _endasm // Desvia o programa para a função ISR_alta_prioridade
}
#pragma code int_baixa = 0x18 // Endereço Vetor de interrupção de baixa prioridade
void int_baixa(void)
{
_asm GOTO ISR_baixa_prioridade _endasm // Desvia o programa para a função ISR_baixa_prioridade
}
#pragma code
/** FIM DO ARQUIVO main.c ***************************************************************/
…
LE )
Os sonhos são como uma humana interna holodeck . Dentro de sua mente, tudo é possível, de seus desejos mais grandiosos a seus piores pesadelos. Isto é tudo muito bem, mas e se você pudesse controlar seus sonhos e se tornar o deus onisciente de uma realidade escolhidos a dedo, sempre que você vai dormir? Inception levou essa idéia ao extremo lógico invadindo os sonhos de outras pessoas.
Enquanto nós não podemos invadir os sonhos dos outros, podemos definitivamente ter um astro de ação filme herói da nossa própria! Ao usar certas técnicas de sonhos lúcidos , você pode fazer exatamente isso. Durante o sonho lúcido, o sonhador dormindo está consciente de que eles estão em um sonho, mas permanece no sono. Isso permite que você conscientemente manipular e transformar o mundo de sonhos como em Inception .
Hoje, nós vamos fazer os nossos próprios sonhos lúcidos óculos e cortar nosso subconsciente em sua apresentação.
Materiais
Os óculos
LEDs (2)
ATTINY85 microcontrolador ( ESTOU USANDO O ARDUINO MESMO )
8 pinos titular de chips
AVR programador ou Arduino
3 volts bateria de célula tipo moeda
Suporte da bateria
perfboard
Mudar
Passo 1 Corte os óculos
Marque onde o seu nível de olho é em cada lente dos óculos. Certifique-se de testar se eles são grandes o suficiente para caber os LEDs que você tem.
Idealmente, o buraco deve ser grande o suficiente apenas que os LEDs são mantidos no lugar.
Etapa 2 do Programa de Chip
Para programar o ATTINY85, tudo o que precisamos é um Arduino e uma placa de montagem.Siga as instruções aqui sobre como usar um Arduino como um programador ISP. Uma vez que o programador está configurado, coloque este código para o chip. O código executa as seguintes tarefas cada vez que você ligar os óculos de proteção:
Pisque uma vez para sinalizar energia.
Esperar duas horas para o usuário para adormecer.
Blink padrão de luz uma vez a cada dez minutos para sempre.
O padrão pisca a cada dez minutos, na tentativa de pegá-lo no sono REM (movimento rápido dos olhos). REM é a fase do sono mais probabilidade de resultar em atividade sonho, e os ciclos de seu cérebro por essa fase do sono várias vezes ao longo da noite. Para se certificar de que vemos o padrão de luz durante o sono REM, que repeti-la em intervalos de dez minutos.
Passo 3 Breadboard o Circuito
Breadboard o circuito de acordo com o diagrama abaixo.
A grande coisa sobre o uso de uma fonte de 3 volts é que não precisa mesmo de resistores par com os LEDs, porque não há nenhuma corrente extra para protegê-los.
Passo 4 Layout e solda do Conselho
Agora que entendemos o nosso circuito, podemos movê-lo para um conselho permanente.Afaste os componentes em torno da perfboard experimentar com diferentes layouts. Tente encontrar o melhor compromisso de utilidade e estética.
Você vai passar por vários layouts experimentais. Tive sorte e meus LEDs se estendia desde a prancha certa para os buracos nas óculos.
Lembre-se de usar uma tomada para que você possa remover o chip se quiser reprogramá-lo mais tarde.
Eu prefiro a fios de solda na parte traseira para que a frente do conselho é bom e puro.
Passo 5 Anexar a Goggles
Coloque a placa sobre os óculos de proteção para que os LEDs picar através dos buracos dos olhos. Minas fica em apenas pela força dos LEDs, mas você pode colar ou parafusar a placa em que os óculos para uma conexão mais segura.
Passo 6 testá-lo!
Para utilizar os seus novos óculos de sonhos lúcidos, usá-los por alguns minutos por dia e tomar nota do padrão de luz. Cada vez que você notar o padrão, pense em seu entorno e como você chegou lá. Se você é na vida real, você vai se lembrar detalhes, mas no mundo dos sonhos, a maioria das coisas são vagas.
Ligue os óculos e colocá-los em apenas antes de ir para a cama. Se um dos flashes pega-lo em sua fase REM do sono e você está interessado o suficiente para notar que em seu sonho, você pode ser o deus do seu cérebro! Tudo o que precisamos é saber que você está sonhando sem acordar!
Eu não sugiro abrir os olhos enquanto o piscar LEDs. Ele pode lhe dar bastante dor de cabeça.
VIDEO
__________________________________________________________________
Olha que coisa Linda que ficou o meu!
Agora eu vou testa-lo Hahahahahaha
…
EFLOP - Arduino e Cia
#include <VirtualWire.h>
String mensagem;
void setup()
{
Serial.begin(9600);
//Define o pino 8 do Arduino como
//o pino de dados do transmissor
vw_set_tx_pin(8);
vw_setup(2000); // Bits per sec
Serial.println("Digite o texto e clique em ENVIAR...");
}
void loop()
{
char data[40];
int numero;
if (Serial.available() > 0)
{
numero = Serial.readBytesUntil (13,data,40);
data[numero] = 0;
Serial.print("Enviado : ");
Serial.print(data);
Serial.print(" - Caracteres : ");
Serial.println(strlen(data));
//Envia a mensagem para a rotina que
//transmite os dados via RF
send(data);
}
}
void send (char *message)
{
vw_send((uint8_t *)message, strlen(message));
vw_wait_tx(); // Aguarda o envio de dados
}
…
Adicionado por augusto ao 15:30 em 25 novembro 2017
ciar de algum ponto, e o importante é isso: ir em frente.
Primeiro, respondendo suas perguntas, na sequência que vc as colocou:
1) olhei na Internet o seu modelo de Arduino UNO "Lafvin". Ele é um Arduino UNO convencional, e pode ser utilizado como qualquer outro UNO. Então vc não precisa se referir a ele especificamente por "Lafvin". Chame-o apenas de "UNO".
2) os "comandos" "sei()" e "cli()" a que vc se refere, nós chamamos tecnicamente de "statements", e nada mais são do que funções para controle da Interrupção Geral do Processador "AVR" (o Processador do Arduino UNO) , e que são equivalentes respectivamente às funções "interrupts()" e "noInterrupts()" do Arduino. Assim dê uma olhada no site do Arduino sobre estas duas funções. Os links são estes dois: "interrupts" e "noInterrupts". O site estará em inglês, então use o tradutor do Google conforme preferir.
Estes dois "comandos", só devem ser utilizados se vc tiver uma boa experiência com Programação (não precisa ser do Arduino). Isto porque, eles tem consequências diversas para o funcionamento adequado do Sistema, e se utilizados de forma inadequada, seu Sistema poderá ter efeitos colaterais estranhos e que poderão até confundir vc.
E para o que vc quer fazer, não é necessário usar estes dois "comandos", como mostrarei adiante (no código que implementei).
3) o fato dos dois "comandos" não aparecerem "grafados" como vc diz, é irrelevante. Vou explicar. Os "comandos" que aparecem "grafados", aparecem assim porque eles estão descritos em um arquivo texto em alguma Biblioteca do Arduino, e estes arquivos sempre tem o nome "keywords.txt". Isto é usado apenas para ressaltar a visualização dos "comandos" no Editor do Arduino, e nada mais. Ou seja, não tem efeito no resultado da compilação do código. Então não se preocupe com isso. Além disso, o "sei" e o "cli" não deveriam mesmo aparecerem "grafados", pois são "primitivas" do Compilador AVR, e não exatamente "comandos", e de fato não deveriam estar em nenhum arquivo "keywords.txt" (e se estiverem, a pessoa que fez isso se equivocou, pois não domina a fundo o ambiente).
4) os valores e informações não aparecem adequadamente no Display LCD, porque simplesmente os "comandos" (ou "statements"), estão sendo usados de forma totalmente equivocada no seu código. A forma de se usar isto, é simples na plataforma Arduino. Então vc precisa "estudar" um pouco mais sobre isso, e certamente vai entender como usá-los (no código que estou postando mais adiante, vc poderá ver como isso é feito, e então usar como exemplo).
5) como vc está bem "verde" em Programação, primeiro vc precisa fazer o básico no seu código, e isto nada mais é do que medir a vazão em Litros/minuto de forma adequada e confiável, e então depois disso fazer a parte um pouco mais elaborada que vc descreveu (usando dois Sensores de Fluxo "yf-s201c" e um fim-de-curso). Veja: se vc medir adequadamente o Fluxo em um Sensor, então conseguirá medir em dois (ou a quantidade de sensores que vc quiser). Então bastará fazer os cálculos (algo muito simples em Programação) no momento adequado (conforme o seu fim-de-curso). E exibir os resultados no Display, será da mesma forma de sempre. Mas há Técnicas de Programação, que vc certamente terá que ficar mais acostumado. O que posso te dizer sobre isso, é que as pessoas sempre complicam e são muito desorganizadas, e isto é a chave pra tudo dar errado em Programação. Programação, exige que vc seja organizado, é imperativo. Se vc não for assim, então em algum momento vai ter problemas com seu Sistema, e provavelmente eles serão difíceis de resolver (não vou explicar os motivos disto neste momento).
Então pra dar um empurrão, estou postando um código para o Sistema que vc descreveu no seu código original. Veja: não é para o Sistema com dois sensores, pois quero te mostrar como se faz a coisa mais simples primeiro. O pessoal que me acompanha aqui, sabe que os Sistemas que posto aqui são bastante completos em termos de explicação e documentação, e os códigos são totalmente comentados de forma funcional. E 99% das vezes, eu posto também uma simulação do Sistema (usando o Proteus, devido à popularidade do mesmo).
Então o que está sendo feito neste código? Ele simplesmente mede o Fluxo de um Sensor (e nem precisa do "sei" e do "cli"), e exibe isto no Display, e após um minuto (ou 60 amostras), ele calcula a Média da Vazão. Ou seja, exatamente o que vc tentou fazer no seu código original. No entanto vc vai perceber, que o código que estou postando, é completamente diferente do seu original. Então analise o mesmo com atenção, sem pressa, e com a intenção de aprender. No código, estou usando técnicas clássicas para obter os resultados esperados. Assim se vc conseguir aprender, terá avançado tremendamente, e poderá seguir em frente com ainda mais confiança.
Implementei também a Simulação do seu Sistema usando o Proteus, e o Hardware equivalente, vc pode ver na figura a seguir:
(clique na figura para "zoom")
Se ficar estranho pra vc o Hardware na figura anterior, não se preocupe, pois realmente isso vai ocorrer se vc não está familiarizado com Hardware, com Eletrônica, e com o próprio Proteus. O importante é não achar que é algo transcendental ou do Egito antigo.
O resultado da Simulação vc pode ver nas figuras a seguir, onde "printei" a tela do Proteus em três momentos diferentes: 4 segundos após iniciar a execução do código, depois após 32 segundos, e finalmente após 60 segundos (quando a média é calculada e exibida). Após a exibição da Média da Vazão, o Sistema reinicia todo o processo de medição, e isto se repete indefinidamente. Veja os resultados nas figuras:
(clique nas figuras para "zoom")
O código, vc pode usar diretamente no seu Hardware para verificar o resultado. Apenas atente que o LCD I2C usado no código e no Hardware, tem a "pinagem" padrão desses módulos comercializados na Internet, e que está especificado na linha 48 no código, conforme vc pode ver na figura a seguir:
(clique na figura para "zoom")
Embora esta questão da "pinagem" do LCD I2C estivesse muito confusa (e equivocada) no seu código original, eu assumi que vc tem um módulo e Display I2C padrões, e a "pinagem" que usei corresponde a isso. Mas caso seja diferente (acho pouco provável), informe aqui, que tratarei da melhor forma que eu puder.
O código está aqui: "Fluxo_Agua_02.zip"
Como eu disse, vc pode usar este código diretamente no seu Sistema, pois eu segui as definições e pinagens descritas no seu código original.
E no arquivo zipado, vc também encontrará os arquivos para Simulação no Proteus, caso deseje fazer a Simulação (lá vc pode variar a vazão, através de um Potenciômetro que altera a taxa de pulsos de forma equivalente ao Sensor "real", e pode até desligar o Fluxo através de uma chave equivalente a um "Registro" hidráulico).
Espero ter ajudado.
Abrçs
Elcids…
Adicionado por Elcids Chagas ao 23:01 em 31 março 2020
do colocar umas frescuras como uma pagina html para troca de ip
eu tenho os dois codigos e gostaria de saber como faço eles rodarem juntos... alguem poderia me ajudar?
Código do DMX
#include <SPI.h> // needed for Arduino versions later than 0018#include <Ethernet.h>#include <EthernetUdp.h> #include <lib_dmx.h>
#define DMX512 (0) // (250 kbaud - 2 to 512 channels) Standard USITT DMX-512#define DMX1024 (1) // (500 kbaud - 2 to 1024 channels) Completely non standard - TESTED ok#define DMX2048 (2) // (1000 kbaud - 2 to 2048 channels) called by manufacturers DMX1000K, DMX 4x or DMX 1M ???
//TO EDIT:// the next two variables are set when a packet is receivedbyte destination_Ip[]= { 255,255,255,255 }; // the ip to send data, 255,255,255,255 is broadcast sending// art net parametersunsigned int localPort = 6454; // artnet UDP port is by default 6454const int DMX_Universe=15;//universe is from 0 to 15, subnet is not usedconst int number_of_channels=512; //512 for 512 channels, MAX=512
//HARDWAREbyte mac[] = { 144, 162, 218, 00, 16, 96 };//the mac adress of ethernet shield or uno shield boardbyte ip[] = { 192,168,1,118 };// the IP adress of your device, that should be in same universe of the network you are using, here: 192.168.1.x
//ART-NET variableschar ArtNetHead[8]="Art-Net";//sprintf((char *)node->id, "Art-Net\0"); algum erro aqui ?????????????????????
const int art_net_header_size=17;
short OpOutput= 0x5000 ;//output
byte buffer_dmx[number_of_channels]; //buffer used for DMX data
EthernetUDP Udp;
//Artnet PACKETbyte ArtDmxBuffer[(art_net_header_size+number_of_channels)+8+1];
void setup() {
//initialise artnet header construct_arnet_packet(); // démarrage ethernet et serveur UDP Ethernet.begin(mac,ip); Udp.begin(localPort); ArduinoDmx0.set_control_pin(11); // Arduino output pin for MAX485 input/output control (connect to MAX485 pins 2-3) ArduinoDmx0.set_rx_address(1); // set rx0 dmx start address ArduinoDmx0.set_rx_channels(512); // number of rx channels ArduinoDmx0.init_rx(DMX512); // starts universe 0 as rx, NEW Parameter DMX mode}
void loop() { check_arduino_inputs(); construct_arnet_packet(); Udp.beginPacket(destination_Ip, localPort); Udp.write(ArtDmxBuffer,(art_net_header_size+number_of_channels+1)); // was Udp.sendPacket Udp.endPacket(); delay(40);}
void check_arduino_inputs(){ //data from arduino aquisition
for(int i=0;i<512;i++)//reads the 6 analogic inputs and set the data from 1023 steps to 255 steps (dmx) { buffer_dmx[i]= ArduinoDmx0.RxBuffer[i]; }}
void construct_arnet_packet(){ //preparation pour tests for (int i=0;i<513;i++) { ArtDmxBuffer[i]=ArtNetHead[i]; }
//Operator code low byte first ArtDmxBuffer[8]=OpOutput; ArtDmxBuffer[9]= OpOutput >> 8; //protocole ArtDmxBuffer[10]=0; ArtDmxBuffer[11]=14; //sequence ArtDmxBuffer[12]=0; //physical ArtDmxBuffer[13] = 0; // universe ArtDmxBuffer[14]= DMX_Universe;//or 0 ArtDmxBuffer[15]= DMX_Universe>> 8; //data length ArtDmxBuffer[16] = number_of_channels>> 8; ArtDmxBuffer[17] = number_of_channels; for (int t= 0;t<number_of_channels;t++) { ArtDmxBuffer[t+art_net_header_size+1]=buffer_dmx[t]; } }
Codigo da Configuração WEB
#include <SPI.h>#include <Ethernet.h>#include <TextFinder.h>#include <EEPROM.h>#include <avr/wdt.h>
byte IP1 = 192;//the first part of the IP-addressbyte IP2 = 168; //the second part of the IP-addressbyte IP3 = 14; //the thirth part of the IP-addressbyte IP4 = 85; //the fourth part of the IP-addressbyte GW1 = 192; //the first part of the GATEWAYbyte GW2 = 168; //the second part of the GATEWAYbyte GW3 = 14; //the thirth part of the GATEWAYbyte GW4 = 2; //the fourth part of the GATEWAYbyte SUB1 = 255; //first part of the SUBNETMASKbyte SUB2 = 255; //the second part of the SUBNETMASKbyte SUB3 = 255; //the thirth part of the SUBNETMASKbyte SUB4 = 0; //the fourth part of the SUBNETMASKbyte SET = 0;
//seting up the EthernetShieldbyte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };byte ip[] = {IP1,IP2,IP3,IP4};byte gateway[] = {GW1,GW2,GW3,GW4};byte subnet[] = {SUB1,SUB2,SUB3,SUB4};EthernetServer server(80);
const byte ID = 0x95; //used to identify if valid data in EEPROM the "know" bit, // if this is written in EEPROM the sketch has ran before// We use this, so that the very first time you'll run this sketch it will use// the values written above. // defining which EEPROM address we are using for what dataconst byte ID_ADDR = 0; //the EEPROM adress used to store the ID (to check if sketch already has ran)const byte IP_ADDR1 = 1; //the EEPROM adress used to store the first part of the IP-addressconst byte IP_ADDR2 = 2; //the EEPROM adress used to store the second part of the IP-addressconst byte IP_ADDR3 = 3; //the EEPROM adress used to store the thirth part of the IP-addressconst byte IP_ADDR4 = 4; //the EEPROM adress used to store the fourth part of the IP-addressconst byte GW_ADDR1 = 5; //the EEPROM adress used to store the first part of the GATEWAYconst byte GW_ADDR2 = 6; //the EEPROM adress used to store the second part of the GATEWAYconst byte GW_ADDR3 = 7; //the EEPROM adress used to store the thirth part of the GATEWAYconst byte GW_ADDR4 = 8; //the EEPROM adress used to store the fourth part of the GATEWAYconst byte SUB_ADDR1 = 9; //the EEPROM adress used to store the first part of the SUBNETMASKconst byte SUB_ADDR2 = 10; //the EEPROM adress used to store the second part of the SUBNETMASKconst byte SUB_ADDR3 = 11; //the EEPROM adress used to store the thirth part of the SUBNETMASKconst byte SUB_ADDR4 = 12; //the EEPROM adress used to store the fourth part of the SUBNETMASKbyte ip_addr[] = { IP_ADDR1, IP_ADDR2, IP_ADDR3, IP_ADDR4};byte gw_addr[] = { GW_ADDR1, GW_ADDR2, GW_ADDR3, GW_ADDR4};byte sub_addr[] = { SUB_ADDR1, SUB_ADDR2, SUB_ADDR3, SUB_ADDR4};
void setup(){ Serial.begin(9600); ShieldSetup (); //Setup the Ethernet shield server.begin(); //starting the server Serial.print("ready on ip: "); Serial.print(IP1,DEC); Serial.print("."); Serial.print(IP2,DEC); Serial.print("."); Serial.print(IP3,DEC); Serial.print("."); Serial.println(IP4,DEC);}
void ShieldSetup(){ int idcheck = EEPROM.read(ID_ADDR); Serial.println(idcheck,DEC); if (idcheck != ID){ //ifcheck id is not the value as const byte ID, //it means this sketch has NOT been used to setup the shield before Ethernet.begin(mac, ip, gateway, subnet); //just use the values written in the beginning of the sketch Serial.println("first time sketch has run"); } if (idcheck == ID){ //if id is the same value as const byte ID, //it means this sketch has been used to setup the shield. //So we will read the values out of EERPOM ans use them //to setup the shield. IP1 = EEPROM.read(IP_ADDR1); IP2 = EEPROM.read(IP_ADDR2); IP3 = EEPROM.read(IP_ADDR3); IP4 = EEPROM.read(IP_ADDR4); GW1 = EEPROM.read(GW_ADDR1); GW2 = EEPROM.read(GW_ADDR2); GW3 = EEPROM.read(GW_ADDR3); GW4 = EEPROM.read(GW_ADDR4); SUB1 = EEPROM.read(SUB_ADDR1); SUB2 = EEPROM.read(SUB_ADDR2); SUB3 = EEPROM.read(SUB_ADDR3); SUB4 = EEPROM.read(SUB_ADDR4); byte ip[] = {IP1,IP2,IP3,IP4}; byte gateway[] = {GW1,GW2,GW3,GW4}; byte subnet[] = {SUB1,SUB2,SUB3,SUB4}; Ethernet.begin(mac, ip, gateway, subnet); Serial.println("NOT the first time sketch has run"); }}
void ShieldValueWrite(){ Serial.println("writing to EEPROM"); for (int i = 0 ; i < 4; i++) { EEPROM.write(ip_addr[i], ip[i]); } for (int i = 0 ; i < 4; i++) { EEPROM.write(gw_addr[i], gateway[i]); } for (int i = 0 ; i < 4; i++) { EEPROM.write(sub_addr[i], subnet[i]); } }
void loop(){ EthernetClient client = server.available(); if (client) { TextFinder finder(client ); while (client.connected()) { if (client.available()) { if( finder.find("GET /") ) { Serial.println("connection has been made"); if (finder.findUntil("SBM", "\n\r")){ Serial.println(); Serial.println("found a submitted form"); SET = finder.getValue(); while(finder.findUntil("DT", "\n\r")){ int val = finder.getValue(); if(val >= 0 && val <= 3) { ip[val] = finder.getValue(); } if(val >= 4 && val <= 7) { subnet[val - 4] = finder.getValue(); } if(val >= 8 && val <= 11) { gateway[val - 8] = finder.getValue(); } } Serial.print("The new IP address is:"); Serial.print(ip[0],DEC); for (int i= 1; i < 4; i++){ Serial.print("."); Serial.print(ip[i],DEC); } Serial.println(); Serial.print("The new Subnet is:"); Serial.print(subnet[0],DEC); for (int i= 1; i < 4; i++){ Serial.print("."); Serial.print(subnet[i],DEC); } Serial.println(); Serial.print("The new gateway is:"); Serial.print(gateway[0],DEC); for (int i= 1; i < 4; i++){ Serial.print("."); Serial.print(gateway[i],DEC); } Serial.println(); ShieldValueWrite(); // writing all the values whitin the form into EEPROM EEPROM.write(ID_ADDR, 0x95); //set ID to the known bit, so when you reset the Arduino is will use the EEPROM values Serial.println("all data has been written to EEPROM"); Serial.println("you can now reset the Arduino"); Serial.println("and use the new ip in your browser"); // // if al the data has been written to EEPROM we should reset the arduino // for now you'll have to use the hardware reset button } } client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.print("<html><body><table><form><input type=\"hidden\" name=\"SBM\" value=\"1\">"); client.print("<tr><td>IP: <input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT0\" value=\""); client.print(IP1,DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT1\" value=\""); client.print(IP2,DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT2\" value=\""); client.print(IP3,DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT3\" value=\""); client.print(IP4,DEC); client.print("\"></td></tr><tr><td>MASK: <input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT4\" value=\""); client.print(subnet[0],DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT5\" value=\""); client.print(subnet[1],DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT6\" value=\""); client.print(subnet[2],DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT7\" value=\""); client.print(subnet[3],DEC); client.print("\"></td></tr><tr><td>GW: <input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT8\" value=\""); client.print(gateway[0],DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT9\" value=\""); client.print(gateway[1],DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT10\" value=\""); client.print(gateway[2],DEC); client.print("\">.<input type=\"text\" size=\"1\" maxlength=\"3\" name=\"DT11\" value=\""); client.print(gateway[3],DEC); client.print("\"></td></tr><tr><td><input type=\"submit\" value=\"SUBMIT\"></td></tr>"); client.print("</form></table></body></html>"); client.print("free test SRAM = "); client.print(availableMemory()); client.print(" / SRAM used = "); client.print(2048-availableMemory()); break; } } delay(1); client.stop(); }}
int availableMemory(){ int size = 2048; byte *buf; while ((buf = (byte *) malloc(--size)) == NULL); free(buf); return size;}…
Adicionado por Deives Bender ao 20:57 em 11 fevereiro 2014
l dúvida é em relação ao menu do LCD onde pretendo ter na primeira tela após ser acionado por um botão "bverde" uma mensagem com o nome da máquina passando então 1 segundo irá mostrar a quantidade a ser envasada. A quantidade será o valor digitado no Keypad;
- Após o valor ser digitado pelo keypad uma segunda tela é mostrada, nessa tela será contada a quantidade de envasada e pressionando o "bamarelo" muda a tela para a terceira tela onde irá mostrar o nível do tanque de armazenamento, pressionando o "bamarelo" novamente ele volta para a segunda tela, ou seja o "bamarelo" irá funcionar como um botão de opões que transita entre essas duas telas;- Usando um decrementador quero que o mesmo decremente o valor digitado na tela 1 mostrando a mensagem de que o Lote esta pronto e que se deve inserir um novo valor;- Um terceiro botão "bvermelho" seria o botão de emergência, ou seja se pressionado a máquina trava.- Todo esse programa foi baseado em exemplos e projetos que encontrei aqui no fórum e em outros sites.
Como devo organizar os botões para agirem desta maneira ? Pois eles estão executando as ações que defini mais não da maneira que descrevi acima.
Segue o Programa:
//========================================================================#include <Keypad.h>#include <LiquidCrystal.h> LiquidCrystal lcd(22,23,24,25,26,27); // DECLARAÇÃO DOS PINOS DO LCD NO ARDUINO// DEFINIÇÃO DOS BOTÕES - VERDE. VERMELHO, AMARELO#define bverde A1 // Os pinos analógicos podem ser#define bamarelo A2 // usados como digitais, bastando#define bvermelho A3 // referenciá-los por A0, A1..#define bDown A4#define bverde0 90 // Valor de referência que a#define bamarelo0 91 // função CheckButton() passa#define bvermelho0 92 // indicando que um botão foi#define bDown0 93 // soltoboolean averde, aamarelo, avermelho, aDown; // Grava o ultimo valor lidos nos botões.// Utilizado pela função Checkbutton p/ identificar quando há uma alteração no estado do pino dos botões// DEFINIÇÃO DOS PINOS E VALORES PARA O SENSOR, ESTEIRA E BOMBAint contador = 0; int Sensor = 0; int sensorPin = A0; int MotorEsteira = 11;int MotorBomb= 12;int EstadoMotor=0;int EstadoSensor=1;int LED1=8;int LED2=9;int LED3=10;int LED4=2;int buzzer=7;int variavel; // VARIAVEL A SER ALTERADA PELO MENUchar state=1; // VARIÁVEL QUE GUARDA POSIÇÃO ATUAL DO MENUint dec=-1;int i=0;const byte LIN = 4; // TECLADO POSSUI 4 LINHASconst byte COL = 3; //TECLADO POSSUI 3 COLUNASchar keys[LIN][COL] = { {//MATRIZ CORRESPONDENTE AOS CARACTERES DO KEYPAD '1','2','3' }, {'4','5','6' },{'7','8','9' },{'*','0','#' }};byte LinPins[LIN] = {28,29,30,31}; //PINOS DO ARDUINO CORRESPONDENTES AS COLUNASbyte ColPins[COL] = {32,33,34}; //E AS LINHAS DA MATRIZKeypad keypad = Keypad( makeKeymap(keys), LinPins, ColPins, LIN, COL );char key = keypad.getKey();void setup(){lcd.begin(16, 2); // Iniciando a biblioteca do LCDSerial.begin(9600); // DEFINIÇÃO DA PORTA SERIALpinMode(bverde, INPUT); // BotõespinMode(bamarelo,INPUT);pinMode(bvermelho, INPUT);pinMode(bDown, INPUT);digitalWrite(bverde, HIGH); // Aciona o pull-up internodigitalWrite(bamarelo,HIGH); // dos botõesdigitalWrite(bvermelho, HIGH);digitalWrite(bDown, HIGH);pinMode(sensorPin, INPUT); //DEFINIR SE A VARIAVEL É ENTRADA(IMPUT) OU SAIDA(OUTPUT) DE DADOSpinMode(MotorEsteira, OUTPUT); pinMode(MotorBomb, OUTPUT);pinMode(EstadoSensor, INPUT);pinMode(LED1, OUTPUT);pinMode(LED2, OUTPUT);pinMode(LED3, OUTPUT);pinMode(LED4, OUTPUT);pinMode(buzzer, OUTPUT);}void loop(){Sensor = digitalRead(sensorPin); // A VARIAVEL SENSOR CORRESPONDE AO sensorPin QUE ESTÁ LIGADO A PORTA ANALÓGICA A0 DO ARDUINif(Sensor == LOW){ digitalWrite(MotorEsteira, HIGH); // SE O SENSOR NÃO ESTIVER ACIONADO O MOTOR DA BOMBA ESTA PARADO E O LED1 ASCESOdigitalWrite(LED1,HIGH); digitalWrite(LED2, LOW);digitalWrite(MotorBomb, LOW);digitalWrite(buzzer, LOW);}if(Sensor == HIGH) { // SE O SENSOR ESTIVER ACIONADO O MOTOR DA ESTEIRA ESTA PARADO E O LED1 APAGAdigitalWrite(MotorEsteira, LOW); // O MOTOR DA BOMBA LIGA E O LED2 ASCENDE E UM TOQUE DE 2 SEGUNDO É digitalWrite(MotorBomb, HIGH); // ACIONADO PELO BUZZER digitalWrite(LED1, LOW);digitalWrite(LED2, HIGH);delay(8000);//ESTE DELAY SERVE PARA A BOMBA JOGAR 200ml DE AGUA NA GARRAFAcontador++;Sensor == !Sensor; //O SINAL DO SENSOR É INVERTIDO PARA A FUNÇAO RETORNAR DE ONDE ESTAVA}EstadoSensor = digitalRead(sensorPin); // O SINAL DO SENSOR É MOSTRADO NO SERIAL MONITOR Serial.println(Sensor);if(EstadoSensor == HIGH){ // A FUNÇAO RETORNA AO ESTADO INICIALdigitalWrite(MotorEsteira, HIGH); digitalWrite(MotorBomb, LOW);digitalWrite(LED1, HIGH);digitalWrite(LED2, LOW);digitalWrite(buzzer,LOW);delay(2000);}switch (state) { // Define checa qual tela atualcase 1: // executado quando na TELA 1switch (CheckButton()) {case bverde:lcd.setCursor(0,0);lcd.print("Maquina Envase");lcd.setCursor(0,2);lcd.print("Eng. Mecatronica");delay(5000);lcd.clear();lcd.setCursor(0,0); lcd.print("Controle Prod.");Set_state(1);break;case bamarelo:lcd.clear(); Set_state(2); // antes de mudar de tela, é necessário limpar obreak; lcd.clear(); Set_state(3); // display com a função lcd.clear()break;lcd.clear(); Set_state(1);break;default: // Caso nenhum botão tenha sido apertado, ela executa a set_stateSet_state(1); // mesmo assim para atualizar o display.}break;case 2: // executado quando na TELA 2switch (CheckButton()) {case bverde: lcd.clear(); Set_state(1);break;case bamarelo: //lcd.clear(); Set_state(3);break;lcd.clear(); Set_state(1);break;lcd.clear(); Set_state(2);break;default:Set_state(2);}break;case 3: // executado quando na TELA 3switch (CheckButton()) {case bverde: lcd.clear(); Set_state(1);case bamarelo:lcd.clear(); Set_state(2);break;lcd.clear(); Set_state(3);break;lcd.clear(); Set_state(1);break;default:Set_state(3);}break;case 4: // executado quando na TELA 4switch (CheckButton()) {case bamarelo:lcd.clear(); Set_state(1);break;default:Set_state(1);}break;default: ;}}// FIM DO LOOPchar CheckButton() { if (averde!=digitalRead(bverde)) { averde=!averde; if (averde) return bverde0; else return bverde;} elseif (aamarelo!=digitalRead(bamarelo)) {aamarelo=!aamarelo;if (aamarelo) return bamarelo0; else return bamarelo;} elseif (avermelho!=digitalRead(bvermelho)) {avermelho=!avermelho;if (avermelho) return bvermelho0; else return bvermelho;} elseif (aDown!=digitalRead(bDown)) {aDown=!aDown;if (aDown) return bDown0; else return bDown;} elsereturn 0;}void PCP() // FUNÇÃO QUE DEFINE A QUANTIDADE DE GARRAFAS A SEREM ENVASADAS NO DIA{char key = keypad.getKey();if (key != NO_KEY){lcd.setCursor(i,2); lcd.print(key);i++;}}void Set_state(char index) {state = index; // Atualiza a variável state para a nova telaswitch (state) { // verifica qual a tela atual e exibe o conteúdo correspondentecase 1: //==================== state 1PCP();break;case 2: //==================== state 2lcd.setCursor(0,0);lcd.print("Qnt. Envasada:");lcd.setCursor(0,1);lcd.print(contador); // mostra os segundos na telalcd.print(" garrafas");delay(20);// if(contador==key){// lcd.setCursor(0,0);// lcd.print("Lote Pronto!");// lcd.setCursor(0,1);// lcd.print("Insira Novo");// }break;case 3: //==================== state 3lcd.setCursor(0,0);lcd.print("Nivel Tanque");lcd.setCursor(1,2);lcd.print("%");break;case 4: //==================== state 4break;default: ;}}…
guinte: tenho vários motores instalados em uma fábrica, estes motores possuem contatos auxiliares de alarme para informar quando um motor entrar em sobrecarga. Gostaria que o Arduíno Mega/Emissor recebesse o sinal (5V) destes contatos e me enviasse uma SMS informando que o motor está desarmado. A idéia básica é a seguinte:No Emissor:Eu recebo o sinal de 5V no pino 22 do arduino mega, por exemplo, recebendo este sinal eu escrevo na serial o valor "A".Eu recebo o sinal de 5V no pino 23 do arduino mega, por exemplo, recebendo este sinal eu escrevo na serial o valor "B". Eassim sucessivamente.No receptor (Arduíno Uno + Shield SIM 900 ICOMSAT 1.1):No receptor eu leio o que está escrito na serial e faço meu comando.Se ler o caracter 'A' na serial, envia SMS "M1 DESARMADO".Se ler o caracter 'B' na serial, envia SMS "M2 DESARMADO".O problemas destes códigos é que fica enviando SMS sem parar.
Vcs poderiam me dar uma luz para este caso? Segue abaixo os códigos:
//Arduino Mega (emissor)
byte contatoM1=22; //define o contato do motor M1byte contatoM2=23; //define o contato do motor M2byte contatoM3=24; //define o contato do motor M3byte contatoM4=25; //define o contato do motor M4byte contatoM5=26; //define o contato do motor M5byte contatoM6=27; //define o contato do motor M6byte contatoM7=28; //define o contato do motor M7byte contatoM8=29; //define o contato do motor M8byte contatoM9=30; //define o contato do motor M9byte contatoM10=31;//define o contato do motor M10byte contatoM11=32; //define o contato do motor M11byte contatoM12=33; //define o contato do motor M12byte contatoM13=34; //define o contato do motor M13byte contatoM14=35; //define o contato do motor M14byte contatoM15=36; //define o contato do motor M15byte contatoM16=37; //define o contato do motor M16byte contatoM17=38;//define o contato do motor M17byte A, B, C, D, E,F, G,H,I,J,L,M,N,O,Q,R,S;boolean enviouA, enviouB,enviouC, enviouD,enviouE, enviouF,enviouG, enviouH,enviouI, enviouJ,enviouL, enviouM,enviouN, enviouO,enviouQ, enviouR,enviouS=false; // flags booleanasbyte tx=1; // define o pino de saída Serial
boolean tempodecorte() { static unsigned long last_interrupt_time = 0; // define o tempo de referencia como zero unsigned long interrupt_time = millis(); // comeca a contagem do tempo if(interrupt_time - last_interrupt_time > 5000) // aplica a condição tempo de contagem maior que 5 s do que o tempo de referencia { last_interrupt_time = interrupt_time; // se a condicao é satisfeita redefine o tempo de referencia como o tempo de contagem return true; // e contabiliza o voto } return false; // se nao, nao contabiliza o voto }
void setup() { Serial.begin(9600); // inicializa o Serial com 9600 bauds pinMode(contatoM1, INPUT); pinMode(contatoM2, INPUT); pinMode(contatoM3, INPUT); pinMode(contatoM4, INPUT); pinMode(contatoM5, INPUT); pinMode(contatoM6, INPUT); pinMode(contatoM7, INPUT); pinMode(contatoM8, INPUT); pinMode(contatoM9, INPUT); pinMode(contatoM10, INPUT); pinMode(contatoM11, INPUT); pinMode(contatoM12, INPUT); pinMode(contatoM13, INPUT); pinMode(contatoM14, INPUT); pinMode(contatoM15, INPUT); pinMode(contatoM16, INPUT); pinMode(contatoM17, INPUT); pinMode(tx,OUTPUT); digitalWrite(tx,HIGH); // "liga" o pino de saída Serial } void loop() { A=digitalRead(contatoM1); B=digitalRead(contatoM2); C=digitalRead(contatoM3); D=digitalRead(contatoM4); E=digitalRead(contatoM5); F=digitalRead(contatoM6); G=digitalRead(contatoM7); H=digitalRead(contatoM8); I=digitalRead(contatoM9); J=digitalRead(contatoM10); L=digitalRead(contatoM11); M=digitalRead(contatoM12); N=digitalRead(contatoM13); O=digitalRead(contatoM14); Q=digitalRead(contatoM15); R=digitalRead(contatoM16); S=digitalRead(contatoM17); if(tempodecorte()){ // chama funcao para o tempo em que o botao deve ser pressionado para ser considerado um voto if(A==HIGH && enviouA == false){ Serial.write('A'); // armazena A no Serial enviouA = true; delay(5000); } if(A==LOW){ // se mudou o valor de A, altera a flag para quando mudar novamente ele enviar enviouA = false; } // o if do B não deve ter nada a ver com o A, pois são motores diferentes if(B==HIGH && enviouB == false){ Serial.write('B'); // armazena B no Serial enviouB = true; delay(5000); } if(B==LOW){ enviouB = false; } if(C==HIGH && enviouC == false){ Serial.write('C'); // armazena C no Serial enviouC = true; delay(5000); } if(C==LOW){ enviouC = false; } if(D==HIGH && enviouD == false){ Serial.write('D'); // armazena D no Serial enviouD = true; delay(5000); } if(D==LOW){ enviouD = false; } if(E==HIGH && enviouE == false){ Serial.write('E'); // armazena E no Serial enviouE = true; delay(5000); } if(E==LOW){ enviouE = false; } if(F==HIGH && enviouF == false){ Serial.write('F'); // armazena F no Serial enviouF = true; delay(5000); } if(F==LOW){ enviouF = false; } if(G==HIGH && enviouG == false){ Serial.write('G'); // armazena G no Serial enviouG = true; delay(5000); } if(G==LOW){ enviouG = false; } if(H==HIGH && enviouH == false){ Serial.write('H'); // armazena H no Serial enviouH = true; delay(5000); } if(H==LOW){ enviouH = false; } if(I==HIGH && enviouI == false){ Serial.write('I'); // armazena I no Serial enviouI = true; delay(5000); } if(I==LOW){ enviouI = false; } if(J==HIGH && enviouJ == false){ Serial.write('J'); // armazena J no Serial enviouJ = true; delay(5000); } if(J==LOW){ enviouJ = false; } if(L==HIGH && enviouL == false){ Serial.write('L'); // armazena L no Serial enviouL = true; delay(5000); } if(L==LOW){ enviouL = false; } if(M==HIGH && enviouM == false){ Serial.write('M'); // armazena M no Serial enviouM = true; delay(5000); } if(M==LOW){ enviouM = false; } if(N==HIGH && enviouN == false){ Serial.write('N'); // armazena N no Serial enviouN = true; delay(5000); } if(N==LOW){ enviouN = false; } if(O==HIGH && enviouO == false){ Serial.write('O'); // armazena O no Serial enviouO = true; delay(5000); } if(O==LOW){ enviouO = false; } if(Q==HIGH && enviouQ == false){ Serial.write('Q'); // armazena Q no Serial enviouQ = true; delay(5000); } if(Q==LOW){ enviouQ = false; } if(R==HIGH && enviouR == false){ Serial.write('R'); // armazena R no Serial enviouR = true; delay(5000); } if(R==LOW){ enviouR = false; } if(S==HIGH && enviouS == false){ Serial.write('S'); // armazena S no Serial enviouS = true; delay(5000); } if(S==LOW){ enviouS = false; } } }
//Receptor (Arduíno Uno + Shield SIM 900 ICOMSAT 1.1)#include "SIM900.h"#include <SoftwareSerial.h>#include "sms.h"#include "GSM.h"SMSGSM sms;boolean started=false;byte rx=0;char x=0;int pinState = 0;int powerkey = 9; int statuspin = 4;void setup() {Serial.begin(9600); pinMode(rx,INPUT); pinMode(statuspin, INPUT);pinMode(pinState, INPUT);pinMode(powerkey, OUTPUT);pinState = digitalRead(statuspin); if(pinState==LOW){ digitalWrite(powerkey, HIGH); delay(2000); digitalWrite(powerkey, LOW); delay(2000);} Serial.println("GSM Shield testing."); if (gsm.begin(2400)){ Serial.println("\nstatus=READY"); started=true; } else Serial.println("\nstatus=IDLE"); }void loop() { if(Serial.available()){ x = Serial.read(); { if (x =='A'){ sms.SendSMS("+559888021164", "M1 DESARMADO"); delay(5000); } if (x =='B'){ sms.SendSMS("+559888021164", "M2 DESARMADO"); delay(5000); } if (x =='C'){ sms.SendSMS("+559888021164", "M3 DESARMADO"); delay(5000); } if (x =='D'){ sms.SendSMS("+559888021164", "M4 DESARMADO"); delay(5000); } if (x =='E'){ sms.SendSMS("+559888021164", "M5 DESARMADO"); delay(5000); } if (x =='F'){ sms.SendSMS("+559888021164", "M6 DESARMADO"); delay(5000); } if (x =='G'){ sms.SendSMS("+559888021164", "M7 DESARMADO"); delay(5000); } if (x =='H'){ sms.SendSMS("+559888021164", "M8 DESARMADO"); delay(5000); } if (x =='I'){ sms.SendSMS("+559888021164", "M9 DESARMADO"); delay(5000); } if (x =='J'){ sms.SendSMS("+559888021164", "M10 DESARMADO"); delay(5000); } if (x =='L'){ sms.SendSMS("+559888021164", "M11 DESARMADO"); delay(5000); } if (x =='M'){ sms.SendSMS("+559888021164", "M12 DESARMADO"); delay(5000); } if (x =='N'){ sms.SendSMS("+559888021164", "M13 DESARMADO"); delay(5000); } if (x =='O'){ sms.SendSMS("+559888021164", "M14 DESARMADO"); delay(5000); } if (x =='Q'){ sms.SendSMS("+559888021164", "M15 DESARMADO"); delay(5000); } if (x =='R'){ sms.SendSMS("+559888021164", "M16 DESARMADO"); delay(5000); } if (x =='S'){ sms.SendSMS("+559888021164", "M17 DESARMADO"); delay(5000); } else{ x=0; } }}}
…
Adicionado por Edson Diniz ao 14:50 em 12 agosto 2014