m o mesmo funcionamento, mas não estou conseguindo receber quaisquer dados do sensor por meio desta biblioteca.
Está junto anexado a biblioteca QTRSensors.
// Inclusão de bibliotecas #include <Button.h>#include <QTRSensors.h>#include <Wire.h>#include <LiquidCrystal.h>
// Definição de constantes#define NUMREADINGS 10 // número de leituras para tirar a média // da tensão da bateria
// Definção de objetosButton button = Button(2,BUTTON_PULLUP_INTERNAL); // botão no pino 2// sensores nos pinos analógicos 0, 1, 2, 3 e 4// usados como digital 14, 15, 16, 17 e 18// 5 sensores, time-out 2000, sem pino de LEDQTRSensorsRC qtr((unsigned char[]) {14, 15, 16, 17, 18}, 5, 2000, QTR_NO_EMITTER_PIN);// display nos pinos R/W - 13, Enable - 12, daods - 9, 8, 7 e 4LiquidCrystal lcd(13, 12, 9, 8, 7, 4);
// Definição de variáveisunsigned int sensors[5]; // Matriz para armazenar valores dos sensores
int inA1 = 10; // Pinagem para a PONTE-Hint inA2 = 11;int inB1 = 5;int inB2 = 6;
//int pinButton = 2; // Pino do botãoint pinBatery = 5; // Pino do sensor de bateria// |GND|---/\/\/\/------/\/\/\/-----|VCC|// 10K | 5K// |int pinAudio = 3; // Pino do Buzzer/Speaker
int voltage;int readings[NUMREADINGS];float volts = 0;int total = 0;float average = 0;int index = 0;int last_proportional;int integral;
// Executado na inicialização do Arduinovoid setup(){ lcd.begin(16, 2); Serial.begin(9600); // Inicializa a comunicação serial pinMode(pinAudio, OUTPUT); // Define pino de audio como saída set_motors(0,0); // Enquanto espera, motores permanecem parados lcd.clear(); lcd.setCursor(0, 0); lcd.print(" LINUSBot"); lcd.setCursor(0, 1); lcd.print(" Line Follower "); delay(2000); voltage = read_batery(); // Lê a tensão da bateria lcd.clear(); lcd.setCursor(0, 0); lcd.print("Bateria"); lcd.setCursor(0, 1); lcd.print(voltage); lcd.print(" mV"); delay(2000); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Inicializando..."); delay(1500); lcd.setCursor(0, 1); lcd.print("OK!"); delay(1000); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Pressione Botao"); while(!button.isPressed()){ } delay(500); // Atraso para dar tempo de tirar o dedo do botão // Sempre espere por um botão ser pressionado antes de que // seu robot possa iniciar a movimentação lcd.clear(); lcd.setCursor(0, 0); lcd.print("Auto-calibracao"); //Serial.println("Auto-calibracao"); // Auto-calibração: gira para a direita e depois esquerda e volta ao início // calibrando os sensores unsigned int counter; // usado como um simples contador for(counter=0; counter<80; counter++){ if(counter < 20 || counter >= 60){ set_motors(50,-50); // Gira para a direita } else{ set_motors(-50,50); // Gira para a esquerda } // Esta função armazena um conjunto de leituras dos sensores, e mantém // informações sobre o máximo e mínimo valores encontrados qtr.calibrate(); // Desde que contamos até 80, o total do tempo de calibração // será de 80 * 10 = 800 ms delay(10); } set_motors(0,0); // Garante motores parados após o processo // de calibração lcd.setCursor(0, 1); lcd.print("Calibrado!"); delay(1000); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Pressione botao"); // Enquanto botão não é pressionado // mostra a posição da linha em relação aos sensores no console serial // usado para debug /* while(!button.isPressed()){ unsigned int position = qtr.readLine(sensors); Serial.println(position); } */}
// Esta é a função principal, onde o código inicia. Todo programa Arduino// deve ter uma função loop() definida em algum lugarvoid loop(){ while(!button.isPressed()){ } delay(200); playMusic(); lcd.clear(); lcd.setCursor(0, 0); lcd.print("Go! go! go! ..."); delay(500); // Este é o loop principal - irá rodar para sempre while(1){ // Obtém a posição da linha // Aqui não estamos interessados nos valores individuais de cada sensor unsigned int position = qtr.readLine(sensors); // O termo proporcional deve ser 0 quando estamos na linha int proportional = ((int)position) - 2000; // Calcula o termo derivativo (mudança) e o termo integral (soma) // da posição int derivative = proportional - last_proportional; integral += proportional; // Lembrando a ultima posição last_proportional = proportional; // Calcula a diferença entre o aranjo de potência dos dois motores // m1 - m2. Se for um número positivo, o robot irá virar para a // direita. Se for um número negativo, o robot irá virar para a esquerda // e a magnetude dos números determinam a agudez com que fará as curvas/giros int power_difference = proportional/10 + integral/10000 + derivative*3/2; // Calcula a configuração atual dos motores. Nunca vamos configurar // um motor com valor negativo const int max = 180; if(power_difference > max) power_difference = max; if(power_difference < -max) power_difference = -max; if(power_difference < 0) set_motors(max+power_difference, max); else set_motors(max, max-power_difference); }}
// Acionamento dos motoresvoid set_motors(int left_speed, int right_speed){ if(right_speed >= 0 && left_speed >= 0){ analogWrite(inA1, 0); analogWrite(inA2, right_speed); analogWrite(inB1, 0); analogWrite(inB2, left_speed); } if(right_speed >= 0 && left_speed < 0){ left_speed = -left_speed; analogWrite(inA1, 0); analogWrite(inA2, right_speed); analogWrite(inB1, left_speed); analogWrite(inB2, 0); } if(right_speed < 0 && left_speed >= 0){ right_speed = -right_speed; analogWrite(inA1, right_speed); analogWrite(inA2, 0); analogWrite(inB1, 0); analogWrite(inB2, left_speed); } }
// Verifica tensão da bateriaunsigned int read_batery(){ // Tirando a média for (int k = 0; k < NUMREADINGS; k++){ // Zerando a matriz readings[k] = 0; } total -= readings[index]; // Inicializa total readings[index] = analogRead(pinBatery); // Faz a leitura do sensor total += readings[index]; // Soma valores da matriz index = (index + 1); // Próximo valor if (index >= NUMREADINGS){ // Verifica se chegou ao fim das leituras index = 0; // Se sim zera o índice } average = total / NUMREADINGS; // Média simples //Serial.println(average); // Para debug, se necessário // Agora calculamos a tensão baseado na leitura analógica média volts = average * 5000 * 3 / 2 / 1023 * 10; return (volts); // Retorna com o valor}
// Toca música e sonsvoid playMusic(){ // Definição de frequência das notas #define NOTE_B0 31 #define NOTE_C1 33 #define NOTE_CS1 35 #define NOTE_D1 37 #define NOTE_DS1 39 #define NOTE_E1 41 #define NOTE_F1 44 #define NOTE_FS1 46 #define NOTE_G1 49 #define NOTE_GS1 52 #define NOTE_A1 55 #define NOTE_AS1 58 #define NOTE_B1 62 #define NOTE_C2 65 #define NOTE_CS2 69 #define NOTE_D2 73 #define NOTE_DS2 78 #define NOTE_E2 82 #define NOTE_F2 87 #define NOTE_FS2 93 #define NOTE_G2 98 #define NOTE_GS2 104 #define NOTE_A2 110 #define NOTE_AS2 117 #define NOTE_B2 123 #define NOTE_C3 131 #define NOTE_CS3 139 #define NOTE_D3 147 #define NOTE_DS3 156 #define NOTE_E3 165 #define NOTE_F3 175 #define NOTE_FS3 185 #define NOTE_G3 196 #define NOTE_GS3 208 #define NOTE_A3 220 #define NOTE_AS3 233 #define NOTE_B3 247 #define NOTE_C4 262 #define NOTE_CS4 277 #define NOTE_D4 294 #define NOTE_DS4 311 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_FS4 370 #define NOTE_G4 392 #define NOTE_GS4 415 #define NOTE_A4 440 #define NOTE_AS4 466 #define NOTE_B4 494 #define NOTE_C5 523 #define NOTE_CS5 554 #define NOTE_D5 587 #define NOTE_DS5 622 #define NOTE_E5 659 #define NOTE_F5 698 #define NOTE_FS5 740 #define NOTE_G5 784 #define NOTE_GS5 831 #define NOTE_A5 880 #define NOTE_AS5 932 #define NOTE_B5 988 #define NOTE_C6 1047 #define NOTE_CS6 1109 #define NOTE_D6 1175 #define NOTE_DS6 1245 #define NOTE_E6 1319 #define NOTE_F6 1397 #define NOTE_FS6 1480 #define NOTE_G6 1568 #define NOTE_GS6 1661 #define NOTE_A6 1760 #define NOTE_AS6 1865 #define NOTE_B6 1976 #define NOTE_C7 2093 #define NOTE_CS7 2217 #define NOTE_D7 2349 #define NOTE_DS7 2489 #define NOTE_E7 2637 #define NOTE_F7 2794 #define NOTE_FS7 2960 #define NOTE_G7 3136 #define NOTE_GS7 3322 #define NOTE_A7 3520 #define NOTE_AS7 3729 #define NOTE_B7 3951 #define NOTE_C8 4186 #define NOTE_CS8 4435 #define NOTE_D8 4699 #define NOTE_DS8 4978
// Definição de músicas int note[] = {NOTE_C4, NOTE_C4, NOTE_G4, NOTE_C5, NOTE_G4, NOTE_C5}; int duration[] = {100, 100, 100, 300, 100, 300};
int starttune[] = {NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_C4, NOTE_F4, NOTE_G4, NOTE_F4, NOTE_E4, NOTE_F4, NOTE_G4}; int duration2[] = {100, 200, 100, 200, 100, 400, 100, 100, 100, 100, 200, 100, 500};
int error[] = {NOTE_G3, NOTE_C3, NOTE_G3, NOTE_C3, NOTE_G3, NOTE_C3, NOTE_G3, NOTE_C3}; int duration3[] = {100, 200, 100, 200, 100, 200, 100, 200}; // Loop com a quandiade de notas a serem tocadas // Se necessário, mude o valor interno do loop "for" for(int i=0;i<6;i++){ tone(pinAudio, note[i], duration[i]); // Emite o som nota/duração delay(duration[i]); // Pausa do som noTone(pinAudio); // Finaliza som }}
…
liderados por Sergey Lebedev Alekseevich a partir do final de 1948 no Instituto de Eletrônica e Tecnologia de Kiev, cuja exploração é começou em 1951 depois de vários testes com sucesso. Inicialmente, o trabalho sobre a MESM, tinha objetivos apenas deinvestigación e interesses na área dos computadores de construção elementares. Mas depois de testes bem-sucedidos de sua operação e uma necessidade crescente de todos os tipos de cálculos (especialmente no serviço militar), decide terminar o projeto foi capaz de usar a máquina como uma ferramenta para resolver problemas reais.Em 1949 atrasado, nós projetamos a arquitetura e identifica esquemas MESM funcionamento de seus blocos. Em 1950, a máquina foi montada em um prédio de dois andares de um antigo mosteiro Fofaniya (cerca de Kiev). Em 6 de novembro de 1950 foi o primeiro teste da máquina executando-laoperación Y + Y = 0, Y (0) = 0, Y (π) = 0. Em 4 de janeiro de 1951, as operações foram realizadas unasucesión soma de números ímpares de fatorial de um número e de um elevador de energia. 25 de dezembro de 1951, começou a operação normal e regular da máquina.O MESM tinha as seguintes características:PunchcardA máquina aritmética: ação, universal paralelo, com base no biestável simples.Representação de números: Encoma, binário fixo, com 16 bits para Labase e um bit para indicar o sinal.Memória operacional: com base nos dados biestáveis para 31 dígitos para o comando de 63 dígitos.Memória volátil: a-31-dígitos dados para os dígitos de comando-63.Velocidade de processamento: c (o tempo de ciclo total é de cerca de 17,6 ms, a operação de divisão é realizada numa gama de 17,6-20,8 ms).Comandos do sistema: três vias, com 20 dígitos para o comando, os quatro primerosdígitos indicam theCode de laoperación, o 5 endereço próximo do primeiro operando, a 6 após o segundo operando e os restantes 5 endereço de armazenamento resultado laoperación .Operação disponível: adição, subtração, multiplicação, divisão, comparação do deslocamento, considerando o sinal, em comparação com o valor absoluto, redirecionar, transmitido números de uma bobina magnética, Soma de comandos, pare.Thermionic válvulas: a 6000 (3500 apox 2500 triodes e diodos.)Área ocupada: cerca de 60m ².Consumo de energia: cerca de 25 kW.A leitura dos dados é realizada por meio de cartões perfurados também pode usar uma bobina magnética, cuja capacidade de armazenamento foi de aproximadamente 5000 comandos ou números.A saída dos dados é realizada por um dispositivo, ou por um dispositivo imprentaelectromecánico fotográfica sobre uma película fotográfica.STRELAA Strela computador (ЭВМ "Стрела") foi o primeiro computador de grande porte construído na União Soviética a sério desde 1953. Strela significa seta.O projetista-chefe foi Yuri Basilevsky. Entre seus assistentes foi Boris Rameyev, designer-chefe da série computador Ural. Ele foi projetado para o projeto especial Gabinete 245, de Moscou.Os Strelas foram fabricados em Moscou Usina de Informática e Máquinas analíticos (Московский завод счетно-аналитических машин) entre 1953 e 1957, foram construídos sete máquinas. Foram instalados no Centro de Computação da Academia Russa de Ciências, Keldysh Instituto de Matemática Aplicada, Universidade Estadual de Moscou, e centros de computação de alguns ministérios (relacionada com a defesa e economia).Estes computadores de primeira geração eram 6.200 e 60.000 válvulas diodos semicondutores. O Strela tinha uma velocidade de 2.000 operações por segundo. Sua aritmética de ponto flutuante foi baseado em palavras de 43 bits com mantissa assinado e 35 bits de expoente 6 bits assinados. A tubos de RAM Williams tinha 2048 palavras. Ele também foi um programas ROM semicondutores. A entrada de dados foi através de cartões perfurados ou de fitas. A saída de dados foi realizada por fita magnética, cartões perfurados ou impressora.A versão mais recente do Strela usado um cilindro magnético de 4.096 palavras girando a 6.000 rpm.Em 1954, os designers Strela foram agraciados com o Stalin Medalha 1. grau.MINSKA Minsk foi uma família de computadores de grande porte foram desenvolvidos e produzidos no Soviética Bielo-Rússia República Socialista entre 1959 e 1975. Sua produção foi interrompida pela decisão política de mudar para um clone IBM 360 conhecido como ES EVM para o comprimento conhecido como "distensão", em que a União Soviética e os EUA aliviou tensões e houve um "degelo" da Guerra Fria.O modelo mais avançado era o Minsk-32, desenvolvido em 1968. Suportado COBOL, FORTRAN e ALGAMS (uma versão do ALGOL). Este e versões anteriores também usou uma linguagem de máquina orientada chamado AKI (por sua sigla (AvtoKod "Inzhener.") Estava entre os nativos linguagem assembly SSK (Kodirovaniya Sistema Simvolicheskogo, ou "sistema de código simbólico") de altura e Línguas nível como FORTRAN. M-20, M-220 e M-222 eram um grupo de máquinas de uso geral projetados e fabricados na URSS. Essas máquinas foram desenvolvidas pelo Instituto de Pesquisa Científica de máquinas eletrônicas (NIIEM) e construído no Moscou Usina de Computação e Análise de Máquina (SAM) e Usina Kazan de máquinas de computação, sob a supervisão do Ministério da Indrustria URSS.URALA série Ural computador foi desenvolvido pelo manifacturer de Computação Eletrônica Produção de Penza, e foi produzido entre 1959 e 1964. O seu designer chefe era Bashir Rameyev foram fabricados um total de 139. Foi amplamente utilizado na década de 60, especialmente nos países socialistas, mas também exportados para a Europa Ocidental e na América Latina.Modelos 1 a 4 da Ural foram baseados em tubos de vácuo (válvulas), com hardware que o fizeram capaz de atingir os 12.000 cálculos de ponto flutuante por segundo. Uma palavra é constituída por 40 bits e foi capaz de conter um número ou de duas instruções. Foi utilizado um núcleo de ferrite para criar a memória de trabalho. A nova série (o 11 eo 14, produzido entre 1964 e 1971) foram baseados em semicondutores.Permitido para tarefas matemáticas em centros de informática, instalações e indrustriales científicos instalações. A máquina ocupa aproximadamente 90-100 metros quadrados. O computador estava funcionando e tinha uma tensão trifásica 30kVA lastro magnéticos capazes.As principais unidades do sistema foram: teclado unidade de controle, e leitura, memória, a memória de ferrite unidade aritmeticológica, unidade central de processamento e fonte de alimentação.Estações de trabalho. e computadores pessoais.SM EVMO EVM SM (russo М ЭВМ, curto Система Малых ЭВМ - literalmente Minicomputadores Sistema) era o nome de vários tipos soviéticos minicomputadores 70 e 80. Sua produção começou por volta de 1975. Muitos deles eram clones do DEC PDP-11 e VAX. SM-1 e SM-2 clones foram criados por minicomputadores Hewlett Packard. O sistema operacional mais comum para esses computadores foram traduzidas versões do RSX-11 (ОС РВ) para modelos high-end e RT-11 (РАФОС, ФОДОС) para modelos low-end. Houve também um clone de UNIX disponível, MOS, por gama alta PDP-11 clones.MIRMIR (МИР, "paz" ou "mundo" em russo) é o nome de uma série de computadores soviéticos, desenvolvido entre 1965 (miR-1) para 1969 (o MIR-2) por um grupo liderado por Viktor Glushkov. Um acrônimo para "Машина для Инженерных Расчётов" (cálculos de engenharia de máquinas). Ele foi projetado como um computador "pequena" para uso em aplicações de engenharia e científicos. Entre outras inovações, continha uma implementação em hardware de uma linguagem de programação de alto nível pode fazer cálculos com frações, polinômios, derivadas e integrais. Outra característica inovadora para a época era de que a interface de usuário combinado com um teclado, monitor e uma caneta de luz usado para escrever e editar texto na tela. Pode ser considerado como um dos primeiros computadores pessoais.
Fonte:
http://histinf.blogs.upv.es/2011/01/10/aproximacion-historia-info-urss/…
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
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
eypad 4x4 ligados direto sem resistores
Segue o programa:
int first = 0;int second = 0;
int caso = 0;
#include <Keypad.h>
#include <LiquidCrystal.h>//biblioteca do display
LiquidCrystal lcd(8, 9, 7, 6, 5, 4);
const byte ROWS = 4;
const byte COLS = 4;
// Define o Keypad (mapa do circuito do teclado).
char keys[ROWS][COLS] =
{
{'1', '2', '3', 'A'},
{'4', '5', '6', 'B'},
{'7', '8', '9', 'C'},
{'*', '0', '#', 'D'}
};
byte rowPins[ROWS] = { 31, 33, 35, 37 };
byte colPins[COLS] = { 39, 41, 43, 45 };
Keypad kpd = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); // Objeto do keypad
char tecla = kpd.getKey(); //Variavel para adquirir a tecla pressionada
void setup() {
lcd.begin(16, 2); //Inicia o LCD com dimensões 16x2(Colunas x Linhas)
}
void loop()
{
char tecla = kpd.getKey(); //Variavel para adquirir a tecla pressionada
switch (caso)
{
case 0:
lcd.setCursor(0, 0);
lcd.print ("MENU");
lcd.setCursor (0, 1);
lcd.print ("INSIRA O TAMANHO");
caso = 1;
break;
case 1:
switch (tecla)
{
case '0' ... '9': // Caso aperte teclas de 0 a 9 para definir o tamanho do fio
lcd.clear();
lcd.setCursor (0, 0);
lcd.print ("TAMANHO EM MM"); // Tamanho do fio a ser definido
lcd.setCursor(0, 1);
first = first * 10 + (tecla - '0'); // Conta para acumular digitos no lcd.print (ex:136)
lcd.print(first);
caso = 1;
break;
case '*': // Caso aperte * será como um "enter" e irá para o menu de quantidade de fios
caso = 2; // Outra tela do menu
lcd.clear();
lcd.setCursor(0, 0);
lcd.print ("INSIRA A QTDE"); // Quantidade de fios a ser definido
lcd.setCursor(0, 1);
second = second * 10 + (tecla - '0'); // Mesma conta para acumular digitos
lcd.print(second);
break;
}
}
}
A duvida é quando vou inserir a quantidade automaticamente o arduino joga o valor "-6" no campo de digitação e não consigo tirar de jeito nenhum.…
Adicionado por Lucas Cruz ao 8:50 em 6 dezembro 2016