ama Sketch principal que controla o Alarme, simulei o Sensor sem fio e Controle remoto
através de dois botões - o da esquerda corresponde ao acionamento de um Sensor sem fio.
E o botão da direita simula o acionamento do controle remoto RF.
O Led verde indica que o Alarme esta operacional, isto é, pronto para ser ativado.
O Led vermelho indica que o Alarme esta ativado e quando piscando esta disparado - algum sensor de intrusão foi acionado.
E o Led azul simula o acionamento da Sirene do Alarme - para evitar barulheira durante os testes.
Esse é o vídeo explicando algumas operações do Alarme:
E esse é o Sketch - Programa Protótipo Versão V01_2014. Anexei o arquivo INO.
Tenho que fazer alguns melhoramentos e correções. Estou ainda aprendendo a programar Sketch.
Acho que terei que usar interrupções para verificar o acionamento do Sensor e do Controle remoto.
Tenho que estudar isso.
Sugestões, correções são bem vindas.
Espero que gostem e que seja útil para alguém.
Esse projeto esta sendo muito bom para mim. Tenho aprendido muita coisa!
/* ALARME ARDUINO - OPEN SOURCE - Versão 01_2014
CRIADO POR: Gustavo Murta
DATA: 02/02/2014
USANDO ARDUINO 2009 - Versão 1.05
E-MAIL: jgustavoam@gmail.com
Permitido o uso público, mas deve-se manter o nome do autor.
*/
//Declaração das variáveis referentes às entradas e saídas do Arduino 2009
int SensorSF = 2; int Controle_remoto = 3;
int Led_Verde = 8;
int Led_Verm = 9;
int Apito = 10;
int Sirene = 11;
int valor_SensorSF = 1;
int valor_Controle_remoto = 1;
unsigned int tempo_apito = 0;
boolean Alarme_ativado = false;
int i = 0;
void setup() {
Serial.begin(9600); //Inicializando o monitor serial
//Definindo pinos como entrada ou saída
pinMode(SensorSF,INPUT);
pinMode(Controle_remoto,INPUT);
pinMode(Led_Verde,OUTPUT);
pinMode(Led_Verm,OUTPUT);
pinMode(Apito,OUTPUT);
pinMode(Sirene,OUTPUT); // Led Azul simulando a Sirene
// Inicialização do Alarme
digitalWrite(Led_Verde, LOW); // Led Verde aceso = Alarme Operacional
digitalWrite(Led_Verm, !Alarme_ativado); // Led Vermelho apagado = Alarme Desativado
digitalWrite(Sirene, HIGH); // Sirene desativada (Led Azul)
noTone(Apito); // Desliga o apito
Serial.println("Alarme Operacional ");
// Aguardando a ativação do alarme, através do controle remoto
do
{
delay(50); // Atraso para aguardar Controle Remoto
valor_Controle_remoto = digitalRead(Controle_remoto);
} while (valor_Controle_remoto != 0); // Loop até o controle remoto ser acionado
Serial.println("Alarme Ativado");
Alarme_ativado = !Alarme_ativado; // Ativa o bit de Alarme Ativado
digitalWrite(Led_Verm, !Alarme_ativado); // Acende o led vermelho = Alarme Ativado
Buzzer(200); // um Bip
}
// Função Apito (Buzzer)
void Buzzer(unsigned int tempo_apito) {
tone(Apito,4000); // Ligando o Apito com uma frequencia de 4000 hz.
delay(tempo_apito); // Duração do Apito
noTone(Apito); // Desliga o apito
}
// Função de monitoramento dos Sensores sem fio
void Monitor_SensorSF() {
valor_SensorSF = digitalRead(SensorSF);
if (valor_SensorSF == 0 && Alarme_ativado == 1){ // Somente dispara se o Alarme estiver ativado
Serial.println("Sensor sem fio acionado");
dispara_Alarme() ;
}
}
// Função de verificação do estado do Controle Remoto
void CR_acionado() {
valor_Controle_remoto = digitalRead(Controle_remoto); // Verifica se Controle remoto foi acionado
}
// Função de monitoramento do Controle Remoto
void Monitor_CR() {
CR_acionado();
if (valor_Controle_remoto == 0)
{
Alarme_ativado = !Alarme_ativado; // Controle remoto foi acionado
Serial.print("Controle remoto acionado = ");
if (Alarme_ativado == 1)
{
Serial.println("Alarme ativo");
digitalWrite(Led_Verm,!Alarme_ativado);
Buzzer (200); // Um Bip
} else {
desliga_Alarme();
}
}
}
// Função de Disparo do Alarme
void dispara_Alarme() {
Serial.println("Alarme disparado - acione o controle remoto em 5 segundos para cancelar");
for (int i=0; i<5; i++) // tempo de espera para cancelamento do acionamento da Sirene
{
digitalWrite(Led_Verm, LOW); // Acende o led vermelho
Buzzer(200); // Duração do Apito = 200 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
digitalWrite(Led_Verm, HIGH); // Apaga o led vermelho
delay(200); // Atraso de 200 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
digitalWrite(Led_Verm, LOW); // Acende o led vermelho
Buzzer(400); // Duração do Apito = 400 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
digitalWrite(Led_Verm, HIGH); // Apaga o led vermelho
delay(200); // Atraso de 200 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
}
dispara_Sirene();
}
void dispara_Sirene()
{
digitalWrite(Sirene, LOW); // Liga a Sirene (Led Azul)
Serial.println("Sirene ligada");
for (int i=0; i<20; i++){ // Tempo que a Sirene ficará ligada
digitalWrite(Led_Verm, LOW); // Acende o led vermelho
Buzzer(100); // Duração do Apito = 100 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
digitalWrite(Led_Verm, HIGH); // Apaga o led vermelho
delay(100); // Duração do Apito = 100 ms
CR_acionado();
if (valor_Controle_remoto == 0){ break; }
}
Alarme_ativado = !Alarme_ativado;
desliga_Alarme();
}
// Função de desativação do Alarme
void desliga_Alarme() {
digitalWrite(Sirene, HIGH); // Desliga a Sirene (Led Azul)
Serial.println("Alarme desativado");
Buzzer (100); // Dois bips
delay(100);
Buzzer (100);
noTone(Apito); // Desliga o apito
digitalWrite(Led_Verm,!Alarme_ativado); // Led Vermelho apagado = Alarme Desativado
}
void loop() {
Monitor_CR();
Monitor_SensorSF();
}
…
mosa “luzinha azul”
No mundo do IoT e da automação em geral, é muito comum deparar-nos com controles remotos via celulares utilizando tecnologia BT. Isso é devido a 3 componentes básicos mas muito importantes:
Plataforma de desenvolvimento para Android
Módulos BT baratos e acessíveis (Como por exemplo o HC-06)
E claro, o velho e bom Arduino....
Neste tutorial, vou desenvolver algumas idéias de como controlar as saídas de um Arduíno através de um celular de maneira a mover um Robot, acionar lâmpadas em uma casa, etc.
No mercado é comum encontrar módulos de BT 3.0 “Master-Slave” como o HC-05 e “Slaves” como o HC-06. Já mais recentemente, apareceram os HC-08 e HC-10 que trabalham com tecnologia BT 4.0 ou BLE (“Bluetooth Low Energy”). Os módulos BLE são os únicos que podem ser conectados a um Iphone, pois infelizmente a Apple não fornece suporte a ao BT 3.0.
Para os projetos discutidos aqui, usarei um HC-06 que é bem popular e barato (Bye, bye, Iphone, vamos de Android!). O Módulo é alimentado com 5V o que faz com que ele seja facilmente conectado a um Arduino UNO por exemplo, para receber e transmitir informações a outros dispositivos como um PC ou um telefone celular. Seus pinos de transmissão e recepção podem ser conectados diretamente ao UNO, não havendo a necessidade de se utilizar divisores de tensão como vimos no caso do ESP8266.
Na prática, o HC-06 deve ser ligado diretamente aos pinos 0 e 1 do Arduino (Serial):
HC06-Tx ao Arduino pin 0 (Rx)
HC06-Rx ao Arduino pin 1 (Tx)
Ao se usar a entrada serial por HW do UNO é muito importante lembrar-se que o HC-06 não pode estar fisicamente conectado aos pinos 0 e 1 durante a carga do programa, isso porque o USB também usa essa mesma serial. Uma maneira simples de se contornar esse probleminha (se seu projeto não utiliza muitos GPIOs do UNO) é usar uma porta serial por SW através da library SoftwareSerial (a mesma que usamos no caso do ESP8266). Em nosso caso aqui, usaremos os pinos 10 e 11 do UNO (Tx, Rx respectivamente).
O passo seguinte será escrever um codigo bem simples para se poder testar, programar e inicializar o HC-o6:
Para iniciar, incluir a Library Software Serial, definindo a variável “BT” como a nova porta serial.
#include <SoftwareSerial.h> SoftwareSerial BT(10, 11); // RX, TX String command = ""; // Stores response of bluetooth device
void setup() { Serial.begin(9600); Serial.println("Type AT commands!"); BT.begin(9600); // HC-06 usually default baud-rate }
Em seguida vem o corpo principal do código que simplesmente espera por dados vindos do BT e uma vez que eles chegem, os mesmos são escritos no Serial Monitor. Da mesma maneira, se podem enviar comandos AT desde o monitor serial até o módulo HC-06.
void loop() { if (BT.available()) // Read device output if available. { while(BT.available()) // While there is more to be read, keep reading. { delay(10); //Delay added to make thing stable char c = BT.read(); //Conduct a serial read command += c; //build the string. } Serial.println(command); command = ""; // No repeats } if (Serial.available()) { delay(10); // The DELAY! ********** VERY IMPORTANT ******* BT.write(Serial.read()); } }
Uma vez carregado o programa, faça alguns testes básicos. Por exemplo:,
Envie “AT“, o módulo deverá responder “OK“.
Pergunte a versão do Firmware: “AT+VERSION”, o módulo deverá responser, por exemplo: “linvorV1.8“.
Com o HC-06 é possível definir um nome para o módulo por exemplo: “AT+NAMEMJRoBot_BT_HC06“. Mas diferente de outros módulos, voce não conseguirá saber qual é o nome que está definido para o módulo. Ao se enviar o comando anterior, o HC-06 responderá simplesmente: “OKsetname”.
Em geral, o HC-o6 vem de fábrica com o password (ou PIN): 1234. Voce poderá definir um novo com o comando AT: AT+PINxxxx onde ‘xxxx‘ serão 4 números.
OK! Módulo conectado ao UNO e funcionando. Hora de lançar mão do velho e bom celular Android!!!
Existem muitas apps na loja da Google que podem ser utilizadas. Vou sugerir duas delas, por serem as que usarei em meus tutoriais. Essas apps foram desenvolvidas por mim utilizando o MIT Application2 tool (ver projeto aqui) e estão disponíveis sem custo na loja da Google:
MJRoBoT II BT Control
MJRoBot BT Digital Analog Voice Control
O App MJR0Bot II foi desenvolvido para comandar Robots. Ele basicamente envia um caracter para cada comando de direção, modos AUTO/MANUAL, velocidade + e velocidade-. Alem de permitir o envio de mensagens em modo texto.
O App. MJRoBot Digital Analog Voice Control, envia comandos para acionamento digitais (ligar/desligar) tanto por botões como por voz e comandos numéricos para controle de PWMs (0-255).
Faça o Download de qualquer uma das duas Apps, vá ao set-up do celular e procure o modulo BT fazendo a conexão (entre com o PIN 1234 ou algum outro definido por você). Isso deverá ser feito uma única vez, pois o celular guardará os dados de conexão. Uma vez que o celular e o HC-06 estão conversando, é só usar as APPs.
A partir da segunda vez, ao lançar-se a app, o modulo BT estará desconectado.
Acione o botão de BT, para que o app informe dos modulos disponíveis:
Selecione o nome do módulo (No caso é esse com o HC-06 ao final).
O App então mostrará “CONNECTED”, informando que está “pared” com o HC-06
A partir daí, é só ir acionando os botões do APP e observar no Monitor Serial, o que é que o APP está enviando.
Por exemplo, acionando “ON” e “OFF” sequencialmente para os 4 devices, no caso da APP MJRoBot Digital Analog Voice Control, o resultado seria:
dev1on dev1off dev2on dev2off dev3on dev3off dev4on dev4off
Agora que já temos um App para o Android e sabemos como funciona um modulo BT, vamos colocar a mão na massa e criar algo de util!
Controlando as saídas do Arduino.
Vamos construir o circuito abaixo:
A idéia será usar o App MJRoBot Digi/Ana/Voice Ctrl para acender e apagar os LEDS e também controlar a intensidade dos mesmos usando PWM.
Estaremos relacionando:
Device 1: "dev1on/dev1off" ==> LED Red ==> Pin 3 do UNO
Device 2: "dev2on/dev2off" ==> LED Yellow ==> Pin 5 do UNO
Device 3: "dev3on/dev3off" ==> LED Green==> Pin 6 do UNO
Device 4: "dev4on/dev4off" ==> LED Blue==> Pin 9 do UNO
Ou seja, ao acionar o botão “ON” relacionado ao “Device 1”, a mensagem de texto “dev1on”será enviada ao Arduino. Ao receber essa mensagem, o LED vermelho deverá acender e assim por diante.
Observe que os 4 pinos são pinos com capacidade de gerar PWM. Isso é importante para a utilização dos “sliders” da App, que enviarão valores para controlar a intensidade dos LEDs via PWM:
Dev A0: "r/ 0-255" ==> LED Red ==> Pin 3 do UNO
Dev A1: "y/ 0-255" ==> LED Yellow ==> Pin 5 do UNO
Dev A2: "g/ 0-255" ==> LED Green==> Pin 6 do UNO
Dev A3: "b/ 0-255" ==> LED Blue==> Pin 9do UNO
No caso dos controles deslizantes (“sliders”), antes dos valores para controle do PWM (0 a 255), um caracter será enviado para que o Arduino saiba de que “slider” estará chegando o comando.
O Código:
Setup inicial:
#include <SoftwareSerial.h>
SoftwareSerial BT(10, 11); //TX, RX respectively String device;
const int dev1 = 3; //PWM const int dev2 = 5; //PWM const int dev3 = 6; //PWM const int dev4 = 9; //PWM
void setup() { BT.begin(9600); Serial.begin(9600);
pinMode(dev1, OUTPUT); pinMode(dev2, OUTPUT); pinMode(dev3, OUTPUT); pinMode(dev4, OUTPUT); }
Podemos dividir a parte principal do programa em 4 blocos:
Espera dos comandos BT e construção da variável “device”
Acionamento dos LEDS a partir dos botões
Acionamento dos LEDS a partir de comandos de voz
Controle do intensidade dos LEDs via Sliders
void loop() { while (BT.available()) //Check if there is an available byte to read { delay(10); //Delay added to make thing stable char c = BT.read(); //Conduct a serial read device += c; //build the string. } if (device.length() > 0) { Serial.println(device); // Button control: if (device == "dev1on") {digitalWrite(dev1, HIGH);} else if (device == "dev1off") {digitalWrite(dev1, LOW);} else if (device == "dev2on") {digitalWrite(dev2, HIGH);} else if (device == "dev2off") {digitalWrite(dev2, LOW);} else if (device == "dev3on") {digitalWrite(dev3, HIGH);} else if (device == "dev3off") {digitalWrite(dev3, LOW);} else if (device == "dev4on") {digitalWrite(dev4, HIGH);} else if (device == "dev4off") {digitalWrite(dev4, LOW);}
// Voice control: else if (device == "ligar um" || device == "Ligar 1") {digitalWrite(dev1, HIGH);} else if (device == "desligar um" || device == "desligar 1") {digitalWrite(dev1, LOW);} else if (device == "ligar som" || device == "Ligar som") {digitalWrite(dev2, HIGH);} else if (device == "desligar som" || device == "Desligar som") {digitalWrite(dev2, LOW);} else if (device == "ligar TV" || device == "Ligar TV") {digitalWrite(dev3, HIGH);} else if (device == "desligar TV" || device == "Desligar TV") {digitalWrite(dev3, LOW);} else if (device == "ligar quarto" || device == "Ligar quarto") {digitalWrite(dev4, HIGH);} else if (device == "desligar quarto" || device == "Desligar quarto") {digitalWrite(dev4, LOW);}
// Slider control: char colour = device[0]; int value = device[2]; Serial.print(" "); Serial.println(value); if ( colour == 'r') { analogWrite(dev1, value); // use value to set PWM for LED brightness } if ( colour == 'y') { analogWrite(dev2, value); // use value to set PWM for LED brightness } if ( colour == 'g') { analogWrite(dev3, value); // use value to set PWM for LED brightness } if ( colour == 'b') { analogWrite(dev4, value); } device=""; //Reset the variable } }
Deixo aqui o link para os códigos usados neste tutorial:
Link para os códigos Arduino
No vídeo abaixo, uma demonstração da porção programa acima (botões & Slider):
Vídeo demo comando por botões e Slider
O controle de dispositivos IoT por voz é uma tendência nos dias de hoje. Conseguir este tipo de controle com o conjunto Arduino/HC-06/Android é extremamente simples. Os dispositivos Android já possuem essa característica “de fábrica”. No App que desenvolvi, apenas acrescentei um botão que faz com que o Android “escute” um comando e o envie em formato texto para o Arduino. O codigo se encarrega de “ler” a string que chega.
Em vermelho, ressalto no código alguns possíveis comandos de voz. Ao receber por “Ligar TV” por exemplo, o LED verde (correspondente ao device 3) acenderá (em vez do LED podíamos ter uma relé que ligaria a TV).
No vídeo abaixo, uma pequena demonstração do controle por voz:
Vídeo demo de comandos por voz.
Bom, acredito que já é possível ver o enorme potencial do controle de “coisas” usando BT/Android/Arduino. Em meus próximos posts estarei desenvolvendo Robots que poderão ser controlados remotamente como vimos aqui.
Para mais tutoriais, demos, vídeos, etc. visite meu blog:
MJRoBot.org
Um abraço e até mais!
…
Adicionado por Marcelo Rovai ao 19:45 em 31 janeiro 2016
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
Ultrasônico SR04, um relé deverá ativar e também será gerado uma tensão utilizando PWM. Os valores de tensão e distância devem ser mostrados num LCD 16x2.
Só que como está no sketch, a distância lida sempre consta como 0, se poderem analisar e ver algo fora do normal e me dizer seria de boa ajuda.
Print do Sketch: https://pastebin.com/print/wuLdCi9T
#include "Ultrasonic.h"
#include <LiquidCrystal.h>
Ultrasonic ultrasonic(13, 12); // 13 Echo 12 Trig
LiquidCrystal lcd (11, 10, 9, 8, 7, 6);
int valor_pwm; //Variável para armazenar o sinal PWM
int entrada_rele1 = 1; //Define o relé 1 no pino 1
int entrada_rele2 = 2; //Define o relé 2 no pino 2
int entrada_rele3 = 3; //Define o relé 3 no pino 3
int entrada_rele4 = 4; //Define o relé 4 no pino 4
void setup() {
pinMode(entrada_rele1, OUTPUT);
pinMode(entrada_rele2, OUTPUT);
pinMode(entrada_rele3, OUTPUT);
pinMode(entrada_rele4, OUTPUT);
digitalWrite(entrada_rele1, HIGH); // Deixa o relé desligado
digitalWrite(entrada_rele2, HIGH); // Deixa o relé desligado
digitalWrite(entrada_rele3, HIGH); // Deixa o relé desligado
digitalWrite(entrada_rele4, HIGH); // Deixa o relé desligado
Serial.begin(9600);
lcd.begin(16, 2);
lcd.setCursor( 0, 0);
lcd.print(" Gerando tensao ");
lcd.setCursor( 0, 1);
lcd.print(" pela distancia ");
delay(3000);
lcd.clear();
}
void loop()
{
int tensao = valor_pwm; //Define a tensão o valor dado pelo pwm
int distancia = (ultrasonic.Ranging(CM)); //Distancia dada pela leitura do Sensor
if (distancia < 100) {
if (distancia < 70) {
if (distancia < 50) {
if (distancia < 30) {
if (distancia < 10) {
analogWrite(valor_pwm, 0);//Ativa 0vcc
lcd.setCursor(0, 0);
lcd.print("Tensao ");
lcd.print(tensao); //Escreve no display o valor da tensao obtida pelo pwm
lcd.print(" V"); //Escreve V
lcd.setCursor(0, 1);
lcd.print("Distancia ");
lcd.print(distancia);//Escreve no display o valor da distancia em CM.
Serial.print(distancia);
Serial.println();
}
}
else {
analogWrite(valor_pwm, 64);//Ativa ~1,2 vcc
digitalWrite(entrada_rele1, LOW); //Aciona o Relé
lcd.setCursor(0, 0);
lcd.print("Tensao ");
lcd.print(tensao); //Escreve no display o valor da tensao obtida pelo pwm
lcd.print(" V"); //Escreve V
lcd.setCursor(0, 1);
lcd.print("Distancia ");
lcd.print(distancia); //Escreve no display o valor da distancia em CM.
Serial.print(distancia);
Serial.println();
}
}
else {
analogWrite(valor_pwm, 127);//Ativa ~2,5 vcc
digitalWrite(entrada_rele2, LOW); //Aciona o relé 2
lcd.setCursor(0, 0);
lcd.print("Tensao ");
lcd.print(tensao); //Escreve no display o valor da tensao obtida pelo pwm
lcd.print(" V"); //Escreve V
lcd.setCursor(0, 1);
lcd.print("Distancia ");
lcd.print(distancia);//Escreve no display o valor da distancia em CM.
Serial.print(distancia);
Serial.println();
}
}
else {
analogWrite(valor_pwm, 191);//Ativa ~ 3,7vcc
digitalWrite(entrada_rele3, LOW); //Aciona o Relé 3
lcd.setCursor(0, 0);
lcd.print("Tensao ");
lcd.print(tensao); //Escreve no display o valor da tensao obtida pelo pwm
lcd.print(" V"); //Escreve V
lcd.setCursor(0, 1);
lcd.print("Distancia ");
lcd.print(distancia);//Escreve no display o valor da distancia em CM.
Serial.print(distancia);
Serial.println();
}
}
else {
analogWrite(valor_pwm, 255); //Ativa 5vcc
digitalWrite(entrada_rele4, LOW); //Aciona o Relé 4
lcd.setCursor(0, 0);
lcd.print("Tensao ");
lcd.print(tensao); //Escreve no display o valor da tensao obtida pelo pwm
lcd.print(" V"); //Escreve V
lcd.setCursor(0, 1);
lcd.print("Distancia ");
lcd.print(distancia);//Escreve no display o valor da distancia em CM.
Serial.print(distancia);
Serial.println();
}
}
…
Adicionado por Gildeon Jr ao 15:38 em 17 outubro 2018
ero mas não envia via sms com o link.Peguei o código e fui modificando , incluindo algumas coisas para me ajudar.
O código é esse :
#include <SPI.h> #include <SD.h> #include <TinyGPS++.h> #define ARDUINO_USD_CS 8 // uSD card CS pin (pin 8 on Duinopeak GPS Logger Shield)
String avalia = ""; int conta = 0;
///////////////////////// // Log File Defintions // ///////////////////////// // Keep in mind, the SD library has max file name lengths of 8.3 - 8 char prefix, // and a 3 char suffix. // Our log files are called "gpslogXX.csv, so "gpslog99.csv" is our max file. #define LOG_FILE_PREFIX "gpslog" // Name of the log file. #define MAX_LOG_FILES 100 // Number of log files that can be made #define LOG_FILE_SUFFIX "csv" // Suffix of the log file char logFileName[13]; // Char string to store the log file name // Data to be logged: #define LOG_COLUMN_COUNT 8 char * log_col_names[LOG_COLUMN_COUNT] = { "longitude", "latitude", "altitude", "speed", "course", "date", "time", "satellites" }; // log_col_names is printed at the top of the file. ////////////////////// // Log Rate Control // ////////////////////// #define LOG_RATE 5000 // Log every 5 seconds unsigned long lastLog = 0; // Global var to keep of last time we logged ///////////////////////// // TinyGPS Definitions // ///////////////////////// TinyGPSPlus tinyGPS; // tinyGPSPlus object to be used throughout #define GPS_BAUD 9600 // GPS module's default baud rate //////////////////////////////////////////////// // Arduino GPS Shield Serial Port Definitions // //////////////////////////////////////////////// // If you're using an Arduino Uno, Mega, RedBoard, or any board that uses the // 0/1 UART for programming/Serial monitor-ing, use SoftwareSerial: #include <SoftwareSerial.h> #define ARDUINO_GPS_RX 3 // GPS TX, Arduino RX pin #define ARDUINO_GPS_TX 2 // GPS RX, Arduino TX pin SoftwareSerial ssGPS(ARDUINO_GPS_TX, ARDUINO_GPS_RX); // Create a SoftwareSerial SoftwareSerial SIM900(10, 11); // Set gpsPort to either ssGPS if using SoftwareSerial or Serial1 if using an // Arduino with a dedicated hardware serial port #define gpsPort ssGPS // Alternatively, use Serial1 on the Leonardo // Define the serial monitor port. On the Uno, Mega, and Leonardo this is 'Serial' // on other boards this may be 'SerialUSB' #define SerialMonitor Serial void setup() { SIM900.begin(9600); SerialMonitor.begin(9600); gpsPort.begin(GPS_BAUD); SerialMonitor.println("Setting up SD card."); // see if the card is present and can be initialized: if (!SD.begin(ARDUINO_USD_CS)) { SerialMonitor.println("Error initializing SD card."); } updateFileName(); // Each time we start, create a new file, increment the number printHeader(); // Print a header at the top of the new file } void loop() { if ((lastLog + LOG_RATE) <= millis()) { // If it's been LOG_RATE milliseconds since the last log: if (tinyGPS.location.isUpdated()) // If the GPS data is vaild { if (logGPSData()) // Log the GPS data { SerialMonitor.println("GPS logged."); // Print a debug message lastLog = millis(); // Update the lastLog variable } else // If we failed to log GPS { // Print an error, don't update lastLog SerialMonitor.println("Failed to log new GPS data."); } } else // If GPS data isn't valid { // Print a debug message. Maybe we don't have enough satellites yet. SerialMonitor.print("No GPS data. Sats: "); SerialMonitor.println(tinyGPS.satellites.value()); } } // If we're not logging, continue to "feed" the tinyGPS object: while (gpsPort.available()) tinyGPS.encode(gpsPort.read()); } byte logGPSData() { File logFile = SD.open(logFileName, FILE_WRITE); // Open the log file if (logFile) { // Print longitude, latitude, altitude (in feet), speed (in mph), course // in (degrees), date, time, and number of satellites. logFile.print(tinyGPS.location.lng(), 6); logFile.print(','); logFile.print(tinyGPS.location.lat(), 6); logFile.print(','); logFile.print(tinyGPS.altitude.feet(), 1); logFile.print(','); logFile.print(tinyGPS.speed.mph(), 1); logFile.print(','); logFile.print(tinyGPS.course.deg(), 1); logFile.print(','); logFile.print(tinyGPS.date.value()); logFile.print(','); logFile.print(tinyGPS.time.value()); logFile.print(','); logFile.print(tinyGPS.satellites.value()); logFile.println(); logFile.close();
GSMsms(); return 1; // Return success } return 0; // If we failed to open the file, return fail } // printHeader() - prints our eight column names to the top of our log file void printHeader() { File logFile = SD.open(logFileName, FILE_WRITE); // Open the log file if (logFile) // If the log file opened, print our column names to the file { int i = 0; for (; i < LOG_COLUMN_COUNT; i++) { logFile.print(log_col_names[i]); if (i < LOG_COLUMN_COUNT - 1) // If it's anything but the last column logFile.print(','); // print a comma else // If it's the last column logFile.println(); // print a new line } logFile.close(); // close the file } } // updateFileName() - Looks through the log files already present on a card, // and creates a new file with an incremented file index. void updateFileName() { int i = 0; for (; i < MAX_LOG_FILES; i++) { memset(logFileName, 0, strlen(logFileName)); // Clear logFileName string // Set logFileName to "gpslogXX.csv": sprintf(logFileName, "%s%d.%s", LOG_FILE_PREFIX, i, LOG_FILE_SUFFIX); if (!SD.exists(logFileName)) // If a file doesn't exist { break; // Break out of this loop. We found our index } else // Otherwise: { SerialMonitor.print(logFileName); SerialMonitor.println(" exists"); // Print a debug statement } } SerialMonitor.print("File name: "); SerialMonitor.println(logFileName); // Debug print the file name }
void sendsms() { delay(400); Serial.println("AT + CMGS = \"+55xxxxxxxxxxxx\""); delay(300);
Serial.print("http://maps.google.com/maps?q=loc:"); //SIM900.print("Latitude = "); Serial.print(tinyGPS.location.lat(), 6); //SIM900.print(" Longitude = ");
Serial.print(","); Serial.print(tinyGPS.location.lng(), 6); delay(200); Serial.println((char)26); // End AT command with a ^Z, ASCII code 26 delay(200); Serial.println();
if (millis() > 5000 && tinyGPS.charsProcessed() < 10) { Serial.println(F("No GPS detected: check wiring.")); while(true); } }
void comando(String comand) { conta++; avalia = ""; SIM900.print(comand); while(SIM900.available()<=0) Serial.print("preso passo "), Serial.println(conta), delay(200);
while(SIM900.available()>0) { char letra = SIM900.read(); if (isAlphaNumeric(letra)) avalia += letra; }
if (avalia=="OK") Serial.print("passo"), Serial.println(conta); else Serial.print("avalia: "), Serial.println(avalia); delay(200); }
void GSMsms() { comando("AT+CMGF=1\r\n"); comando("ATE0\r\n"); comando("AT+CNMI=1,2,0,0,0\r\n"); /* SIM900.print("AT+CMGF=1\r"); SIM900.print("ATE0\r"); SIM900.print("AT+CNMI=1,2,0,0,0\r"); */ delay(400);
SIM900.print("AT+CMGS=\r\n"); SIM900.write(0x22);//aspa dupla SIM900.print("+55xxxxxxxxx"); SIM900.write(0x22);//aspa dupla SIM900.println(); delay(400);
SIM900.print("http://maps.google.com/maps?q=loc:"); SIM900.print(tinyGPS.location.lat(), 6); SIM900.print(","); SIM900.print(tinyGPS.location.lng(), 6); SIM900.write(0x1A); SIM900.write(0x0D); SIM900.write(0x0A); Serial.println("Enviando mensagem..."); delay(1000); }
HARDWARE USADO :
SIM 900A
ARDUINO UNO
ARDUINO SHIELD…
Adicionado por Rafael Q. S. ao 22:41 em 4 outubro 2019
liderados por Sergey Lebedev Alekseevich a partir do final de 1948 no Instituto de Eletrônica e Tecnologia de Kiev, cuja exploração é começou em 1951 depois de vários testes com sucesso. Inicialmente, o trabalho sobre a MESM, tinha objetivos apenas deinvestigación e interesses na área dos computadores de construção elementares. Mas depois de testes bem-sucedidos de sua operação e uma necessidade crescente de todos os tipos de cálculos (especialmente no serviço militar), decide terminar o projeto foi capaz de usar a máquina como uma ferramenta para resolver problemas reais.Em 1949 atrasado, nós projetamos a arquitetura e identifica esquemas MESM funcionamento de seus blocos. Em 1950, a máquina foi montada em um prédio de dois andares de um antigo mosteiro Fofaniya (cerca de Kiev). Em 6 de novembro de 1950 foi o primeiro teste da máquina executando-laoperación Y + Y = 0, Y (0) = 0, Y (π) = 0. Em 4 de janeiro de 1951, as operações foram realizadas unasucesión soma de números ímpares de fatorial de um número e de um elevador de energia. 25 de dezembro de 1951, começou a operação normal e regular da máquina.O MESM tinha as seguintes características:PunchcardA máquina aritmética: ação, universal paralelo, com base no biestável simples.Representação de números: Encoma, binário fixo, com 16 bits para Labase e um bit para indicar o sinal.Memória operacional: com base nos dados biestáveis para 31 dígitos para o comando de 63 dígitos.Memória volátil: a-31-dígitos dados para os dígitos de comando-63.Velocidade de processamento: c (o tempo de ciclo total é de cerca de 17,6 ms, a operação de divisão é realizada numa gama de 17,6-20,8 ms).Comandos do sistema: três vias, com 20 dígitos para o comando, os quatro primerosdígitos indicam theCode de laoperación, o 5 endereço próximo do primeiro operando, a 6 após o segundo operando e os restantes 5 endereço de armazenamento resultado laoperación .Operação disponível: adição, subtração, multiplicação, divisão, comparação do deslocamento, considerando o sinal, em comparação com o valor absoluto, redirecionar, transmitido números de uma bobina magnética, Soma de comandos, pare.Thermionic válvulas: a 6000 (3500 apox 2500 triodes e diodos.)Área ocupada: cerca de 60m ².Consumo de energia: cerca de 25 kW.A leitura dos dados é realizada por meio de cartões perfurados também pode usar uma bobina magnética, cuja capacidade de armazenamento foi de aproximadamente 5000 comandos ou números.A saída dos dados é realizada por um dispositivo, ou por um dispositivo imprentaelectromecánico fotográfica sobre uma película fotográfica.STRELAA Strela computador (ЭВМ "Стрела") foi o primeiro computador de grande porte construído na União Soviética a sério desde 1953. Strela significa seta.O projetista-chefe foi Yuri Basilevsky. Entre seus assistentes foi Boris Rameyev, designer-chefe da série computador Ural. Ele foi projetado para o projeto especial Gabinete 245, de Moscou.Os Strelas foram fabricados em Moscou Usina de Informática e Máquinas analíticos (Московский завод счетно-аналитических машин) entre 1953 e 1957, foram construídos sete máquinas. Foram instalados no Centro de Computação da Academia Russa de Ciências, Keldysh Instituto de Matemática Aplicada, Universidade Estadual de Moscou, e centros de computação de alguns ministérios (relacionada com a defesa e economia).Estes computadores de primeira geração eram 6.200 e 60.000 válvulas diodos semicondutores. O Strela tinha uma velocidade de 2.000 operações por segundo. Sua aritmética de ponto flutuante foi baseado em palavras de 43 bits com mantissa assinado e 35 bits de expoente 6 bits assinados. A tubos de RAM Williams tinha 2048 palavras. Ele também foi um programas ROM semicondutores. A entrada de dados foi através de cartões perfurados ou de fitas. A saída de dados foi realizada por fita magnética, cartões perfurados ou impressora.A versão mais recente do Strela usado um cilindro magnético de 4.096 palavras girando a 6.000 rpm.Em 1954, os designers Strela foram agraciados com o Stalin Medalha 1. grau.MINSKA Minsk foi uma família de computadores de grande porte foram desenvolvidos e produzidos no Soviética Bielo-Rússia República Socialista entre 1959 e 1975. Sua produção foi interrompida pela decisão política de mudar para um clone IBM 360 conhecido como ES EVM para o comprimento conhecido como "distensão", em que a União Soviética e os EUA aliviou tensões e houve um "degelo" da Guerra Fria.O modelo mais avançado era o Minsk-32, desenvolvido em 1968. Suportado COBOL, FORTRAN e ALGAMS (uma versão do ALGOL). Este e versões anteriores também usou uma linguagem de máquina orientada chamado AKI (por sua sigla (AvtoKod "Inzhener.") Estava entre os nativos linguagem assembly SSK (Kodirovaniya Sistema Simvolicheskogo, ou "sistema de código simbólico") de altura e Línguas nível como FORTRAN. M-20, M-220 e M-222 eram um grupo de máquinas de uso geral projetados e fabricados na URSS. Essas máquinas foram desenvolvidas pelo Instituto de Pesquisa Científica de máquinas eletrônicas (NIIEM) e construído no Moscou Usina de Computação e Análise de Máquina (SAM) e Usina Kazan de máquinas de computação, sob a supervisão do Ministério da Indrustria URSS.URALA série Ural computador foi desenvolvido pelo manifacturer de Computação Eletrônica Produção de Penza, e foi produzido entre 1959 e 1964. O seu designer chefe era Bashir Rameyev foram fabricados um total de 139. Foi amplamente utilizado na década de 60, especialmente nos países socialistas, mas também exportados para a Europa Ocidental e na América Latina.Modelos 1 a 4 da Ural foram baseados em tubos de vácuo (válvulas), com hardware que o fizeram capaz de atingir os 12.000 cálculos de ponto flutuante por segundo. Uma palavra é constituída por 40 bits e foi capaz de conter um número ou de duas instruções. Foi utilizado um núcleo de ferrite para criar a memória de trabalho. A nova série (o 11 eo 14, produzido entre 1964 e 1971) foram baseados em semicondutores.Permitido para tarefas matemáticas em centros de informática, instalações e indrustriales científicos instalações. A máquina ocupa aproximadamente 90-100 metros quadrados. O computador estava funcionando e tinha uma tensão trifásica 30kVA lastro magnéticos capazes.As principais unidades do sistema foram: teclado unidade de controle, e leitura, memória, a memória de ferrite unidade aritmeticológica, unidade central de processamento e fonte de alimentação.Estações de trabalho. e computadores pessoais.SM EVMO EVM SM (russo М ЭВМ, curto Система Малых ЭВМ - literalmente Minicomputadores Sistema) era o nome de vários tipos soviéticos minicomputadores 70 e 80. Sua produção começou por volta de 1975. Muitos deles eram clones do DEC PDP-11 e VAX. SM-1 e SM-2 clones foram criados por minicomputadores Hewlett Packard. O sistema operacional mais comum para esses computadores foram traduzidas versões do RSX-11 (ОС РВ) para modelos high-end e RT-11 (РАФОС, ФОДОС) para modelos low-end. Houve também um clone de UNIX disponível, MOS, por gama alta PDP-11 clones.MIRMIR (МИР, "paz" ou "mundo" em russo) é o nome de uma série de computadores soviéticos, desenvolvido entre 1965 (miR-1) para 1969 (o MIR-2) por um grupo liderado por Viktor Glushkov. Um acrônimo para "Машина для Инженерных Расчётов" (cálculos de engenharia de máquinas). Ele foi projetado como um computador "pequena" para uso em aplicações de engenharia e científicos. Entre outras inovações, continha uma implementação em hardware de uma linguagem de programação de alto nível pode fazer cálculos com frações, polinômios, derivadas e integrais. Outra característica inovadora para a época era de que a interface de usuário combinado com um teclado, monitor e uma caneta de luz usado para escrever e editar texto na tela. Pode ser considerado como um dos primeiros computadores pessoais.
Fonte:
http://histinf.blogs.upv.es/2011/01/10/aproximacion-historia-info-urss/…
dentro do Processador estes respectivos pinos são controlados pelos circuitos desta Interface, e portanto os sinais lógicos que aparecem nos pinos externos, são os sinais do Hardware SPI. Em outras palavras: enquanto o SPI está "habilitado", se no seu sketch vc setar um daqueles sinais com "HIGH" ou "LOW" via "digitalWrite", o nível lógico não chegará ao pino, uma vez que este está sendo controlado pelo Hardware SPI. Vc pode ver isto claramente através do Diagrama Lógico para um pino de I/O do Processador, conforme mostro na figura a seguir:
(clique na figura para "zoom")
A figura anterior é do datasheet do Processador AVR. Nela marquei na cor "rosa claro", os sinais que selecionam entre um I/O convencional (que pode ser "setado" via "digitalWrite" e lido via "digitalRead") e uma Função Alternativa para o pino (esta função pode ser por exemplo o SPI). Os sinais da Função Alternativa, estão marcados na cor "laranja claro", e veja que nem todos estes sinais "chegam" aos pinos físicos do Processador, pois alguns são usados para determinar se na Função Alternativa o pino será uma entrada ou uma saída, ou mesmo se o Resistor de Pullup interno (o "RPU") será ativado. Caso tenha alguma curiosidade sobre algum sinal em específico mostrado na figura, fique à vontade para perguntar.
Uma informação adicional: na figura anterior, a região que marquei em azul mais escuro, é a que é controlada pelo "digitalWrite", e a região que marquei em verde claro é a que é acessada pelo "digitalRead" (e neste caso específico, essa região também pode ser acessada por uma Função Alternativa).
Uma vez esclarecido esta questão das Funções Alternativas em relação aos pinos do Processador, respondendo suas questões, de forma enumerada:
1) como o RV já disse, vc não pode usar os pinos do SPI para I/O convencional. E o motivo disso é exatamente o que mostrei no texto anterior: quando vc habilita o uso do SPI, os pinos correspondentes não estão conectados aos Ports de I/O, e sim ao Hardware do SPI dentro do Processador.
E se a Interface SPI estiver habilitada, então os pinos correspondentes terão uma temporização específica para esta Interface, conforme vc pode ver na figura a seguir:
(clique na figura para "zoom")
Note que marquei com cores, os sinais correspondentes ao SPI, e estas cores irão coincidir com as que usei na próxima figura logo adiante, para os mesmos sinais. Mas aqui o importante é perceber que devido às características específicas desta temporização, é praticamente inviável tentar usar estes sinais para outras funções, mesmo com "gambiarras" de Hardware e Firmware (até é possível, mas não é nada prático).
2) "espelhamento" não é o termo técnico adequado. Em Hardware, o termo técnico "espelhamento" se refere quando um Sinal sempre acompanha o Estado Lógico de outro sinal, mas estes sinais não estão fisicamente conectados. Ou seja, apenas um é a cópia lógica do outro, e os sinais são "drivados" cada um por seu circuito específico.
No caso a que vc se refere sobre os sinais correspondentes ao SPI, que seriam os pinos "11", "12", e "13", seja no conector "ICSP" (ou "In Circuit System Programming"), seja no conector de I/O do Arduino, os sinais são exatamente os mesmos, ou seja, os três sinais estão em ambos os conectores (e portanto não são "espelhamentos"). E estes sinais são originados nos pinos do Processador. Vc pode ver isso na figura a seguir, onde marquei a conexão destes três sinais na cor "rosa claro":
(clique na figura para "zoom")
Na figura anterior, o conector "ICSP" para o Processador ATMega328 está marcado na cor amarela. Este conector é usado para programar o Processador, semelhante a quando vc programa o mesmo através da IDE do Arduino. Porém a IDE do Arduino usa uma "Ponte USB para Serial" para enviar os códigos ao Processador "principal", e neste caso é o próprio Processador que se "auto-programa" com o código enviado. Já no caso do uso do "ICSP", os sinais para programação são praticamente idênticos aos do SPI, e por isso os sinais físicos desta Interface são usados nesta função de programação. Porém neste caso, não é exatamente o Processador quem faz a programação, pois quando o "ICSP" é usado, um Hardware "escondido" no Processador é "ativado". Este Hardware é uma Máquina de Estados, e ela é cadenciada pelos sinais do "ICSP", usando um Protocolo específico (este Protocolo está descrito em documentos publicados pelo Fabricante do Processador).
Então veja que, a função do "ICSP" não tem relação com a Função SPI usada nos sketchs. E apesar de ambas usarem os mesmos sinais, em 99,99% dos casos isso não é um problema, pois o "ICSP" é geralmente usado ou na Programação em Fábrica de um Produto comercial, ou na programação em campo deste produto, e neste caso o Fabricante do produto evita usar a SPI no produto final (e se ele resolver usar, então terá que tomar alguns cuidados). Já no caso do Arduino, em 99,99% dos casos, a programação é feira através da "Ponte USB para Serial", que é totalmente separada do "ISCP", e nenhum conflito ocorre.
3) e o "outro" conector "ICSP" na placa no UNO (aquele conector próximo ao conector USB), é para a programação via "ICSP" do Processador que implementa a "Ponte USB para Serial", sendo este Processador geralmente o ATMega16u2 conforme vc pode ver no diagrama elétrico mostrado na figura anterior. O "ICSP" desse outro Processador está na cor laranja na figura anterior. O código que "roda" neste processador, é o que gerencia a "Ponte USB para Serial", ou seja, que envia ao Processador "principal" o código que vc compila na IDE do Arduino. Logo geralmente não "mexemos" com este Processador. Mas o "ICSP" dele está ali, caso por algum motivo seja necessário regravar o código que gerencia a "Ponte USB para Serial",
Então, de forma convencional, não há como vc usar os sinais deste outro "ISCP", uma vez que ele não está conectado aos sinais do Processador "principal".
Além disso, a maioria esmagadora das placas UNO (e de outros Arduinos também), atualmente está usando Circuitos Integrados que são uma implementação em Hardware da "Ponte USB para Serial", o que significa que vc não encontrará um conector "ICSP" correspondente (ou seja, nestas placas só há o "ICSP" para o Processador "principal").
Uma curiosidade: o sinal "SS" (o pino "10" no UNO), de fato pertence à Interface SPI. Porém só é utilizado quando se usa o SPI com diversos Processadores e mais de um desses pode ser um "Master SPI". Em todos os outros casos, o sinal "SS" está livre para ser um I/O convencional e nenhum "setting" especial é necessário para isto. Note também que para o nRF24L01, vc pode especificar quem será o pino "CSN", e não precisa ser o "SS" do Arduino.
Uma dica final: caso precise de mais I/Os no UNO, aconselho usar um Expansor I2C, devido à praticidade de fazer isto com esta Interface. Um expansor muito popular e muito bom, é aquele que é usado também para acessar os Displays LCDs convencionais através do I2C, e que pode ser usado para expandir I/Os sem ser necessária qualquer modificação, como mostrado na figura a seguir:
(clique na figura para "zoom")
Este Expansor I2C da figura anterior, usa o CI "PCF8574" ou o "PCF8574A" (a diferença entre eles é apenas o "endereço base" I2C). Cada expansor desses, acrescenta 8 pinos de I/O ao Arduino, e vc pode usar até 16 desses expansores simultaneamente (caso use ambos 8574 e 8574A), possibilitando até 128 pinos de I/O (e se usar apenas o 8574 ou o 8574A, então até 64 pinos são possíveis usando 8 expansores simultaneamente). E cada pino de I/O do expansor é independente, e pode ser programado para ser entrada ou saída digital. E melhor: há Bibliotecas disponíveis para facilitar a programação e o acesso a estes pinos do expansor. E claro: ao usar estes expansores, atente para o consumo de energia, já que está acrescentando Hardware.
Espero ter ajudado a esclarecer as dúvidas.
Abrçs
Elcids…
Adicionado por Elcids Chagas ao 20:08 em 24 abril 2020