asil de R$ 1.000,00 , eu acho que o projeto já começa a ficar viavel... desde que encontre pessoas dispostas a pagar...rsrsrsrs
Item
Qte
Descrição
V. Unit
Tot
1
1
CI Drive, irs2334
$6.44
$6.44
2
6
IGBTs , irgr4045d
$3.16
$18.96
3
1
Placas de CI
$25.00
$25.00
4
1
Fonte SW 15 VDC (20W)
$30.00
$30.00
Total Geral
$ 80.4
…
o codigo aqui, se alguem puder me ajudar agradeço muito. Obrigado.
#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, 50);//Define o endereco IPv4(trocar final);IPAddress gateway(192, 168, 1, 1); //Define o gatewayIPAddress subnet(255, 255, 255, 0); //Define a máscara de redeEthernetServer server(80); // 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çoboolean 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(); } } } }}//--------------------------------------------------------------------------------------------------------//…
.
E finalmente analisei o código que vc postou aqui (o "ADS1115.ino"), e encontrei diversos problemas nele.
Seguem considerações e questionamentos:
1) no código não há uma Taxa de Amostragem funcional. Ou seja: vc não está fazendo as Amostragens como deveria para se obter a melhor qualidade do sinal sendo aquisitado (na realidade, lamento em dizer que a forma que vc está fazendo a amostragem naquele código, está completamente incorreta).
Obs.: não adianta vc simplesmente acrescentar no seu código o comando que eu informei (o "setDataRate"), porque sem entender os detalhes de como a amostragem funciona no ADS1115, não é possível obter um resultado consistente.
Para se conseguir um resultado realmente efetivo, vc deve programar a Taxa de Amostragem no ADS1115, e então escolher a forma como vc usará isto. Para o seu caso, que está medindo sinais de frequência muito baixa, eu acredito que a melhor opção é usar a técnica descrita na figura a seguir, no texto que marquei em azul:
(clique na figura para "zoom")
Se vc não souber como fazer esta implementação, me avise que mostrarei como.
2) no seu código, quando um LED indicador de Tolerância é ligado, ele não mais é desligado em nenhum momento. Por que esse comportamento?
Por acaso, vc sempre Reseta o Arduino após um teste de tolerância, para poder iniciar o próximo teste?
3) no código, há diversas Bibliotecas que não estão sendo usadas. Vc realmente vai usá-las em algum momento?
4) há diversos problemas de organização funcional no seu código. Algumas funções estão misturadas, e algumas tem nomes que não refletem o que realmente está sendo feito naquelas funções. Isto não é bom, principalmente se vc pretende ir evoluindo e atualizando este código.
5) um ESP32 está na imagem que vc postou das conexões no Hardware. Mas afinal, qual Placa de Arduino vc está realmente usando no Hardware?
Dica: toda vez que vc postar questões no LDG, certifique-se de que vc disse claramente qual placa Arduino vc está usando.
Se vc esclarecer as questões que coloquei, eu posso alterar o seu código postado (ou outro que vc designar), de forma que realmente funcione a Amostragem, obtendo os melhores resultados possíveis, e também organizar e comentar o código de forma que ele realmente seja manuseável e faça sentido.
Agora falando sobre seu último teste.
O problema ali é que suas conversões estão sofrendo do efeito da "Injeção de Carga" nos circuitos internos do ADS1115, e esse efeito ocorre quando vc troca o canal no Multiplexador interno do Conversor (o ADS1115). Veja: a "Injeção de Carga" sempre existe em todos os Conversores A/D que tem um Multiplexador para seleção do canal a ser convertido. Mas a questão é: quanto desse efeito chegará até vc? Ou seja: é preciso usar a técnica correta para minimizar aquele efeito nocivo.
Veja: por motivos um tanto óbvios, os Fabricantes de Chips odeiam falar nesse assunto: "Injeção de Carga" (a maioria nem toca no assunto). Então vc jamais pode esquecer disso e de usar o tratamento adequado para minimizar o efeito.
Vc não informou quais são as Impedâncias de Saída dos seus Sensores (seja o "Vacuostato", seja o próprio divisor de tensão pois vc não informou exatamente quais são os Resistores ali usados - e é possível que vc esteja usando valores inadequados). Veja: conhecer a faixa de valor dessas Impedâncias, é crucial para se obter bons resultados na Amostragem.
Mas mesmo sem ter informação dessas Impedâncias, irei postar uma adequação para seu sinal. Esta adequação é mostrada na figura a seguir:
(clique na figura para "zoom")
A figura é clara sobre como usar a adequação. Simplesmente seu sinal deve ser conectado ao circuito mostrado, e então a saída deste circuito vai à entrada do ADS1115. Eu calculei os valores dos componentes, baseado no fato de que vc está aquisitando sinais de baixa frequência (Pressão e derivados). Importante: no circuito, C1 deve ser obrigatoriamente do tipo Cerâmico (não serve o tipo Poliéster Metalizado !!!).
Note: a figura mostra o circuito para uma entrada do ADS1115. Se vc usar outras entradas, replique o mesmo circuito para cada uma dessas entradas. Se a frequência dos demais sinais for outra completamente diferente, então o circuito deve ser recalculado (ou até modificado).
Para um teste semelhante ao que vc descreveu no seu último post, aplique o circuito a apenas uma das entradas do ADS1115, e então aplique a tensão de 3.3V à entrada deste circuito. Também aplique 3.3V diretamente a outras duas entradas do ADS1115. Na quarta entrada aplique diretamente 5V. Então simplesmente rode seu código para poder ver os valores convertidos.
Muito Importante: neste teste, a tensão de alimentação do ADS1115 deve ser de 5V. Também garanta que o seu código esteja selecionando Ganho igual a 1 para o ADS1115 (pois se o ganho for maior que "1", ocorrerá saturação no sinal dentro do ADS, comprometendo o teste e resultados).
Fico no aguardo, para poder contribuir na evolução do seu Sistema.
Abrçs,
Elcids…
Adicionado por Elcids Chagas ao 1:13 em 2 fevereiro 2022
DDLE NOZZLE_CLEAN_START_POINT
// Moves the nozzle to the initial position #define NOZZLE_CLEAN_GOBACK #endif
/** * Print Job Timer * * Automatically start and stop the print job timer on M104/M109/M190. * * M104 (hotend, no wait) - high temp = none, low temp = stop timer * M109 (hotend, wait) - high temp = start timer, low temp = stop timer * M190 (bed, wait) - high temp = start timer, low temp = none * * The timer can also be controlled with the following commands: * * M75 - Start the print job timer * M76 - Pause the print job timer * M77 - Stop the print job timer */ #define PRINTJOB_TIMER_AUTOSTART
/** * Print Counter * * Track statistical data such as: * * - Total print jobs * - Total successful print jobs * - Total failed print jobs * - Total time printing * * View the current statistics with M78. */ #define PRINTCOUNTER // habilita possibilidade de ver as estatisticas de impressao
//============================================================================= //============================= LCD and SD support ============================ //=============================================================================
// @section lcd
/** * LCD LANGUAGE * * Select the language to display on the LCD. These languages are available: * * en, an, bg, ca, cn, cz, cz_utf8, de, el, el-gr, es, es_utf8, * eu, fi, fr, fr_utf8, gl, hr, it, kana, kana_utf8, nl, pl, pt, * pt_utf8, pt-br, pt-br_utf8, ru, sk_utf8, tr, uk, zh_CN, zh_TW, test * * :{ 'en':'English', 'an':'Aragonese', 'bg':'Bulgarian', 'ca':'Catalan', 'cn':'Chinese', 'cz':'Czech', 'cz_utf8':'Czech (UTF8)', 'de':'German', 'el':'Greek', 'el-gr':'Greek (Greece)', 'es':'Spanish', 'es_utf8':'Spanish (UTF8)', 'eu':'Basque-Euskera', 'fi':'Finnish', 'fr':'French', 'fr_utf8':'French (UTF8)', 'gl':'Galician', 'hr':'Croatian', 'it':'Italian', 'kana':'Japanese', 'kana_utf8':'Japanese (UTF8)', 'nl':'Dutch', 'pl':'Polish', 'pt':'Portuguese', 'pt-br':'Portuguese (Brazilian)', 'pt-br_utf8':'Portuguese (Brazilian UTF8)', 'pt_utf8':'Portuguese (UTF8)', 'ru':'Russian', 'sk_utf8':'Slovak (UTF8)', 'tr':'Turkish', 'uk':'Ukrainian', 'zh_CN':'Chinese (Simplified)', 'zh_TW':'Chinese (Taiwan)', 'test':'TEST' } */ #define LCD_LANGUAGE pt-br
/** * LCD Character Set * * Note: This option is NOT applicable to Graphical Displays. * * All character-based LCDs provide ASCII plus one of these * language extensions: * * - JAPANESE ... the most common * - WESTERN ... with more accented characters * - CYRILLIC ... for the Russian language * * To determine the language extension installed on your controller: * * - Compile and upload with LCD_LANGUAGE set to 'test' * - Click the controller to view the LCD menu * - The LCD will display Japanese, Western, or Cyrillic text * * See http://marlinfw.org/docs/development/lcd_language.html * * :['JAPANESE', 'WESTERN', 'CYRILLIC'] */ #define DISPLAY_CHARSET_HD44780 JAPANESE // este diplay e o que uso habitualmente
/** * SD CARD * * SD Card support is disabled by default. If your controller has an SD slot, * you must uncomment the following option or it won't work. * */ #define SDSUPPORT // descomentar para ter acesso ao cartao SD
/** * SD CARD: SPI SPEED * * Enable one of the following items for a slower SPI transfer speed. * This may be required to resolve "volume init" errors. */ //#define SPI_SPEED SPI_HALF_SPEED //#define SPI_SPEED SPI_QUARTER_SPEED //#define SPI_SPEED SPI_EIGHTH_SPEED
/** * SD CARD: ENABLE CRC * * Use CRC checks and retries on the SD communication. */ //#define SD_CHECK_AND_RETRY
/** * LCD Menu Items * * Disable all menus and only display the Status Screen, or * just remove some extraneous menu items to recover space. */ //#define NO_LCD_MENUS //#define SLIM_LCD_MENUS
// // ENCODER SETTINGS // // This option overrides the default number of encoder pulses needed to // produce one step. Should be increased for high-resolution encoders. // //#define ENCODER_PULSES_PER_STEP 4
// // Use this option to override the number of step signals required to // move between next/prev menu items. // //#define ENCODER_STEPS_PER_MENU_ITEM 1
/** * Encoder Direction Options * * Test your encoder's behavior first with both options disabled. * * Reversed Value Edit and Menu Nav? Enable REVERSE_ENCODER_DIRECTION. * Reversed Menu Navigation only? Enable REVERSE_MENU_DIRECTION. * Reversed Value Editing only? Enable BOTH options. */
// // This option reverses the encoder direction everywhere. // // Set this option if CLOCKWISE causes values to DECREASE // //#define REVERSE_ENCODER_DIRECTION
// // This option reverses the encoder direction for navigating LCD menus. // // If CLOCKWISE normally moves DOWN this makes it go UP. // If CLOCKWISE normally moves UP this makes it go DOWN. // #define REVERSE_MENU_DIRECTION // inverse o comando do botão do painel de controle
// // Individual Axis Homing // // Add individual axis homing items (Home X, Home Y, and Home Z) to the LCD menu. // //#define INDIVIDUAL_AXIS_HOMING_MENU
// // SPEAKER/BUZZER // // If you have a speaker that can produce tones, enable it here. // By default Marlin assumes you have a buzzer with a fixed frequency. // #define SPEAKER
// // The duration and frequency for the UI feedback sound. // Set these to 0 to disable audio feedback in the LCD menus. // // Note: Test audio output with the G-Code: // M300 S<frequency Hz> P<duration ms> // //#define LCD_FEEDBACK_FREQUENCY_DURATION_MS 2 //#define LCD_FEEDBACK_FREQUENCY_HZ 5000
//============================================================================= //======================== LCD / Controller Selection ========================= //======================== (Character-based LCDs) ========================= //=============================================================================
// // RepRapDiscount Smart Controller. // http://reprap.org/wiki/RepRapDiscount_Smart_Controller // // Note: Usually sold with a white PCB. // #define REPRAP_DISCOUNT_SMART_CONTROLLER // LCD usado na minha impressora
// // ULTIMAKER Controller. // //#define ULTIMAKERCONTROLLER
// // ULTIPANEL as seen on Thingiverse. // //#define ULTIPANEL
// // PanelOne from T3P3 (via RAMPS 1.4 AUX2/AUX3) // http://reprap.org/wiki/PanelOne // //#define PANEL_ONE
// // GADGETS3D G3D LCD/SD Controller // http://reprap.org/wiki/RAMPS_1.3/1.4_GADGETS3D_Shield_with_Panel // // Note: Usually sold with a blue PCB. // //#define G3D_PANEL
// // RigidBot Panel V1.0 // http://www.inventapart.com/ // //#define RIGIDBOT_PANEL
// // Makeboard 3D Printer Parts 3D Printer Mini Display 1602 Mini Controller // https://www.aliexpress.com/item/Micromake-Makeboard-3D-Printer-Parts-3D-Printer-Mini-Display-1602-Mini-Controller-Compatible-with-Ramps-1/32765887917.html // //#define MAKEBOARD_MINI_2_LINE_DISPLAY_1602
// // ANET and Tronxy 20x4 Controller // //#define ZONESTAR_LCD // Requires ADC_KEYPAD_PIN to be assigned to an analog pin. // This LCD is known to be susceptible to electrical interference // which scrambles the display. Pressing any button clears it up. // This is a LCD2004 display with 5 analog buttons.
// // Generic 16x2, 16x4, 20x2, or 20x4 character-based LCD. // #define ULTRA_LCD // estava comentado
//============================================================================= //======================== LCD / Controller Selection ========================= //===================== (I2C and Shift-Register LCDs) ===================== //=============================================================================
// // CONTROLLER TYPE: I2C // // Note: These controllers require the installation of Arduino's LiquidCrystal_I2C // library. For more info: https://github.com/kiyoshigawa/LiquidCrystal_I2C //
// // Elefu RA Board Control Panel // http://www.elefu.com/index.php?route=product/product&product_id=53 // //#define RA_CONTROL_PANEL
// // Sainsmart (YwRobot) LCD Displays // // These require F.Malpartida's LiquidCrystal_I2C library // https://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home // //#define LCD_SAINSMART_I2C_1602 //#define LCD_SAINSMART_I2C_2004
// // Generic LCM1602 LCD adapter // //#define LCM1602
// // PANELOLU2 LCD with status LEDs, // separate encoder and click inputs. // // Note: This controller requires Arduino's LiquidTWI2 library v1.2.3 or later. // For more info: https://github.com/lincomatic/LiquidTWI2 // // Note: The PANELOLU2 encoder click input can either be directly connected to // a pin (if BTN_ENC defined to != -1) or read through I2C (when BTN_ENC == -1). // //#define LCD_I2C_PANELOLU2
// // Panucatt VIKI LCD with status LEDs, // integrated click & L/R/U/D buttons, separate encoder inputs. // //#define LCD_I2C_VIKI
// // CONTROLLER TYPE: Shift register panels //
// // 2 wire Non-latching LCD SR from https://goo.gl/aJJ4sH // LCD configuration: http://reprap.org/wiki/SAV_3D_LCD // //#define SAV_3DLCD
//============================================================================= //======================= LCD / Controller Selection ======================= //========================= (Graphical LCDs) ======================== //=============================================================================
// // CONTROLLER TYPE: Graphical 128x64 (DOGM) // // IMPORTANT: The U8glib library is required for Graphical Display! // https://github.com/olikraus/U8glib_Arduino //
// // RepRapDiscount FULL GRAPHIC Smart Controller // http://reprap.org/wiki/RepRapDiscount_Full_Graphic_Smart_Controller // //#define REPRAP_DISCOUNT_FULL_GRAPHIC_SMART_CONTROLLER
// // ReprapWorld Graphical LCD // https://reprapworld.com/?products_details&products_id/1218 // //#define REPRAPWORLD_GRAPHICAL_LCD
// // Activate one of these if you have a Panucatt Devices // Viki 2.0 or mini Viki with Graphic LCD // http://panucatt.com // //#define VIKI2 //#define miniVIKI
// // MakerLab Mini Panel with graphic // controller and SD support - http://reprap.org/wiki/Mini_panel // //#define MINIPANEL
// // MaKr3d Makr-Panel with graphic controller and SD support. // http://reprap.org/wiki/MaKr3d_MaKrPanel // //#define MAKRPANEL
// // Adafruit ST7565 Full Graphic Controller. // https://github.com/eboston/Adafruit-ST7565-Full-Graphic-Controller/ // //#define ELB_FULL_GRAPHIC_CONTROLLER
// // BQ LCD Smart Controller shipped by // default with the BQ Hephestos 2 and Witbox 2. // //#define BQ_LCD_SMART_CONTROLLER
// // Cartesio UI // http://mauk.cc/webshop/cartesio-shop/electronics/user-interface // //#define CARTESIO_UI
// // LCD for Melzi Card with Graphical LCD // //#define LCD_FOR_MELZI
// // SSD1306 OLED full graphics generic display // //#define U8GLIB_SSD1306
// // SAV OLEd LCD module support using either SSD1306 or SH1106 based LCD modules // //#define SAV_3DGLCD #if ENABLED(SAV_3DGLCD) //#define U8GLIB_SSD1306 //#define U8GLIB_SH1106 //estava descomentadada ??? #endif
// // Original Ulticontroller from Ultimaker 2 printer with SSD1309 I2C display and encoder // https://github.com/Ultimaker/Ultimaker2/tree/master/1249_Ulticontroller_Board_(x1) // //#define ULTI_CONTROLLER
// // TinyBoy2 128x64 OLED / Encoder Panel // //#define OLED_PANEL_TINYBOY2
// // MKS MINI12864 with graphic controller and SD support // http://reprap.org/wiki/MKS_MINI_12864 // //#define MKS_MINI_12864
// // Factory display for Creality CR-10 // https://www.aliexpress.com/item/Universal-LCD-12864-3D-Printer-Display-Screen-With-Encoder-For-CR-10-CR-7-Model/32833148327.html // // This is RAMPS-compatible using a single 10-pin connector. // (For CR-10 owners who want to replace the Melzi Creality board but retain the display) // //#define CR10_STOCKDISPLAY
// // ANET and Tronxy Graphical Controller // //#define ANET_FULL_GRAPHICS_LCD // Anet 128x64 full graphics lcd with rotary encoder as used on Anet A6 // A clone of the RepRapDiscount full graphics display but with // different pins/wiring (see pins_ANET_10.h).
// // MKS OLED 1.3" 128 × 64 FULL GRAPHICS CONTROLLER // http://reprap.org/wiki/MKS_12864OLED // // Tiny, but very sharp OLED display // //#define MKS_12864OLED // Uses the SH1106 controller (default) //#define MKS_12864OLED_SSD1306 // Uses the SSD1306 controller
// // Silvergate GLCD controller // http://github.com/android444/Silvergate // //#define SILVER_GATE_GLCD_CONTROLLER
//============================================================================= //============================ Other Controllers ============================ //=============================================================================
// // CONTROLLER TYPE: Standalone / Serial //
// // LCD for Malyan M200 printers. // This requires SDSUPPORT to be enabled // //#define MALYAN_LCD
// // CONTROLLER TYPE: Keypad / Add-on //
// // RepRapWorld REPRAPWORLD_KEYPAD v1.1 // http://reprapworld.com/?products_details&products_id=202&cPath=1591_1626 // // REPRAPWORLD_KEYPAD_MOVE_STEP sets how much should the robot move when a key // is pressed, a value of 10.0 means 10mm per click. // //#define REPRAPWORLD_KEYPAD //#define REPRAPWORLD_KEYPAD_MOVE_STEP 10.0
//============================================================================= //=============================== Extra Features ============================== //=============================================================================
// @section extras
// Increase the FAN PWM frequency. Removes the PWM noise but increases heating in the FET/Arduino //#define FAST_PWM_FAN
// Use software PWM to drive the fan, as for the heaters. This uses a very low frequency // which is not as annoying as with the hardware PWM. On the other hand, if this frequency // is too low, you should also increment SOFT_PWM_SCALE. //#define FAN_SOFT_PWM
// Incrementing this by 1 will double the software PWM frequency, // affecting heaters, and the fan if FAN_SOFT_PWM is enabled. // However, control resolution will be halved for each increment; // at zero value, there are 128 effective control positions. #define SOFT_PWM_SCALE 0
// If SOFT_PWM_SCALE is set to a value higher than 0, dithering can // be used to mitigate the associated resolution loss. If enabled, // some of the PWM cycles are stretched so on average the desired // duty cycle is attained. //#define SOFT_PWM_DITHER
// Temperature status LEDs that display the hotend and bed temperature. // If all hotends, bed temperature, and target temperature are under 54C // then the BLUE led is on. Otherwise the RED led is on. (1C hysteresis) //#define TEMP_STAT_LEDS
// M240 Triggers a camera by emulating a Canon RC-1 Remote // Data from: http://www.doc-diy.net/photo/rc-1_hacked/ //#define PHOTOGRAPH_PIN 23
// SkeinForge sends the wrong arc g-codes when using Arc Point as fillet procedure //#define SF_ARC_FIX
// Support for the BariCUDA Paste Extruder //#define BARICUDA
// Support for BlinkM/CyzRgb //#define BLINKM
// Support for PCA9632 PWM LED driver //#define PCA9632
/** * RGB LED / LED Strip Control * * Enable support for an RGB LED connected to 5V digital pins, or * an RGB Strip connected to MOSFETs controlled by digital pins. * * Adds the M150 command to set the LED (or LED strip) color. * If pins are PWM capable (e.g., 4, 5, 6, 11) then a range of * luminance values can be set from 0 to 255. * For Neopixel LED an overall brightness parameter is also available. * * *** CAUTION *** * LED Strips require a MOSFET Chip between PWM lines and LEDs, * as the Arduino cannot handle the current the LEDs will require. * Failure to follow this precaution can destroy your Arduino! * NOTE: A separate 5V power supply is required! The Neopixel LED needs * more current than the Arduino 5V linear regulator can produce. * *** CAUTION *** * * LED Type. Enable only one of the following two options. * */ //#define RGB_LED //#define RGBW_LED
#if ENABLED(RGB_LED) || ENABLED(RGBW_LED) #define RGB_LED_R_PIN 34 #define RGB_LED_G_PIN 43 #define RGB_LED_B_PIN 35 #define RGB_LED_W_PIN -1 #endif
// Support for Adafruit Neopixel LED driver //#define NEOPIXEL_LED #if ENABLED(NEOPIXEL_LED) #define NEOPIXEL_TYPE NEO_GRBW // NEO_GRBW / NEO_GRB - four/three channel driver type (defined in Adafruit_NeoPixel.h) #define NEOPIXEL_PIN 4 // LED driving pin on motherboard 4 => D4 (EXP2-5 on Printrboard) / 30 => PC7 (EXP3-13 on Rumba) #define NEOPIXEL_PIXELS 30 // Number of LEDs in the strip #define NEOPIXEL_IS_SEQUENTIAL // Sequential display for temperature change - LED by LED. Disable to change all LEDs at once. #define NEOPIXEL_BRIGHTNESS 127 // Initial brightness (0-255) //#define NEOPIXEL_STARTUP_TEST // Cycle through colors at startup #endif
/** * Printer Event LEDs * * During printing, the LEDs will reflect the printer status: * * - Gradually change from blue to violet as the heated bed gets to target temp * - Gradually change from violet to red as the hotend gets to temperature * - Change to white to illuminate work surface * - Change to green once print has finished * - Turn off after the print has finished and the user has pushed a button */ #if ENABLED(BLINKM) || ENABLED(RGB_LED) || ENABLED(RGBW_LED) || ENABLED(PCA9632) || ENABLED(NEOPIXEL_LED) #define PRINTER_EVENT_LEDS #endif
/** * R/C SERVO support * Sponsored by TrinityLabs, Reworked by codexmas */
/** * Number of servos * * For some servo-related options NUM_SERVOS will be set automatically. * Set this manually if there are extra servos needing manual control. * Leave undefined or set to 0 to entirely disable the servo subsystem. */ //#define NUM_SERVOS 3 // Servo index starts with 0 for M280 command
// Delay (in milliseconds) before the next move will start, to give the servo time to reach its target angle. // 300ms is a good value but you can try less delay. // If the servo can't reach the requested position, increase it. #define SERVO_DELAY { 300 }
// Only power servos during movement, otherwise leave off to prevent jitter //#define DEACTIVATE_SERVOS_AFTER_MOVE
#endif // CONFIGURATION_H…
Adicionado por Richard Falcos ao 11:36 em 8 dezembro 2019
port = fopen("/dev/ttyUSB0", "w"); #### porta no linux ####
//$port = fopen("COM1" , "w"); // Porta do windows
$port = fopen("com.hoho.android.usbserial.driver.CdcAcmSerialDriver(usbDevice, connection)", "w"); #### porta no Android ####
No software serial Monitor instalado no android funciona a comunicação.
Problema
Queria saber como faço para minha pagina usar a serial no android.
Andrei pesquisando ele usa esse comando.
com.hoho.android.usbserial.driver.CdcAcmSerialDriver(usbDevice, connection) - e aparte final e aleatório se tirar usb e coloca novamente e outro número.
O que quero saber e como minha página usa a porta serial que esta conectada nele.
Tem esse site que é da google que explica parte de libraries.
https://code.google.com/p/usb-serial-for-android/
Mais acho que isso e para quem for desenvolver para arquivo java.
Como não entendo muito então não sei.
Tem até um exemplo de código para arduino.
1. Download usb-serial-for-android-v010.jar
2. Copy the jar to your Android project's libs/ directory. (See Android's FAQ for help).
3. Copy device_filter.xml to your project's res/xml/ directory. -- esse arquivo informa acho que se conseguir aplicar sempre vai ser esse número.
<!-- 0x2341 / Arduino -->
<usb-device vendor-id="9025"/>
4. Configure your AndroidManifest.xml to notify your app when a device is attached (see Android USB Host documentation for help).
<activity android:name="..." ...> <intent-filter> <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" /> </intent-filter> <meta-data android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" android:resource="@xml/device_filter" /> </activity>
5. Use it! Example code snippet:
// Get UsbManager from Android.UsbManager manager = (UsbManager) getSystemService(Context.USB_SERVICE); // Find the first available driver.UsbSerialDriver driver = UsbSerialProber.acquire(manager); if (driver != null) { driver.open(); try { driver.setBaudRate(115200); byte buffer[] = new byte[16]; int numBytesRead = driver.read(buffer, 1000); Log.d(TAG, "Read " + numBytesRead + " bytes."); } catch (IOException e) { // Deal with error. } finally { driver.close(); } }
For a more complete example, see the UsbSerialExamples code in git, which is a simple application for reading and showing serial data.
A simple Arduino application is also available which can be used for testing.
Tenho Mini pc cx-919 II tentei colocar o lubunto mais sem sucesso.
Alguém tem alguma sugestão.
…
i interno, ao qual nós nos conectamos através de um iPhone, e, com o App do fabricante (DJI), é possível ver a telemetria e dar comando de tirar foto e filmar ao drone.
A telemetria é gerada com a placa-mãe do drone, e nada tem a ver com o módulo wifi. Tanto que retirei o módulo wifi e consegui a ver a telemetria através de um link normal de vídeo.
Assim, o módulo wifi tem 2 funções, apenas:
1) comunicar-se com o drone através de UART (tem dois terminais UART do módulo wifi para a placa-mãe), puxando a telemetria e e mandando para o celular;
2) receber a imagem da câmera (através de um outro terminal, de vídeo) e mandar para o celular, também.
Originalmente, o módulo wifi recebe comando 'tirar foto' do App do iPhone e manda este comando para a placa pelo UART.
Bem, começa o problema. Este drone tem curto alcance. Para aumentar o alcance, tirei o pesado módulo wifi e coloquei um link de vídeo via rádio normal, que também me possibilita ver a telemetria, pelo sinal de vídeo.
NO ENTANTO, perdi a funcionalidade de tirar foto remotamente.
Sei que, para tirar foto remotamente, preciso enviar um 'packet' com o comando do Arduino para a placa-mãe, correspondente ao comando que ela originalmente recebia do módulo wifi.
Fiz a conexão, mas não estou conseguindo. Até o comando (packet) tem um cara que já descobriu qual é:
http://www.rcgroups.com/forums/showthread.php?t=2212861
(em seu post ele coloca um código que não consegui rodar, acho que porque não consegui as libraries que ele usa).
Alguém poderia me ajudar, como eu deveria mandar estes packets através de um sketch feito no Arduino? Eu comandaria o Arduino pelo rádio (isto, já sei fazer), e o Arduino mandaria o packet para a placa-mãe do drone, que tiraria a foto!
Por fim, fiz um sketch simplificado, que manda o packet via comando Serial.write ou Serial.Print para o drone. Nada aconteceu. Acho que não é um packet na estrutura certa.
Peço ajuda! não aguento mais varar noites em claro procurando resolver!!
abraço
Carlos.
ps.: Anexo foto do modulo wifi retirado. Sua entrada de vídeo está no transmissor de vídeo, agora.
Já a sua conexão pinos 5 e 6 UART estão soltas, e são as que quero colocar no Arduino para mandar os comandos.
ps2.: ANEXO o sketch simplificado, cujo final é uma tentativa de comunicação com o phantom. Tentei de vários jeitos, mas não sei se este é o formato de packet.
Sala principal
…
exemplo, uso do Decoder 4511), e por este motivo a implementação é bastante completa permitindo que seja desenvolvida na direção que vc ou outros desejem. Esta também é uma ótima oportunidade para mostrar a implementação de coisas que podem até parecer complexas a princípio, mas que são na realidade bem simples. Para isto, o Hardware é descrito em detalhes, e o código está totalmente organizado (de forma hierárquica) e comentado funcionalmente (o que é indispensável para se entender sem esforço, como ele funciona). Mesmo assim irei descrever aqui, alguns pontos principais para aqueles que não querem se aprofundar e desejam apenas utilizar os recursos. Aconselho a quem for utilizar, ler integralmente o texto aqui publicado.
Implementei também uma Simulação no Proteus, a qual permite testar o funcionamento do Sistema e também medir alguns parâmetros importantes. Sobre a Simulação, alguns aspectos são apresentados mais adiante.
O código implementado e os arquivos para a Simulação, estão disponíveis para download no final deste post (há também um vídeo mostrando a execução da simulação).
Sobre o Circuito
A implementação do Hardware usa o Arduino UNO, o Decoder CMOS de 7 segmentos 4511 (mais "corretamente" o 4511B), e três Displays de 7 segmentos de Katodo Comum (já que o 4511 permite acionar diretamente esse tipo de Display). Há também os três Botões usados para inserção da Senha, e dois LEDs que indicam se a Senha inserida está correta ou não. Os demais componentes são Resistores e Transistores. O circuito implementado pode ser visto na figura a seguir:
(clique na figura para "zoom")
Vamos falar um pouco então sobre os elementos usados neste Hardware:
1) Arduino: está sendo usado o UNO (uma vez que foi este o Arduino informado no tópico em questão), e isto facilita muito "traduzir" este Sistema para outros Arduinos. Conforme pode ser visto na figura anterior, são usados 4 pinos para especificar um valor de 0 a 9 para o Decoder 4511, sendo estes pinos o 4, 5, 6, e 7, conectados respectivamente aos bits "A" (ou bit "0"), "B" (ou bit "1"), "C" (ou bit "2"), e "D" (ou bit "3") do 4511. Mas poderiam ser usados quaisquer pinos de saída Digital do Arduino e em qualquer ordem desejada, pois o código implementado permite isso.
Para o controle ON/OFF de cada Display, foram usados os pinos "A1", "A2", e "A3" do UNO. Aqui também, quaisquer pinos podem ser usados e em qualquer ordem.
Para leitura dos estados dos três Botões e controle dos dois LEDs, outros 5 pinos são usados, e novamente podem ser especificados quaisquer outros pinos.
Assim ainda restam disponíveis 8 pinos do Arduino UNO. Observar que os pinos restantes permitem que se use algumas funções especiais, como pelo menos uma entrada do ADC (pino A0), Interface I2C (pinos A4 e A5), Interrupções Externas (pinos 2 e 3, mas há também as Interrupções do tipo "pin change" para outros pinos), PWM (pino 3), além da conexão ao Terminal do Arduino via Serial 0 (pinos 0 e 1). Claro, todos os 8 pinos também podem ser usados para I/O convencional. Então quando vc escolher qualquer outra combinação de pinos para o Sistema, analise antes qual é a que melhor se encaixa para suas necessidades.
2) Decoder 7 segmentos e Displays: está sendo utilizado o 4511. Este Decoder embora seja CMOS, possui internamente em cada uma de suas 7 saídas para os LEDs de segmentos, um Driver com Transistor Bipolar para fornecer a corrente para os respectivos LEDs (claro, via Resistor externo para limitar e determinar a corrente de saída). É um Decoder para Displays de Katodo Comum. As entradas "LT" (Light Test), e "BI" (Blanking Input), são ativas em "0" e como não estão sendo usadas, são ligadas a "1" (os 5V da alimentação). A entrada "LE" (Latch Enable) deve ser ligada ao "0" (GND do circuito), para que o Latch interno do 4511 fique "transparente", ou seja desabilitado, para que as saídas de 7 segmentos sempre estejam reproduzindo o valor binário presente nas entradas A, B, C, e D.
Os Resistores conectados às saídas QA a QG do 4511, determinam a corrente para cada segmento. Para os valores no circuito, 330 Ω, a corrente será algo próximo a 10mA. Para este cálculo, desconte de 5V, a tensão sobre um LED de segmento, e então terá a tensão sobre o Resistor. No caso, vamos considerar que o LED do Display tem uma tensão Anodo/Katodo de 1.5V quando ligado. Então sobre o Resistor teremos 5V - 1.5V = 3.5V (aqui estamos "desprezando" a queda no Transistor Bipolar interno do 4511). Então a corrente será 3.5V / 330 Ω ≈ 10.6 mA. Da mesma forma, pode-se também calcular o Resistor, especificando-se a corrente desejada, mas evite passar de 20mA, a fim de limitar o total de corrente fornecido pelo 4511 (veja o datasheet do mesmo para mais detalhes). Caso correntes bem maiores sejam desejadas, pode-se usar Transistores adicionais (tipo NPN) nos pinos de segmentos.
Observar que estamos considerando que os Transistores Q1 a Q3 estão funcionalmente saturados quando acionados pelas saídas do Arduino. Isto é fácil de garantir, supondo-se um HFE médio (por exemplo 100) e escolhendo-se uma corrente de base em torno de 1 mA. Caso alguém queira saber sobre estes cálculos, pergunte aqui neste mesmo tópico, ou me contate via email do LDG.
Nota Importante: é possível dispensar Q1 a Q3 e R11 a R13. Para isso basta que se ligue as saídas do Arduino (no caso pinos A1, A2, e A3), diretamente aos Katodos dos Displays. Nenhuma alteração no código é necessária, uma vez que os Transistores usados são do tipo PNP, o que significa que o código aciona estes por Lógica "LOW" (isto foi feito propositalmente). Notar porém, que o uso dos Transistores traz uma maior flexibilidade na escolha das correntes dos segmentos dos Displays, já que a corrente confiável para uma saída do Arduino é de 20mA, e NÃO 40mA como muitos adoram proclamar!!! Vejam: 40mA é para os "limites máximos absolutos" e não preciso dizer mais nada. Mas há um ponto que ajuda muito aqui: os Displays são acionados de forma multiplexada, e sempre há apenas um único Display acionado de cada vez. Isso significa que a corrente média total de um Display será 1/3 (um terço, já que são três Displays) da corrente determinada pelos Resistores dos segmentos. Como temos 7 segmentos, se a corrente individual é de 10 mA, então a corrente total seria 7 x 10mA = 70mA quando todos os segmentos estiverem ligados (reproduzindo o número "8"), mas a corrente efetiva seria 1/3 disso, ou seja: 70mA / 3 = 23mA. Claro, isso é ligeiramente acima da corrente "segura" para um pino do UNO, mas considerando-se que dificilmente todos os segmentos estarão ligados nos três Displays, então esse limite marginal pode ser desconsiderado. Mas de todo caso, o uso dos Transistores Q1 a Q3 é mais sensato, garantindo inclusive que não se extrapole a máxima corrente de todos os pinos somados do processador do UNO (o AtMega328).
3) Botões: para estes, estão sendo utilizados os Pullups internos do Processador do UNO, o que dispensou o uso de Resistores externos. A Lógica implementada no código faz o "debouncing" dos Botões automaticamente (e sem travar a execução do código). Isso permite dispensar Capacitores externos para o "debouncing" (e eventuais Diodos de Proteção, necessários se os Capacitores tivessem valores relativamente altos).
Sobre a Varredura dos Displays e dos Botões
Como pode ser visto na figura inicial que mostra o circuito do Sistema, os Displays são acionados por meio da varredura dos mesmos, ou seja, a exibição dos valores em cada um dos três Displays, é feita de forma multiplexada. Logo, somente um Display está efetivamente "ligado" num determinado momento. A frequência de varredura (ou taxa de "Refresh"), foi escolhida como sendo 50 Hz. Vamos entender os motivos disso. Primeiro, deve ser uma frequência que não permita a retina do olho humano acompanhar o liga/desliga dos Displays, dando a impressão que todos os três Displays estão sempre ligados, e portanto quanto maior esta frequência, melhor. E para que as demais funcionalidades do código sejam executadas sem haver preocupação em manter a taxa de varredura do Display, essa varredura é executada em uma rotina de Interrupção (ISR), e para gerar essa Interrupção em uma taxa constante, é utilizado o "TIMER1" do Hardware do Processador do Arduino. Assim na inicialização do Sistema, o código programa o "TIMER1" para gerar a taxa de varredura dos Displays. A cada interrupção, é feita a varredura de um único Display. Logo, para varrer os três Displays a 50 Hz, é necessário uma taxa de Interrupção de 3 x 50Hz = 150 Hz. Os detalhes do código que fazem essa varredura são mostrados mais adiante. Observar que a ISR (rotina de Interrupção) deve ser eficiente, para garantir que as demais funcionalidades do Sistema sejam executadas de forma "fluida", ou seja, sem parecer que as Interrupções estão ocorrendo 150 vezes por segundo.
No código implementado, a varredura dos Displays de fato é muito eficiente, e consome efetivamente pouco tempo. Por este motivo, para tornar o Sistema também "despreocupado" com a leitura e gerenciamento dos Botões, essa tarefa também é executada na mesma rotina de Interrupção do "TIMER1". Essencialmente, ali é feita a leitura dos estados dos Botões e conforme estes estados, é determinado se um Botão foi acionado, desacionado, ou se está pressionado por um determinado tempo. O código implementa isso de forma enxuta, longe de sacrificar tempo de processamento do restante do Sistema.
Se forem acrescentados ao Sistema dispositivos "One Wire" (ex.: Sensor DS18B20) ou semelhante (ex.: DHT11 ou DHT22), alguns cuidados devem ser tomados para se garantir os tempos de "slot" para estes dispositivos. Mas é algo perfeitamente factível, e posteriormente posso mostrar como fazer isso (há pelo menos três formas de implementação).
Para dispositivos I2C, nenhum cuidado especial é necessário, uma vez que estes também são cadenciados por IRQ (Interrupt Request) e não há um momento específico para que estas IRQs sejam atendidas.
Quaisquer dúvidas relacionadas, posso responder aqui mesmo neste tópico.
Sobre o Código e Funcionamento do Sistema
A Senha do Sistema é definida no início do código, conforme mostrado na figura a seguir:
(clique na figura para "zoom")
Há no Sistema dois LEDs, um Verde (ou LED "OK") e um Amarelo (ou LED "ERRO"). O LED Verde é utilizado para sinalizar quando a Senha correta é inserida, e o Amarelo indica quando a Senha inserida está incorreta. A definição no código para a configuração de Hardware dos LEDs, pode ser vista na figura a seguir:
(clique na figura para "zoom")
Três Botões controlam a operação do Sistema. O Botão "1" decrementa o valor exibido no Display atualmente selecionado. O Botão "2" incrementa o valor exibido. Já o Botão "3" tem várias funções, sendo a mais comum, selecionar o próximo Display para entrada da Senha.
O funcionamento do código é bastante simples: enquanto no "background" a varredura dos Displays e dos Botões é executada quando as Interrupções do TIMER1 ocorrem (na taxa de 150 Hz), temos que no "foreground" (ou execução "normal") o código decrementa ou incrementa o valor exibido no Display atualmente selecionado conforme acionamento dos Botões "1" ou "2". E quando o Botão "3" é acionado, então o código simplesmente seleciona o próximo Display.
Para cada um dos três Displays há uma variável do tipo "byte", que pode assumir valores de 0 a 9. São exatamente o valor dessas três variáveis que são exibidas pelo mecanismo de varredura do Display (no "background", ou seja, na rotina de Interrupção). E no início de tudo, as três variáveis estão zeradas, o que resulta em exibir "000" nos Displays. Há também um variável do tipo byte que indica qual Display está atualmente selecionado, e a mesma assume valores de 1 a 3. E no início, esta variável assume o valor "1", selecionando assim o Display "1" para a entrada de um Dígito da Senha (neste caso o Dígito das centenas). A figura a seguir mostra as três variáveis para os valores exibidos em cada Display, além da variável que indica qual Display está atualmente selecionado:
(clique na figura para "zoom")
Se um Display está no valor "0" e é decrementado, ele "recicla" para "9". E se um Display está no valor "9" e é incrementado, ele recicla para "0". Então o que o código tem que fazer é verificar quando cada Botão é acionado e aplicar as ações descritas.
Mas quando o Display "3" está selecionado e o Botão "3" é acionado, isso deve ser interpretado como "fim da entrada de Senha", e o Sistema então deve verificar se a Senha mostrada nos Displays, corresponde à Senha do Sistema.
Se a Senha que foi "inserida" via Displays estiver correta, então o LED Verde (LD1 no circuito) acende. Mas se a Senha estiver incorreta, então o LED Amarelo (LD2) acende.
Após a verificação da Senha, o Sistema fica aguardando que o Botão "3" seja novamente acionado, para reiniciar uma nova entrada de Senha. Neste ponto, os dois LEDs apagam, sendo selecionado o Display "1" para entrada de um Dígito da Senha, e os Displays exibem "000", e portanto o Sistema volta ao "início".
A forma mais simples e confiável de implementar esse sequenciamento do código, é através de uma Máquina de Estados, que é mostrada mais a frente neste post. Apenas 3 estados foram necessários para implementar todo o processamento.
Há no código um bloco que trata de todo o gerenciamento de leitura dos Botões, e que é executado no "background", ou seja, na rotina de Interrupção do TIMER1 (onde também é feita a varredura dos Displays). Como dito anteriormente, este bloco de código verifica se um Botão foi acionado ou desacionado, e também "mede" o tempo que um Botão está acionado. Estas informações estão disponíveis para serem usadas no "foreground" do código permitindo assim que este tome as ações conforme os estados dos Botões. Mas para que isto seja possível, é necessário que os Botões sejam definidos no Sistema. Esta definição é simples e consiste de duas etapas. A primeira é a definição dos pinos de Hardware onde os Botões estão conectados, conforme mostrado na figura a seguir:
(clique na figura para "zoom")
A segunda etapa é a criação de estruturas de dados para armazenar os status dos Botões, e de funções que configuram estes Botões e atualizam os status dos mesmos. Isto pode ser visto na figura a seguir:
(clique na figura para "zoom")
Caso fossem incluídos mais Botões no Sistema, bastaria se estender a mesma ideia mostrada na figura, acrescentando as definições para estes Botões juntamente aos já existentes.
Notar que a função "atualiza_Status_Botoes" será executada no "background", ou seja, na rotina de Interrupção do TIMER1. Ela está incluída na figura anterior para se mostrar como é simples a definição completa para uso de um Botão no Sistema. Esta função será especificada como a que justamente atualiza os status dos Botões, através de um "HOOK" na rotina de Interrupção (mostrado mais adiante quando a ISR for apresentada).
Em relação ao Decoder 4511, são necessários 4 pinos do Arduino para se especificar qual valor será exibido em um determinado momento. A definição destes pinos é mostrada na figura a seguir:
(clique na figura para "zoom")
Como já dito, quaisquer pinos podem ser especificados, e em qualquer ordem, pois o código se encarrega de setar cada um deles para reproduzir o valor binário para o Decoder 4511.
Para o controle ON/OFF dos três Displays, 3 pinos devem ser especificados para este controle. Novamente, quaisquer pinos podem ser especificados, e em qualquer ordem. No código, esta definição pode ser visto na figura a seguir:
(clique na figura para "zoom")
A figura a seguir, mostra a captura da tela da Simulação do Sistema no Proteus, em um momento que o Display "1" está sendo varrido, e por isso apenas o mesmo aparece "ligado" na figura exibindo o valor "3":
(clique na figura para "zoom")
Como a taxa de varredura total é de 150Hz (ou seja, 3x 50Hz), então o período de varredura é de 6.67ms (ou seja, 1 / 150Hz). Logo a cada 6.67ms o próximo Display é ligado, sendo setado em binário nos pinos A..D do 4511, o valor a ser exibido naquele Display. Ou seja, cada Display fica "ligado" justamente por 6.67ms, e fica desligado por 13.33ms, o que resulta em um ciclo de 20ms, implicando na Frequência individual de 50Hz para cada Display.
Obs.: a captura da figura anterior foi facilitada pelo fato de que a Simulação executa em um tempo "virtual", completamente independente do tempo real, e o Simulador aumenta ou diminui o step de tempo conforme detalhes da Simulação são executados. Por isso mesmo, quando se executa a simulação, é possível acompanhar partes do processo de varredura, o que causa um efeito que pode parecer "estranho", já que nunca vemos todos os três Displays ligados ao mesmo tempo. Eu disse "partes do processo de varredura", porque enquanto a simulação evolui, o próprio Simulador faz capturas do status desta simulação, para então "printar" estes status na tela do Simulador (aqueles pontinhos vermelhos e azuis que vemos nos prints), e essa taxa de captura não tem nenhuma relação com o conteúdo da simulação, o que resulta em um efeito sub-amostrado (é o mesmo efeito que uma luz stroboscópica existente em pistas de dança das danceterias provoca em nossa retina, resultando em algo semelhante a um vídeo onde faltam cenas). Isto pode ser melhor visto no vídeo da simulação mostrado no final deste post (resulta em um "pisca/pisca" dos valores exibidos no Display, e claro isso é apenas na Simulação).
Como já dito, a taxa de varredura total deve ser 3 vezes a taxa desejada para um único Display. Assim como desejamos 50Hz para cada Display, a taxa total de varredura deve ser 150Hz, e isso é definido no código conforme mostrado na figura a seguir:
(clique na figura para "zoom")
Em uma das simulações, acrescentei um Frequencímetro para medir a frequência de varredura para cada um dos Displays, e o resultado pode ser visto na figura a seguir:
(clique na figura para "zoom")
Como pode ser visto na figura anterior, acrescentei também uma chave rotativa (no circuito é a SW1), que permite selecionar em qual dos Displays estaremos medindo a taxa de varredura. Para todos foi medido 50Hz, como seria de se esperar.
(devido à limitação de espaço este post continua logo a seguir: Link)
…
Adicionado por Elcids Chagas ao 13:49 em 15 julho 2021
eu ligo o motor de 127v o arduino desliga o motor sem o sensor estar atuado. sem o motor funciona com o motor não funciona (fiz uma interface de potencia para acionar os reles pois o motor tem que girar nos dois sentidos )outro caso grave que esta acontecendo é que quando eu ligo o motor de 127v aparece um erro na porta serial e ai tem que tirar o cabo usb da uma confusão.
o erro esta dando quando ligo o motor que é no for de subida dali pra baixo ele nao funciona mais da erro na serial
então volta a afirmar com o motor desligado o codigo funciona e quando ligo o motor o codigo nao funciona !!!
para melhor entendimento do projeto o site do tcc segue abaixo na parte de footos
www.leandroggrossi.wix.com/luizalfredo
caso possa me ajudar mais uma vez ficarei muito grato
#include <Servo.h> // BIBLIOTECA Servo servo1; // SERVO DA PINÇA Servo servo2; // SERVO DO GIRO DO BRAÇO void setup() // INICIO DO PROGRAMA { servo1.attach(3); // output SERVO 1 LIGADO NA PORTA DIGITAL servo2.attach(5); // output SERVO 1 LIGADO NA PORTA DIGITAL pinMode(2, OUTPUT); // avanço de garra (Define as portas como saída) pinMode(4, INPUT); // sensor de avanço de garra digitalWrite(4, HIGH); // sensor de avanço de garra pinMode(13, OUTPUT); // descida do braço pinMode(12, OUTPUT); // subida do braço pinMode(7, INPUT); // sendor de subida do braço digitalWrite(7, HIGH); // sendor de subida do braço pinMode(6, OUTPUT); // recuo de garra da garra pinMode(8, INPUT); // sensor de recuo de garra de garra digitalWrite(8, HIGH); // sensor de recuo de garra de garra pinMode(10, OUTPUT); // movimento do braço na horizontal direita pinMode(9, OUTPUT); // movimento do braço na horizontal esquerda pinMode(11, INPUT); // sensor da horintal da garra digitalWrite(11, HIGH); Serial.begin(4800); // PORTA SERIAL (Definição da velocidade de transmissão) //FIM DO FOR} //FIM DO VOID SETUP
//---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------void loop() { int caso = Serial.read(); switch (caso) //COMANDO DE SELEÇÃO DE MÚLTIPLA ESCOLHA (onde há um dado a ser avaliado. É representado por uma variável de memória.) { //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX CASO 'Q' PRIMEIRA POSIÇÃO DE SUBIDA XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX case 'q': servo1.write(0); // servo do braço para 0 grau servo2.write(0); // servo da pinça para 0 grau Serial.println(" SERVO DA PINCA E DO BRACO A ZERO GRAU "); delay(2000); Serial.println(" PINCA ABERTA 20 GRAUS "); servo2.write(20); delay(2000); //----------- AVANÇO DE GARRA-------------------------------------------------------------------------- Serial.println("AVANCO DE GARRA "); digitalWrite(2,HIGH); // avanço de garra while (digitalRead(2)==HIGH) // testa sensor de avanço de garra { while(digitalRead(4)==LOW) //testa condição do botao { digitalWrite(2,LOW); } } Serial.println("SENSOR ATUADO "); //------------------------------------------------------------------------ delay(2000); Serial.println("CAPTURANDO OBJETO "); servo2.write(0); // fecha garra delay(2000); Serial.println("MOTOR DE SUBIDA ACIONADO "); //------------------------------------------------------------------------------------------------------------------------------------------ digitalWrite(12,HIGH); // ajustando posição delay(500); digitalWrite(12,LOW); delay(1000); //----------------------------------------------------------RECUO DE GARRA---------------------------------------------------------------- Serial.println("RECUO DE GARRA "); // lendo dados da porta serial digitalWrite(6,HIGH); // recuo de garra while (digitalRead(6)==HIGH) // testa sensor de recuo de garra de garra { while(digitalRead(8)==LOW) // testa condição do sensor { digitalWrite(6,LOW); } } Serial.println("SENSOR ATUADO "); //---------------------------------------------------------------------------------------------------------------------------------------- delay(2000); Serial.println("MADANDO PINÇA PRA 90 GRAUS "); servo1.write(90); //manda da garra para 90 graus delay(2000); //------------------------------------------------------LIGA MOTOR DE SUBIDA E DECREMENTA------------------------------------------------------------- Serial.println("PREPARANDO PARA LIGAR MOTOR"); delay(3000); digitalWrite(12,HIGH); Serial.println("MOTOR DE SUBIDA DO BRAÇO LIGADO "); // ESCREVENDO NA TELA //tinha um for aqui...
Serial.println("PREPARANDO PARA LIGAR MOTOR"); delay(3000); digitalWrite(12,HIGH); Serial.println("MOTOR DE SUBIDA DO BRAÇO LIGADO "); // ESCREVENDO NA TELA for(int i=0;i<3;i++) // (CONTADOR INÍCIO;EXPR;INCREMENTO DO CONTADOR)Este tipo de comando de repetição deve ser utilizado quando se sabe a quantidade { while(digitalRead(7) == HIGH); delay(3000); while(digitalRead(7) == LOW); } while(digitalRead(7) == HIGH); Serial.println("SENSOR ATUADO "); digitalWrite(12,LOW); Serial.println("MOTOR DE SUBIDA DO BRAÇO DESLIGADO ");// ESCREVE A MENSAGEM NA TELA
//------------------------------------------------------------- BRAÇO NA HORIZONTAL NA ESQUERDA ---------------------------------------------------------- delay(3000); Serial.println("BRAÇO MOVIMENTANDO NA HORIZOTAL (lado direito) "); delay(200); Serial.println("MANDANDO GARRA PARA 180 GRAUS "); servo1.write(180); // mandando a pinça pra 180 graus delay(2000); digitalWrite(10,HIGH); // liga motor da horizontal movimento da garra na horizontal delay(5000); while (digitalRead(10)==HIGH) // testa a condiçao do botao { while(digitalRead(11)==LOW) { digitalWrite(10,LOW); } } //-------------------------------------------------------- AVANÇO DE GARRA------------------------------------------------------------------------------------------------------ delay(2000); Serial.println(" AVANCO DE GARRA "); digitalWrite(2,HIGH); // avanço de garra while (digitalRead(2)==HIGH) // testa sensor de avanço de garra { while(digitalRead(4)==LOW) //testa condição do botao { digitalWrite(2,LOW); } } Serial.println("SENSOR ATUADO "); //------------------------------------------------------------------------------------------------------------------ delay(2000); Serial.println("AJUSTANDO POSICAO "); digitalWrite(13, HIGH); //ajustando a posiçao delay(200); digitalWrite(13, LOW); delay(2000); Serial.println(" DEIXANDO OBJETO "); servo2.write(20); //abrindo garra //----------------------------------------------------------------recuo de garra------------------------------------------------------------------------------- delay(2000); Serial.println(" RECUO DE GARRA "); delay(200); digitalWrite(6,HIGH); // RECUO DA GARRA while (digitalRead(6)==HIGH) // testa sensor de recuo de garra de garra { while(digitalRead(8)==LOW) //testa condição do botao { digitalWrite(6,LOW); } } delay(200); Serial.println(" SENSOR ATUADO "); //movimento para a direita--------------------------------------------------------------------------------------------- delay(2000); Serial.println(" BRAÇO MOVIMENTANDO NA HORIZOTAL (lado esquerdo) "); digitalWrite(9,HIGH); // liga motor da horizontal movimento para a direita da garra na horizontal delay(5000); while (digitalRead(9)==HIGH) // testa a condiçao do botao { while(digitalRead(11)==LOW) { digitalWrite(9,LOW); } } Serial.println(" SENSOR ATUADO "); servo1.write(90); //-------------------------------------------------------------------------------------- //------------------------------DESCIDA DO BRAÇO ---------------------------------------------------------------------- Serial.println("PREPARANDO PARA LIGAR MOTOR"); delay(3000); digitalWrite(13,HIGH); Serial.println("MOTOR DE SUBIDA DO BRAÇO LIGADO "); // ESCREVENDO NA TELA for(int i=0;i<3;i++) // (CONTADOR INÍCIO;EXPR;INCREMENTO DO CONTADOR)Este tipo de comando de repetição deve ser utilizado quando se sabe a quantidade { while(digitalRead(7) == HIGH); delay(3000); while(digitalRead(7) == LOW); } while(digitalRead(7) == HIGH); Serial.println("SENSOR ATUADO "); digitalWrite(13,LOW); Serial.println("MOTOR DE SUBIDA DO BRAÇO DESLIGADO ");// ESCREVE A MENSAGEM NA TELA Serial.println("xxxxxxxxxxxxxxxxxxxxxx FIM DO CICLO xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx "); delay(500); Serial.println("_______________________________ENGENHARIA DE CONTROLE E AUTOMACAO_________________________________________________ "); break;
…
Adicionado por Leandro Grossi ao 15:18 em 2 setembro 2013
conseguimos achar a solução neste site e venho pedir ajuda... ao incluir a nova rotina alarme utilizando sensor ultrassonico segue o codigo abaixo da erro de compilçao e alem do mais... nao consigo nem mesmo "incluir a rotina" sendo que tenho mais uma que eh o motor que vo utilizar para o portao da garagem
segue o codigo abaixo em anexo o arquivo ino... e pra quem nao tem o arduino irei postar no corpo desta mensagem, o motor da garagem nao esta incluido pois a primeira dificuldade veio o ultrassonico simulando o alarme e incluindo na minha rotina do programa principal é o que estou tendo problemas
#include <SPI.h>
#include <String.h>
#include <Ethernet.h>
#include <Ultrasonic.h>
byte mac[] = { 0x90, 0xA2, 0xDA, 0x00, 0x9B, 0x36};// Endereço Macbyte ip[] = {192, 168, 1, 177 };// Endereço de Ip ArduinoEthernetServer server(8090);// Porta de serviço
int cozinha = 7; // wifi
int sala = 3; // wifi
int quarto2 = 6;
int quarto = 2;
int cooler1 = 5;
int cooler2 = 4;
int portao = 8;
Ultrasonic ultrasonic(9, 10);const int alarme1 = 11;const int alarme2 = 12;long microsec = 0;float distanciaCM = 0;
String readString = String(30);// string para buscar dados de endereço
boolean statusQuarto = false;
boolean statusSala = false;
boolean statusQuarto2 = false;
boolean statusCozinha = false;
boolean statusCooler1 = false;
boolean statusCooler2 = false;
boolean statusPortao = false;
boolean statusAlarme = false;
// Variável para o status do portão
void setup(){
// Inicia o Ethernet
Ethernet.begin(mac, ip);
// Define os pinos como saída
pinMode(quarto, OUTPUT);
pinMode(sala, OUTPUT);
pinMode(quarto2, OUTPUT);
pinMode(cozinha, OUTPUT);
pinMode(cooler1, OUTPUT);
pinMode(cooler2, OUTPUT);
pinMode(portao, OUTPUT);
pinMode(alarme1, OUTPUT);
pinMode(alarme2, OUTPUT);
// Inicia a comunicação Serial
Serial.begin(9600); BuzzerDistancia();}
void loop(){ microsec = ultrasonic.timing(); distanciaCM = ultrasonic.convert(microsec, Ultrasonic::CM);
BuzzerDistancia();
Serial.print(distanciaCM); Serial.println(" cm"); delay(1);}
void BuzzerDistancia(){
digitalWrite(alarme1, LOW); digitalWrite(alarme2, LOW);}
// 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')
{
// vamos verificar se a lâmpada da área deve ser ligada
// Se a string possui o texto L=Ligar
{
// vamos verificar se a lâmpada da sala deve ser ligada
// Se a string possui o texto L=Ligar
if (readString.indexOf("LigarSala") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(sala, HIGH);
statusSala = true;
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarSala") >= 0)
{ // A lâmpada vai ser desligada
digitalWrite(sala, LOW);
statusSala = false;
}
{
// vamos verificar se a lâmpada do quarto2 deve ser ligada
// Se a string possui o texto L=Ligar
if (readString.indexOf("LigarQuarto2") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(quarto2, HIGH);
statusQuarto2 = true;
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarQuarto2") >= 0)
{
// A lâmpada vai ser desligada
digitalWrite(quarto2, LOW);
statusQuarto2 = false;
}
if (readString.indexOf("LigarQuarto") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(quarto, HIGH);
statusQuarto = true;
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarQuarto") >= 0)
{
// A lâmpada vai ser desligada
digitalWrite(quarto, LOW);
statusQuarto = false;
}
{
// vamos verificar se a lâmpada da cozinha deve ser ligada
// Se a string possui o texto L=Ligar
if (readString.indexOf("LigarCozinha") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(cozinha, HIGH);
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarCozinha") >= 0)
{
// A lâmpada vai ser desligada
digitalWrite(cozinha, LOW);
statusCozinha = false; }
{
if (readString.indexOf("LigarCooler1") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(cooler1, HIGH);
statusCooler1 = true;
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarCooler1") >= 0)
{ // A lâmpada vai ser desligada
digitalWrite(cooler1, LOW);
statusCooler1 = false;
}
{
if (readString.indexOf("LigarCooler2") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(cooler2, HIGH);
statusCooler2 = true;
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarCooler2") >= 0)
{ // A lâmpada vai ser desligada
digitalWrite(cooler2, LOW);
statusCooler2 = false;
}
{
if (readString.indexOf("LigarPortao") >= 0)
{
// A lâmpada vai ser ligada
digitalWrite(portao, HIGH);
statusPortao = true;
}
// Se a string possui o texto L=Desligar
if (readString.indexOf("DesligarPortao") >= 0)
{ // A lâmpada vai ser desligada
digitalWrite(portao, LOW);
statusPortao = false;
}
{ if (readString.indexOf("LigarAlarme") >= 0)
{
if (distanciaCM < 100) { digitalWrite(alarme1, HIGH); digitalWrite(alarme2, HIGH); statusAlarme = true; } }
{ if (readString.indexOf("DesligarAlarme") >= 0)
{ void BuzzerDistancia() { digitalWrite(alarme1, LOW); digitalWrite(alarme2, LOW); statusAlarme = 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.println("<font size='20'>");
if (statusQuarto) {
client.print("lampada quarto ligada");
} else {
client.print("lampada quarto desligada");
}
//limpa string para a próxima leitura
readString = "";
// parar cliente
client.stop();
} } } } } } } } } } }}}…
Adicionado por Lucas Ascêncio ao 14:53 em 8 outubro 2014