Resultados da busca - %E3%80%90%E2%94%83%E6%8B%9B%E5%95%86%E9%83%A82%E2%92%8F7%E2%92%8F01705_%E6%89%A3%E3%80%91%E3%80%91%E5%8D%8E%E5%AE%87%E5%BD%A9%E7%A5%A8%E6%98%AF%E9%AA%97%E7%9A%84%E5%90%97
om 10 botoes, blz! fiz a montagem e envie o código que foi criado pelo dono do projeto ao Arduino e tudo funcionou perfeitamente, esta aplicação estou usando em minha casa para acionamento de cargas: lampadas tvs e ventiladores e etc... ate aqui tudo tranquilo, acesso pela internet via celular na rede interna e externa tudo perfeito. Agora vou falar o que preciso, eu não sei quase nada de programação da linguagem C++, criei um aplicativo no MIT Inventor 2 e gostaria de usar o meu próprio aplicativo, não sei como criar as regras nos código para enviar para ao arduino é nisso que gostaria da ajuda de meus caros amigos deste conceituado fórum, estou tentando ler algumas coisas sobre este assunto, mais ainda não cheguei a entender, por isso que venho aqui, tentar alguns esclarecimento se possível para acrescentar no desenvolvimento de meus conhecimentos para esta necessidade.
Segue abaixo aplicativo que criei para Android:
tem as duas imagens ON e OFF, pra quando eu clicar ela mudaria a imagem para ON e vise-verso
O aplicativo e o código a baixo é o que eu comprei na PlayStore e está funcionado perfeitamente, gostaria de poder trocar os nomes laterais aos botoes e personalizar de acordo com minhas necessidade. ex colocar o nome do primeiro botão ao invés de ser "A0 OUT 5V" para "GARAGEM" não sei se isto seria melhor, não sei onde estão estas informações no código. agradeço se me for esclarecido estas duvidas.
#include <SPI.h>
#include <String.h>
#include <Ethernet.h>
//-------------------------------------------------------------------
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED };//MAC padrão;
IPAddress ip(192, 168, 1, 120);//Define o endereco IPv4(trocar final);
IPAddress gateway(192, 168, 1, 1); //Define o gateway
IPAddress subnet(255, 255, 255, 0); //Define a máscara de rede
EthernetServer server(8090); // Porta de serviço
//-------------------------------------------------------------------
int AA0 = A0;//Arduino analogica A0;
int AA1 = A1;//Arduino analogica A1;
int AA2 = A2;//Arduino analogica A2;
int AA3 = A3;//Arduino analogica A3;
int AA4 = A4;//Arduino analogica A4;
//-------------------------------------------------------------------
int D2 = 2;//Arduino digital D2; int D3 = 3;//Arduino digital D3; int D4 = 4;//Arduino digital D4; int D5 = 5;//Arduino digital D5; int D6 = 6;//Arduino digital D6; //------------------------------------------------------------------- String readString = String(30); // string para buscar dados de endereço boolean statusA0 = false; // Variável para o status do led boolean statusA1 = false; // Variável para o status do led boolean statusA2 = false; // Variável para o status do led boolean statusA3 = false; // Variável para o status do led boolean statusA4 = false; // Variável para o status do led boolean statusD2 = false; // Variável para o status do led boolean statusD3 = false; // Variável para o status do led boolean statusD4 = false; // Variável para o status do led boolean statusD5 = false; // Variável para o status do led boolean statusD6 = false; // Variável para o status do led //-------------------------------------------------------------------- void setup(){ // Inicia o Ethernet //Ethernet.begin(mac, ip); Ethernet.begin(mac, ip, gateway, subnet); server.begin(); //-----------------------Define pino como saída----------------------- pinMode(AA0, OUTPUT); pinMode(AA1, OUTPUT); pinMode(AA2, OUTPUT); pinMode(AA3, OUTPUT); pinMode(AA4, OUTPUT); pinMode(D2, OUTPUT); pinMode(D3, OUTPUT); pinMode(D4, OUTPUT); pinMode(D5, OUTPUT); pinMode(D6, OUTPUT); //--------------------------------------------------------------------- // Inicia a comunicação Serial Serial.begin(9600); }
void loop(){ // Criar uma conexão de cliente EthernetClient client = server.available(); if (client) { while (client.connected()) { if (client.available()) { char c = client.read(); // ler caractere por caractere vindo do HTTP if (readString.length() < 30) { // armazena os caracteres para string readString += (c); } //se o pedido HTTP terminou if (c == '\n') { //------------------------------------------------------------------ if(readString.indexOf("a0high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA0, HIGH);//Arduino porta digital D2=5V; statusA0 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a0low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA0, LOW);//Arduino porta digital D2=0V; statusA0 = false; } //------------------------------------------------------------------ if(readString.indexOf("a1high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA1, HIGH);//Arduino porta digital D2=5V; statusA1 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a1low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA1, LOW);//Arduino porta digital D2=0V; statusA1 = false; } //------------------------------------------------------------------ if(readString.indexOf("a2high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA2, HIGH);//Arduino porta digital D2=5V; statusA2 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a2low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA2, LOW);//Arduino porta digital D2=0V; statusA2 = false; } //------------------------------------------------------------------ if(readString.indexOf("a3high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA3, HIGH);//Arduino porta digital D2=5V; statusA3 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a3low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA3, LOW);//Arduino porta digital D2=0V; statusA3 = false; } //------------------------------------------------------------------ if(readString.indexOf("a4high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(AA4, HIGH);//Arduino porta digital D2=5V; statusA4 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("a4low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(AA4, LOW);//Arduino porta digital D2=0V; statusA4 = false; } //------------------------------------------------------------------ if(readString.indexOf("d2high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D2, HIGH);//Arduino porta digital D2=5V; statusD2 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d2low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D2, LOW);//Arduino porta digital D2=0V; statusD2 = false; } //------------------------------------------------------------------ if(readString.indexOf("d3high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D3, HIGH);//Arduino porta digital D2=5V; statusD3 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d3low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D3, LOW);//Arduino porta digital D2=0V; statusD3 = false; } //------------------------------------------------------------------ if(readString.indexOf("d4high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D4, HIGH);//Arduino porta digital D2=5V; statusD4 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d4low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D4, LOW);//Arduino porta digital D2=0V; statusD4 = false; } //------------------------------------------------------------------ if(readString.indexOf("d5high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D5, HIGH);//Arduino porta digital D2=5V; statusD5 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d5low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D5, LOW);//Arduino porta digital D2=0V; statusD5 = false; } //------------------------------------------------------------------ if(readString.indexOf("d6high")>=0)//Recebido do Android; { // O Led vai ser ligado digitalWrite(D6, HIGH);//Arduino porta digital D2=5V; statusD6 = true; } // Se a string possui o texto L=Desligar if(readString.indexOf("d6low")>=0)//Recebido do Android; { // O Led vai ser desligado digitalWrite(D6, LOW);//Arduino porta digital D2=0V; statusD6 = false; } //------------------------------------------------------------------ // dados HTML de saída começando com cabeçalho padrão client.println("HTTP/1.1 200 OK"); client.println("Content-Type: text/html"); client.println(); client.print("<font size='20'>"); //------------------------------------------------------------------ if (statusA0) { client.print("azeroon");//Ethernet envia para Android; //String apenas letras; } else { client.print("azerooff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA1) { client.print("aoneon");//Ethernet envia para Android; //String apenas letras; } else { client.print("aoneoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA2) { client.print("atwoon");//Ethernet envia para Android; //String apenas letras; } else { client.print("atwooff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA3) { client.print("athreeon");//Ethernet envia para Android; //String apenas letras; } else { client.print("athreeoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusA4) { client.print("afouron");//Ethernet envia para Android; //String apenas letras; } else { client.print("afouroff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD2) { client.print("dtwoon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dtwooff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD3) { client.print("dthreeon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dthreeoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD4) { client.print("dfouron");//Ethernet envia para Android; //String apenas letras; } else { client.print("dfouroff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD5) { client.print("dfiveon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dfiveoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ if (statusD6) { client.print("dsixon");//Ethernet envia para Android; //String apenas letras; } else { client.print("dsixoff");//Ethernet envia string para Android; //String apenas letras; } //------------------------------------------------------------------ //limpa string para a próxima leitura readString=""; // parar cliente client.stop(); } } } } }…
uestão aqui é qual é a natureza do sinal que ele está aquisitando. Ou seja, qual a frequência do sinal que ele está aquisitando via ADC do Due. A amplitude ele já deve ter tratado adequadamente, uma vez que ele já vê o sinal na Serial Plotter da IDE do Arduino. Mas nada sabemos sobre a frequência do sinal.
Conhecendo a frequência do sinal é possível determinar a técnica mais adequada para a aquisição e posterior visualização do sinal aquisitado. E claro, aí entra a Frequência de Nyquist, e conhecendo a mesma é possível determinar qual a menor Taxa de Amostragem para a aquisição, mantendo a qualidade desejada para a reprodução digital do sinal.
Veja: o loop de aquisição do Thiago funciona a "todo vapor", na máxima velocidade que o Due permite (Hardware e Firmware). O ADC do Due tem uma taxa de conversão máxima de 1MHz, ou seja, resulta em 1 Mega sample por segundo. Considerando que o Due utiliza um ARM, e que o Compilador C++ tenha gerado um código com "boa" performance, é quase certo que o loop de conversão gastará para ser executado um tempo igual a 1000 / 1MHz = 1 ms , ou seja, 1 mili-segundo. E isto seria "adequado" para um sinal de no máximo 500kHz e com um Processamento de Sinal também adequado (aplicando técnicas para a reconstituição do sinal). Caso nenhum Processamento de Sinal seja aplicado, como é o caso do Thiago, então temos que reduzir drasticamente a faixa de frequência do sinal, tipo 10 a 20 vezes menor que a Frequência de Nyquist, para que seja algo apresentável na tela do Serial Plotter.
Mas aqui entra o outro problema: cada "println" no loop de "printagem" dos 1000 valores aquisitados, enviará em média, 6 caracteres ASCII para a serial. Desses 6 caracteres, 4 são considerando valores convertidos da ordem de 4 dígitos decimais, ou seja, entre 1000 e 4095 (o ADC do Due tem 12 bits). Não se pode aqui considerar nessa estimativa, valores inferiores a 1000 (que resultariam em 3, 2, ou 1 caracter ASCII para o valor do sample), pois são apenas 1/4 da faixa total, e assim representam 25% da probabilidade (e portanto errôneo considerar isso numa estimativa "grosseira", que é o caso que estou fazendo). Os outros 2 caracteres ASCII, são o "CR" e o "LF" resultantes do "println".
Logo, para cada "println", em média teremos 6 caracteres ASCII sendo enviados pela Serial. Como a taxa da Serial está em 115200, e cada caractere ocupa 10 bits (1 start bit, 8 data, 1 stop bit), o tempo total necessário para o envio de cada valor via Serial, será igual a 6 * 10 / 115200 = 0.00052 segundos, ou 0.52 ms (aproximadamente meio mili-segundo). Então aparentemente, multiplicando esse tempo por 1000, teremos o total gasto para enviar todas as 1000 amostras = 0.52 segundos (cerca de meio segundo).
Infelizmente, a coisa é um pouco pior. Vou explicar porquê. Quando vc "manda" enviar um byte via Serial, o firmware do Due verifica se o TX da UART (Hardware) está livre, e caso esteja, o byte é transferido direto para o Registro do TX da UART. Mas se o TX já está ocupado transmitindo, então o firmware coloca o byte no Queue do TX da Serial, e este byte será automaticamente transmitido quando o TX ficar livre. Ocorre que o Queue do TX da Serial do Due, tem capacidade para 128 bytes, ou seja, 128 caracteres. Uma vez que um byte tenha sido enviado ao TX da UART, esse byte demorará 87us (87 micro-segundos = resultado de 10 / 115200) para ser enviado. Obviamente que todo o loop de envio não demorará mais que esse tempo (lembrando que é um ARM), então certamente o Queue de 128 bytes ficará entupido após algum tempo (perfeitamente calculável, analisando as iterações iniciais), e quando isso ocorre, o firmware do Due empaca (há um teste no código da Serial que causa isso intencionalmente), e então fica aguardando que o Queue fique pelo menos um byte livre. Mas claro, assim que essa "vaga" fica livre no Queue, ele já entope de novo com o próximo byte que estava esperando para entrar neste Queue do TX.
Em suma: após uma quantidade de caracteres um pouco maior que 128, o Queue do TX da Serial ficará permanentemente entupido no loop de envio, no código do Thiago. E aí a função "println" trava pelo tempo de envio de todos os demais caracteres que restam para serem enviados. Lembrando que cada valor "impresso" via "println", irá gerar em média 6 caracteres, resultando um total de 6 mil caracteres para serem enviados. Então os cerca de um pouco mais de 128 bytes necessários para o entupimento do Queue do TX da Serial, e a consequente "lerdeza" na execução do loop onde está o "println", é uma parcela pequena se comparada aos 6 mil caracteres que serão enviados. Ou seja, um grande problema para a descontinuidade da aquisição de samples, se a frequência do sinal aquisitado for tal que o entupimento do Queue cause uma descaracterização do sinal visto no Serial Plotter.
Claro, sempre é possível usar técnicas de contorno. Mas é preciso saber qual a natureza do sinal aquisitado, especificamente sua faixa de frequência.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 16:50 em 23 setembro 2020
o o primeiro o modo estaconário, o segundo o modo LDR, e o terceiro entra no modo RTC DS 1302.
A lógica é a seguinte: no modo LDR ele faz a varredura pela diferença entre os LDRs e faz o movimento dos motores de modo a posicionar o módulo em direção ao sol, (essa parte está ok). O modo RTC vai ter 12 posicoes pré determinadas, dependendo apenas da hora do dia (ESSA PARTE É O PROBLEMA), já o modo estacionário vai ficar parado em uma inclinação especifica(ESSA PARTE ESTÀ OK). A idéia por tras disso é a seguinte: a cada hora vou medir corrente e tensão no módulo, e quero comparar a eficiencia dos 3 modos distintos. Estou utilizando Arduino UNO, DVR 8825 controlador de motor de passo LDRs e DS 1302 RTC. O Código está assim por enquanto;
#include <AccelStepper.h>#include <ThreeWire.h>#include <RtcDS1302.h>
// Pinos dos sensores LDR
int ldrLeftTopPin = A2; // amaint ldrLeftBottomPin = A0; // verint ldrRightTopPin = A3; // larint ldrRightBottomPin = A1; // preint limiar = 20; // Valor para corrigir diferença entre os LDR'sint Vel = 500; // Velocidade do motor em passos por segudoint MaxSpeed = 1000; // Velocidade máxima que o motor pode atingirint Acelera = 500; // Aceleração dos motoresint modo = 0;// 0 = Estacionário, 1 = LDR, 2 = DS1302int BUTTON_PIN = 7; // Pino do botãoconst int NUM_MODOS = 3;
// Pinos dos motores de passo#define azimuthDirPin 2#define azimuthStepPin 3#define elevationDirPin 4#define elevationStepPin 5#define motorInterfaceType 1 //Motor com dois fios para cada bobina (2 bobinas)
// Pinos RTC#define DS1302_RST 8#define DS1302_DAT 9#define DS1302_CLK 10
// Instância da ligação e do RTCThreeWire ligacao(DS1302_DAT, DS1302_CLK, DS1302_RST);RtcDS1302<ThreeWire> rtc(ligacao);bool buttonWasPressed = false;bool buttonState = false;bool lastButtonState = false;unsigned long lastDebounceTime = 0;unsigned long debounceDelay = 50;
// Instância da classe AccelStepper para cada motorAccelStepper azimuthStepper(motorInterfaceType, azimuthStepPin, azimuthDirPin);AccelStepper elevationStepper(motorInterfaceType, elevationStepPin, elevationDirPin);
void setup() { // Inicia a comunicação serial Serial.begin(9600); // Velocidade máxima em passos por segundo para ambos os motores azimuthStepper.setMaxSpeed(MaxSpeed); azimuthStepper.setAcceleration(Acelera); elevationStepper.setMaxSpeed(MaxSpeed); elevationStepper.setAcceleration(Acelera); pinMode(BUTTON_PIN, INPUT_PULLUP); // Inicia a comunicação com o RTC rtc.Begin(); // Desabilita a proteção contra escrita para gravar a hora e data if (rtc.GetIsWriteProtected()) { rtc.SetIsWriteProtected(false); }
// Se não estava rodando, começa a funcionar if (!rtc.GetIsRunning()) { rtc.SetIsRunning(true); // Obtém o valor da hora quando o código foi compilado RtcDateTime compiled = RtcDateTime(__DATE__, __TIME__); rtc.SetDateTime(compiled); // Para definir um formato personalizado, você pode fazer o seguinte: // O mês precisa ter 3 letras abreviando o nome do mês em inglês (no exemplo abaixo é fevereiro) //RtcDateTime teste = RtcDateTime("Feb 12 2022", "19:32:45"); //rtc.SetDateTime(teste); }}
void loop() { unsigned long currentMillis = millis(); buttonState = digitalRead(BUTTON_PIN);
if (buttonState != lastButtonState) { lastDebounceTime = currentMillis; }
if ((currentMillis - lastDebounceTime) > debounceDelay) { if (buttonState != buttonWasPressed) { buttonWasPressed = buttonState;
if (buttonWasPressed) { // Botão pressionado, alterna entre os modos modo = (modo + 1) % NUM_MODOS; } } }
lastButtonState = buttonState; switch (modo) { case 0: // Modo Estacionário // Coloque o código para o modo estacionário aqui Serial.print("MODO : " ); // Mostra o valor no monitor serial Serial.println(modo); break;
case 1: // Modo LDR Serial.print("MODO : " ); // Mostra o valor no monitor serial Serial.println(modo); // Leitura dos sensores LDR int ldrLeftTopValue = analogRead(ldrLeftTopPin); int ldrLeftBottomValue = analogRead(ldrLeftBottomPin); int ldrRightTopValue = analogRead(ldrRightTopPin); int ldrRightBottomValue = analogRead(ldrRightBottomPin);
// Calculando as diferenças para ambos os eixos int azimuthDifference = (ldrLeftTopValue - ldrRightTopValue) + (ldrLeftBottomValue - ldrRightBottomValue); int elevationDifference = (ldrLeftTopValue - ldrLeftBottomValue) + (ldrRightTopValue - ldrRightBottomValue); // Ajustando a posição dos motores de passo com base nas diferenças dos sensores if (abs(azimuthDifference) > limiar) { // Limiar de diferença para evitar pequenos movimentos if (azimuthDifference > 0) { // Mova o motor de passo de azimuth para a esquerda azimuthStepper.setSpeed(Vel); azimuthStepper.runSpeed(); // Move o motor } else { // Mova o motor de passo de azimuth para a direita azimuthStepper.setSpeed(-Vel); // (sentido inverso) azimuthStepper.runSpeed(); // Move o motor } }
if (abs(elevationDifference) > limiar) { // Limiar de diferença para evitar pequenos movimentos if (elevationDifference > 0) { // Mova o motor de passo de elevação para cima elevationStepper.setSpeed(Vel); // elevationStepper.runSpeed(); // Move o motor } else { // Mova o motor de passo de elevação para baixo elevationStepper.setSpeed(-Vel); // (sentido inverso) elevationStepper.runSpeed(); // Move o motor } } break; case 2: // Modo DS1302 Serial.print("MODO : " ); // Mostra o valor no monitor serial Serial.println(modo); // Obtem a data e hora e imprime os valores RtcDateTime now = rtc.GetDateTime();
Serial.print(now.Day()); Serial.print("/"); Serial.print(now.Month()); Serial.print("/"); Serial.println(now.Year());
Serial.print(now.Hour()); Serial.print(":"); Serial.print(now.Minute()); Serial.print(":"); Serial.println(now.Second());
// Dia da semana (1 a 7, sendo 1 = segunda e 7 = domingo) Serial.println(now.DayOfWeek()); delay(50); break; }}…
ggable controllers, meaning //you must always either restart your Arduino after you conect the controller, //or call config_gamepad(pins) again after connecting the controller.int error = 0; byte type = 0;byte vibrate = 0;
const int stepsPerRevolution = 200; // numero de passos totais do motor// initialize the stepper library on pins 8 through 11:Stepper myStepper(stepsPerRevolution, A0, A1, A2, A3);
//Declaração dos Leds int LEDy = 9; int LEDx = 6; int LEDX = 5; int LEDY = 3; int brilloLedY = 0; // variable para guardar el valor con el que se iluminara el led int brilloLedx = 0; // variable para guardar el valor con el que se iluminara el led int brilloLedX = 0; // variable para guardar el valor con el que se iluminara el led int brilloLedy = 0; // variable para guardar el valor con el que se iluminara el led
void setup(){ Serial.begin(57600); // set the speed at 30 rpm: myStepper.setSpeed(150);
//Definição de LedspinMode(LEDX, OUTPUT);pinMode(LEDx, OUTPUT);pinMode(LEDY, OUTPUT);pinMode(LEDy, OUTPUT);
//CHANGES for v1.6 HERE!!! **************PAY ATTENTION************* error = ps2x.config_gamepad(13,11,10,12, true, true); //setup pins and settings: GamePad(clock, command, attention, data, Pressures?, Rumble?) check for error if(error == 0){ Serial.println("Found Controller, configured successful"); Serial.println("Try out all the buttons, X will vibrate the controller, faster as you press harder;"); Serial.println("holding L1 or R1 will print out the analog stick values."); Serial.println("Go to www.billporter.info for updates and to report bugs."); } else if(error == 1) Serial.println("No controller found, check wiring, see readme.txt to enable debug. visit www.billporter.info for troubleshooting tips"); else if(error == 2) Serial.println("Controller found but not accepting commands. see readme.txt to enable debug. Visit www.billporter.info for troubleshooting tips"); else if(error == 3) Serial.println("Controller refusing to enter Pressures mode, may not support it. "); //Serial.print(ps2x.Analog(1), HEX); type = ps2x.readType(); switch(type) { case 0: Serial.println("Unknown Controller type"); break; case 1: Serial.println("DualShock Controller Found"); break; case 2: Serial.println("GuitarHero Controller Found"); break; } }
void loop(){ /* You must Read Gamepad to get new values Read GamePad and set vibration values ps2x.read_gamepad(small motor on/off, larger motor strenght from 0-255) if you don't enable the rumble, use ps2x.read_gamepad(); with no values you should call this at least once a second */ if(error == 1) //skip loop if no controller found return; if(type == 2){ //Guitar Hero Controller ps2x.read_gamepad(); //read controller if(ps2x.ButtonPressed(GREEN_FRET)) Serial.println("Green Fret Pressed"); if(ps2x.ButtonPressed(RED_FRET)) Serial.println("Red Fret Pressed"); if(ps2x.ButtonPressed(YELLOW_FRET)) Serial.println("Yellow Fret Pressed"); if(ps2x.ButtonPressed(BLUE_FRET)) Serial.println("Blue Fret Pressed"); if(ps2x.ButtonPressed(ORANGE_FRET)) Serial.println("Orange Fret Pressed");
if(ps2x.ButtonPressed(STAR_POWER)) Serial.println("Star Power Command"); if(ps2x.Button(UP_STRUM)) //will be TRUE as long as button is pressed Serial.println("Up Strum"); if(ps2x.Button(DOWN_STRUM)) Serial.println("DOWN Strum"); if(ps2x.Button(PSB_START)) //will be TRUE as long as button is pressed Serial.println("Start is being held"); if(ps2x.Button(PSB_SELECT)) Serial.println("Select is being held");
if(ps2x.Button(ORANGE_FRET)) // print stick value IF TRUE { Serial.print("Wammy Bar Position:"); Serial.println(ps2x.Analog(WHAMMY_BAR), DEC); } }
else { //DualShock Controller ps2x.read_gamepad(false, vibrate); //read controller and set large motor to spin at 'vibrate' speed if(ps2x.Button(PSB_START)) //will be TRUE as long as button is pressed Serial.println("Start is being held"); if(ps2x.Button(PSB_SELECT)) Serial.println("Select is being held"); /* if(ps2x.Button(PSB_PAD_UP)) { //will be TRUE as long as button is pressed Serial.print("Up held this hard: "); Serial.println(ps2x.Analog(PSAB_PAD_UP), DEC); } if(ps2x.Button(PSB_PAD_RIGHT)){ Serial.print("Right held this hard: "); Serial.println(ps2x.Analog(PSAB_PAD_RIGHT), DEC); } if(ps2x.Button(PSB_PAD_LEFT)){ Serial.print("LEFT held this hard: "); Serial.println(ps2x.Analog(PSAB_PAD_LEFT), DEC); } if(ps2x.Button(PSB_PAD_DOWN)){ Serial.print("DOWN held this hard: "); Serial.println(ps2x.Analog(PSAB_PAD_DOWN), DEC); } */ vibrate = ps2x.Analog(PSAB_BLUE); //this will set the large motor vibrate speed based on //how hard you press the blue (X) button if (ps2x.NewButtonState()) //will be TRUE if any button changes state (on to off, or off to on) { if(ps2x.Button(PSB_L3)) Serial.println("L3 pressed"); if(ps2x.Button(PSB_R3)) Serial.println("R3 pressed"); if(ps2x.Button(PSB_L2)) Serial.println("L2 pressed"); if(ps2x.Button(PSB_R2)) Serial.println("R2 pressed"); if(ps2x.Button(PSB_GREEN)) Serial.println("Triangle pressed"); } if(ps2x.ButtonPressed(PSB_RED)) //will be TRUE if button was JUST pressed Serial.println("Circle just pressed"); if(ps2x.ButtonReleased(PSB_PINK)) //will be TRUE if button was JUST released Serial.println("Square just released"); if(ps2x.NewButtonState(PSB_BLUE)) //will be TRUE if button was JUST pressed OR released Serial.println("X just changed"); if(ps2x.Button(PSB_L1) || ps2x.Button(PSB_R1)) // print stick values if either is TRUE { Serial.print("Stick Values:"); Serial.print(ps2x.Analog(PSS_LY), DEC); //Left stick, Y axis. Other options: LX, RY, RX Serial.print(","); Serial.print(ps2x.Analog(PSS_LX), DEC); Serial.print(","); Serial.print(ps2x.Analog(PSS_RY), DEC); Serial.print(","); Serial.println(ps2x.Analog(PSS_RX), DEC); } //fim do if(ps2x...)
//Transforma este valor en el valor que usaremos para el led Para ello usaremos la funcion map() int a = map(ps2x.Analog(PSS_LY), 100, 1, 4, 250); if(a > 0){ brilloLedY = a;}else{brilloLedY = 0;} analogWrite(LEDY, brilloLedY); if(brilloLedY > 0 && brilloLedY < 100){ // step one revolution in one direction: myStepper.step(1); } if(brilloLedY >= 100 && brilloLedY <= 255){ // step one revolution in one direction: myStepper.step(20); } //Transforma este valor en el valor que usaremos para el led Para ello usaremos la funcion map() int b = map(ps2x.Analog(PSS_LY), 155, 255, 4, 255); if(b > 0 && b< 256){ brilloLedy = b;}else{brilloLedy = 0;} analogWrite(LEDy, brilloLedy); if(brilloLedy > 0 && brilloLedy < 100){ // step one revolution in one direction: myStepper.step(-1); } if(brilloLedy >= 100 && brilloLedy <= 255){ // step one revolution in one direction: myStepper.step(-20); } //Transforma este valor en el valor que usaremos para el led Para ello usaremos la funcion map() int c = map(ps2x.Analog(PSS_LX), 100, 1, 4, 250); if(c > 0){ brilloLedx = c;}else{brilloLedx = 0;} analogWrite(LEDx, brilloLedx); //Transforma este valor en el valor que usaremos para el led Para ello usaremos la funcion map() int d = map(ps2x.Analog(PSS_LX), 155, 255, 4, 255); if(d > 0 && b< 256){ brilloLedX = d;}else{brilloLedX = 0;} analogWrite(LEDX, brilloLedX); Serial.println(brilloLedy); }//fim do else dualshockcontroller delay(5); }…
duino (Atmega328), porém como a funcionalidade delas parece genérica (ou seja, vc pode conectar a uma infinidade de fontes de sinais diferentes), e portanto podem conter "spikes" originários de outros equipamentos externos ao seu circuito, estarei provendo uma proteção também genérica. Essa proteção genérica é bem efetiva, mas claro não é "indestrutível", e dependendo do que vc ligue ali (por exemplo um sinal que tenha energia bem alta, e não estou falando de tensão, e sim de energia!!!), pode ser necessário uma proteção mais "reforçada", usando opto-acopladores por exemplo).
Assim, segue a sugestão de proteção na figura a seguir (clique na figura para "zoom"):
Note que seu circuito original do "SCT-013", está na região "amarelo claro" da figura, e veja que mantive as referências dos componentes exatamente como estava no seu circuito original (R21, R22, etc).
Na região "azul claro", está o circuito de proteção para "A3", contra eventuais sinais danosos vindos do sensor SCT (que podem ocorrer se vc "abrir" o sensor, ou se ocorrer um distúrbio na rede elétrica induzindo um "spike" muito alto no secundário do sensor).
Observe que vc pode eliminar "R102" e "R103". Neste caso, "R102" seria substituído por um "curto", e "R103" não seria montado. Mas acho de bom senso vc manter os dois, pois dará flexibilidade maior ao seu sistema (além de prover um loop fechado para o circuito de polarização do sensor).
Já na região "rosa claro", está o circuito de proteção para uma entrada digital. Observe que é bem parecido com o anterior, e o que mudam são os valores dos resistores, que agora são adequados para sinais digitais.
Sobre esse circuito para a entrada digital, você não deve montar "R203" se estiver usando a configuração "INPUT_PULLUP" para a entrada. Só monte "R203" se vc estiver usando a configuração "INPUT" apenas.
Já "R202" pode ser eliminado (substituído por um "curto"), mas ele provém uma proteção adicional para a entrada, então se vc o manter será mais eficiente a proteção.
Veja que no circuito que publiquei acima, desenhei o circuito de proteção para apenas uma entrada digital. Mas cada entrada deve ter seu próprio circuito individual.
No geral: preste atenção aos valores dos componentes que coloquei nos circuitos de proteção (se tiver alguma dúvida sobre os valores, pergunte). Para "R101" e "R201", se possível use resistores de 1/4 W (250 mW). Já os demais resistores podem ser de 1/8 W ou menor ainda.
Uma sugestão adicional: vi que vc está usando o 74HC595. Se for possível, use o 74HC594, que possui a mesma pinagem do "595". A diferença, é que vc pode prover um circuito de "PUC" (Power Up Clear). Isso vai impedir que seus Relés acionem acidentalmente quando vc ligar a alimentação do Sistema. A única diferença na pinagem entre o "594" e o "595", é o pino "13", que no "595" tem a função "OE#", enquanto no "594" tem a função "RCLR#" (também chamado de "PCLR#"). Este circuito é mostrado a seguir:
Observe que se vc tiver vários "594", precisa ter apenas um circuito "PUC" para todos eles, conectando a saída do "PUC" ao pino "13" de todos os "594".
Caso queira comparar, seguem os circuitos lógicos do "594" e "595" (veja que marquei a diferença dos sinais do pino "13"):
Infelizmente, o pessoal por aí afora viciou no "595", e usa o mesmo em circuitos onde o "594" é uma opção melhor (devido ao "PUC"). O que ocorre é que o "595" foi projetado para aplicações de barramento "tri-state", o que não é o caso de 99,9% dos casos que tenho visto por aí em tudo que é lugar. Vai ser difícil aprenderem sobre isso.
Espero ter ajudado.
Abrçs,
Elcids
…
Adicionado por Elcids Chagas ao 21:14 em 4 fevereiro 2019