Kit de iniciação Arduino Keyestudio
Este Kit de iniciação foi desenvolvido a pensar naqueles que se querem iniciar no mundo do Arduino. Inclui uma seleção dos componentes eletrónicos mais úteis para realizar diversos projetos. Para ajudar o utilizador numa fase inicial, são disponibilizados 21 tutoriais de projetos básicos, como por exemplo o “Semáforo”, “Controlo Remoto por infravermelho”. Além disso, estes tutoriais incluem vídeos de demonstração do projeto, diagramas de conexão e os códigos de programação.
Inclui
5 LEDs Azuis
5 LEDs Vermelhos
5 LEDs Amarelos
1 LED RGB
5 Resistências 10K Ω
5 Resistências 1K Ω
8 Resistências 220K Ω
1 Pot 10K Ω
1 Display LED 7 segmentos 1 dígito
1 Display LED segmentos 4 dígitos
1 Matriz LED 8×8
1 Buzzer Ativo
1 Buzzer Passivo
1 Sensor de Chama
1 Recetor Infravermelho
1 Controlo Remoto por Infravermelho
1 Sensor de temperatura LM35
2 Sensor de inclinação
3 Resistências Foto
4 Botões pequenos switch
1 Dip 16 pinos IC 74HC595N
1 Display LCD 16×2
1 Servo 9g
1 Breadboard 839 pinos
1 conjunto de cabos jumper
1 Suporte para pilhas
Placa controladora Arduino
Tem três opções de adquirir este Kit de Iniciação: com Placa Controladora Arduino UNO R3, com Placa Controladora Controladora MEGA 2560 ou sem placa controladora. Se já tem uma placa Arduino, poderá adquirir a versão sem placa controladora. No entanto, se pretende adquirir um kit já com uma placa Arduino incluída, poderá consultar mais informações sobre as placas no ABC Robótica:
| Placa |
Sem Placa, Placa UNO R3, Placa MEGA 2560
|
Projeto 1: Olá, mundo!
int val;//define variable val
int ledpin=13;// define digital interface 13
void setup()
{
Serial.begin(9600);// set the baud rate at 9600 to match the software set up. When connected to a specific device, (e.g. bluetooth), the baud rate needs to be the same with it.
pinMode(ledpin,OUTPUT);// initialize digital pin 13 as output. When using I/O ports on an Arduino, this kind of set up is always needed.
}
void loop()
{
val=Serial.read();// read the instruction or character from PC to Arduino, and assign them to Val.
if(val=='R')// determine if the instruction or character received is “R”.
{ // if it’s “R”,
digitalWrite(ledpin,HIGH);// set the LED on digital pin 13 on.
delay(500);
digitalWrite(ledpin,LOW);// set the LED on digital pin 13 off. delay(500);
Serial.println("Hello World!");// display“Hello World！”string.
}
Projeto 2: LED intermitente
int ledPin = 10; // define digital pin 10.
void setup()
{
pinMode(ledPin, OUTPUT);// define pin with LED connected as output.
}
void loop()
{
digitalWrite(ledPin, HIGH); // set the LED on.
delay(1000); // wait for a second.
digitalWrite(ledPin, LOW); // set the LED off.
delay(1000); // wait for a second
}
Projeto 3: Controlo de Brilho de LED com PWM
int potpin=0;// initialize analog pin 0
int ledpin=11;//initialize digital pin 11（PWM output）
int val=0;// Temporarily store variables' value from the sensor
void setup()
{
pinMode(ledpin,OUTPUT);// define digital pin 11 as “output”
Serial.begin(9600);// set baud rate at 9600
// attention: for analog ports, they are automatically set up as “input”
}
void loop()
{
val=analogRead(potpin);// read the analog value from the sensor and assign it to val
Serial.println(val);// display value of val
analogWrite(ledpin,val/4);// turn on LED and set up brightness（maximum output of PWM is 255）
delay(10);// wait for 0.01 second
}
Projeto 4: Luzes de semáforo
int redled =10; // initialize digital pin 8.
int yellowled =7; // initialize digital pin 7.
int greenled =4; // initialize digital pin 4.
void setup()
{
pinMode(redled, OUTPUT);// set the pin with red LED as “output”
pinMode(yellowled, OUTPUT); // set the pin with yellow LED as “output”
pinMode(greenled, OUTPUT); // set the pin with green LED as “output”
}
void loop()
{
digitalWrite(greenled, HIGH);//// turn on green LED
delay(5000);// wait 5 seconds
digitalWrite(greenled, LOW); // turn off green LED
for(int i=0;i<3;i++)// blinks for 3 times
{
delay(500);// wait 0.5 second
digitalWrite(yellowled, HIGH);// turn on yellow LED
delay(500);// wait 0.5 second
digitalWrite(yellowled, LOW);// turn off yellow LED
}
delay(500);// wait 0.5 second
digitalWrite(redled, HIGH);// turn on red LED
delay(5000);// wait 5 second
digitalWrite(redled, LOW);// turn off red LED
}
Projeto 5: Efeito de perseguição de LED
int BASE = 2 ; // the I/O pin for the first LED
int NUM = 6; // number of LEDs
void setup()
{
for (int i = BASE; i < BASE + NUM; i ++)
{
pinMode(i, OUTPUT); // set I/O pins as output
}
}
void loop()
{
for (int i = BASE; i < BASE + NUM; i ++)
{
digitalWrite(i, LOW); // set I/O pins as “low”, turn off LEDs one by one.
delay(200); // delay
}
for (int i = BASE; i < BASE + NUM; i ++)
{
digitalWrite(i, HIGH); // set I/O pins as “high”, turn on LEDs one by one
delay(200); // delay
}
Projeto 6: Controlo de LED com botão
int ledpin=11;// initialize pin 11
int inpin=7;// initialize pin 7
int val;// define val
void setup()
{
pinMode(ledpin,OUTPUT);// set LED pin as “output”
pinMode(inpin,INPUT);// set button pin as “input”
}
void loop()
{
val=digitalRead(inpin);// read the level value of pin 7 and assign if to val
if(val==LOW)// check if the button is pressed, if yes, turn on the LED
{ digitalWrite(ledpin,LOW);}
else
{ digitalWrite(ledpin,HIGH);}
}
Projeto 7: Alarme ativo
int buzzer=8;// initialize digital IO pin that controls the buzzer
void setup()
{
pinMode(buzzer,OUTPUT);// set pin mode as “output”
}
void loop()
{
digitalWrite(buzzer, HIGH); // produce sound
}
Projeto 8: Alarme passivo
int buzzer=8;// select digital IO pin for the buzzer
void setup()
{
pinMode(buzzer,OUTPUT);// set digital IO pin pattern, OUTPUT to be output
}
void loop()
{ unsigned char i,j;//define variable
while(1)
{ for(i=0;i<80;i++)// output a frequency sound
{ digitalWrite(buzzer,HIGH);// sound
delay(1);//delay1ms
digitalWrite(buzzer,LOW);//not sound
delay(1);//ms delay
}
for(i=0;i<100;i++)// output a frequency sound
{
digitalWrite(buzzer,HIGH);// sound
digitalWrite(buzzer,LOW);//not sound
delay(2);//2ms delay
}
Projeto 9: LED RGB
int redpin = 11; //select the pin for the red LED
int bluepin =10; // select the pin for the blue LED
int greenpin =9;// select the pin for the green LED
int val;
void setup() {
pinMode(redpin, OUTPUT);
pinMode(bluepin, OUTPUT);
pinMode(greenpin, OUTPUT);
Serial.begin(9600);
}
void loop()
{
for(val=255; val>0; val--)
{
analogWrite(11, val);
analogWrite(10, 255-val);
analogWrite(9, 128-val);
delay(1);
}
for(val=0; val<255; val++)
{
analogWrite(11, val);
analogWrite(10, 255-val);
analogWrite(9, 128-val);
delay(1);
}
Serial.println(val, DEC);
}
Projeto 10: Fotoresistência
int potpin=0;// initialize analog pin 0, connected with photovaristor
int ledpin=11;// initialize digital pin 11, output regulating the brightness of LED
int val=0;// initialize variable va
void setup()
{
pinMode(ledpin,OUTPUT);// set digital pin 11 as “output”
Serial.begin(9600);// set baud rate at “9600”
}
void loop()
{
val=analogRead(potpin);// read the analog value of the sensor and assign it to val
Serial.println(val);// display the value of val
analogWrite(ledpin,val);// turn on the LED and set up brightness（maximum output value 255）
delay(10);// wait for 0.01
}
Projeto 11: Sensor de chama
int flame=0;// select analog pin 0 for the sensor
int Beep=9;// select digital pin 9 for the buzzer
int val=0;// initialize variable
void setup()
{
pinMode(Beep,OUTPUT);// set LED pin as “output”
pinMode(flame,INPUT);// set buzzer pin as “input”
Serial.begin(9600);// set baud rate at “9600”
}
void loop()
{
val=analogRead(flame);// read the analog value of the sensor
Serial.println(val);// output and display the analog value
if(val>=600)// when the analog value is larger than 600, the buzzer will buzz
{
digitalWrite(Beep,HIGH);
}else
{
digitalWrite(Beep,LOW);
}
delay(500);
}
Projeto 12: Sensor de temperatura LM35
int potPin = 0; // initialize analog pin 0 for LM35 temperature sensor
void setup()
{
Serial.begin(9600);// set baud rate at”9600”
}
void loop()
{
int val;// define variable
int dat;// define variable
val=analogRead(0);// read the analog value of the sensor and assign it to val
dat=(125*val)>>8;// temperature calculation formula
Serial.print("Tep:");// output and display characters beginning with Tep
Serial.print(dat);// output and display value of dat
Serial.println("C");// display “C” characters
delay(500);// wait for 0.5 second
}
Projeto 13: Interruptor por inclinação
void setup()
{
pinMode(8,OUTPUT);// set digital pin 8 as “output”
}
void loop()
{
int i;// define variable i
while(1)
{
i=analogRead(5);// read the voltage value of analog pin 5
if(i>512)// if larger that 512（2.5V）
{
digitalWrite(8,LOW);// turn on LED
}
else// otherwise
{
digitalWrite(8,HIGH);// turn off LED
}
Projeto 14: Controlo Remoto por infravermelho
#include
int RECV_PIN = 11;
int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
long on1 = 0x00FFA25D;
long off1 = 0x00FFE01F;
long on2 = 0x00FF629D;
long off2 = 0x00FFA857;
long on3 = 0x00FFE21D;
long off3 = 0x00FF906F;
long on4 = 0x00FF22DD;
long off4 = 0x00FF6897;
long on5 = 0x00FF02FD;
long off5 = 0x00FF9867;
long on6 = 0x00FFC23D;
long off6 = 0x00FFB047;
IRrecv irrecv(RECV_PIN);
decode_results results;
// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
// void * to work around compiler issue
//void dump(void *v) {
// decode_results *results = (decode_results *)v
void dump(decode_results *results) {
int count = results->rawlen;
if (results->decode_type == UNKNOWN)
{
Serial.println("Could not decode message");
}
else
{
if (results->decode_type == NEC)
{
Serial.print("Decoded NEC: ");
}
else if (results->decode_type == SONY)
{
Serial.print("Decoded SONY: ");
}
else if (results->decode_type == RC5)
{
Serial.print("Decoded RC5: ");
}
else if (results->decode_type == RC6)
{
Serial.print("Decoded RC6: ");
}
Serial.print(results->value, HEX);
Serial.print(" (");
Serial.print(results->bits, DEC);
Serial.println(" bits)");
}
Serial.print("Raw (");
Serial.print(count, DEC);
Serial.print("): ");
for (int i = 0; i < count; i++) { if ((i % 2) == 1) { Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
}
else
{
Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
}
Serial.print(" ");
}
Serial.println("");
}
void setup()
{
pinMode(RECV_PIN, INPUT);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(LED3, OUTPUT);
pinMode(LED4, OUTPUT);
pinMode(LED5, OUTPUT);
pinMode(LED6, OUTPUT);
pinMode(13, OUTPUT);
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}
int on = 0;
unsigned long last = millis();
void loop()
{
if (irrecv.decode(&results))
{
// If it's been at least 1/4 second since the last
// IR received, toggle the relay
if (millis() - last > 250)
{
on = !on;
// digitalWrite(8, on ? HIGH : LOW);
digitalWrite(13, on ? HIGH : LOW);
dump(&results);
}
if (results.value == on1 )
digitalWrite(LED1, HIGH);
if (results.value == off1 )
digitalWrite(LED1, LOW);
if (results.value == on2 )
digitalWrite(LED2, HIGH);
if (results.value == off2 )
digitalWrite(LED2, LOW);
if (results.value == on3 )
digitalWrite(LED3, HIGH);
if (results.value == off3 )
digitalWrite(LED3, LOW);
if (results.value == on4 )
digitalWrite(LED4, HIGH);
if (results.value == off4 )
digitalWrite(LED4, LOW);
if (results.value == on5 )
digitalWrite(LED5, HIGH);
if (results.value == off5 )
digitalWrite(LED5, LOW);
if (results.value == on6 )
digitalWrite(LED6, HIGH);
if (results.value == off6 )
digitalWrite(LED6, LOW);
last = millis();
irrecv.resume(); // Receive the next value
}
Projeto 15: Leitura de valores analógicos
int potpin=0;// initialize analog pin 0
int ledpin=13;// initialize digital pin 13
int val=0;// define val, assign initial value 0
void setup()
{
pinMode(ledpin,OUTPUT);// set digital pin as “output”
Serial.begin(9600);// set baud rate at 9600
}
void loop()
{
digitalWrite(ledpin,HIGH);// turn on the LED on pin 13
delay(50);// wait for 0.05 second
digitalWrite(ledpin,LOW);// turn off the LED on pin 13
delay(50);// wait for 0.05 second
val=analogRead(potpin);// read the analog value of analog pin 0, and assign it to val
Serial.println(val);// display val’s value
}
Projeto 16: Controlo de LEDs com 74HC595N
int data = 2;// set pin 14 of 74HC595as data input pin SI
int clock = 5;// set pin 11 of 74hc595 as clock pin SCK
int latch = 4;// set pin 12 of 74hc595 as output latch RCK
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
}
void loop()
{
for(int i = 0; i < 256; i++)
{
updateLEDs(i);
delay(500);
}
Projeto 17: Display LED de 1 dígito
// set the IO pin for each segment
int a=7;// set digital pin 7 for segment a
int b=6;// set digital pin 6 for segment b
int c=5;// set digital pin 5 for segment c
int d=10;// set digital pin 10 for segment d
int e=11;// set digital pin 11 for segment e
int f=8;// set digital pin 8 for segment f
int g=9;// set digital pin 9 for segment g
int dp=4;// set digital pin 4 for segment dp
void digital_0(void) // display number 5
{
unsigned char j;
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,LOW);
digitalWrite(dp,LOW);
}
void digital_1(void) // display number 1
{
unsigned char j;
digitalWrite(c,HIGH);// set level as “high” for pin 5, turn on segment c
digitalWrite(b,HIGH);// turn on segment b
for(j=7;j<=11;j++)// turn off other segments
digitalWrite(j,LOW);
digitalWrite(dp,LOW);// turn off segment dp
}
void digital_2(void) // display number 2
{
unsigned char j;
digitalWrite(b,HIGH);
digitalWrite(a,HIGH);
for(j=9;j<=11;j++)
digitalWrite(j,HIGH);
digitalWrite(dp,LOW);
digitalWrite(c,LOW);
digitalWrite(f,LOW);
}
void digital_3(void) // display number 3
{
digitalWrite(g,HIGH);
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(dp,LOW);
digitalWrite(f,LOW);
digitalWrite(e,LOW);
}
void digital_4(void) // display number 4
{
digitalWrite(c,HIGH);
digitalWrite(b,HIGH);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
digitalWrite(a,LOW);
digitalWrite(e,LOW);
digitalWrite(d,LOW);
}
void digital_5(void) // display number 5
{
unsigned char j;
digitalWrite(a,HIGH);
digitalWrite(b, LOW);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e, LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void digital_6(void) // display number 6
{
unsigned char j;
for(j=7;j<=11;j++)
digitalWrite(j,HIGH);
digitalWrite(c,HIGH);
digitalWrite(dp,LOW);
digitalWrite(b,LOW);
}
void digital_7(void) // display number 7
{
unsigned char j;
for(j=5;j<=7;j++)
digitalWrite(j,HIGH);
digitalWrite(dp,LOW);
for(j=8;j<=11;j++)
digitalWrite(j,LOW);
}
void digital_8(void) // display number 8
{
unsigned char j;
for(j=5;j<=11;j++)
digitalWrite(j,HIGH);
digitalWrite(dp,LOW);
}
void digital_9(void) // display number 5
{
unsigned char j;
digitalWrite(a,HIGH);
digitalWrite(b,HIGH);
digitalWrite(c,HIGH);
digitalWrite(d,HIGH);
digitalWrite(e, LOW);
digitalWrite(f,HIGH);
digitalWrite(g,HIGH);
digitalWrite(dp,LOW);
}
void setup()
{
int i;// set variable
for(i=4;i<=11;i++)
pinMode(i,OUTPUT);// set pin 4-11as “output”
}
void loop()
{
while(1)
{
digital_0();// display number 0
delay(1000);// wait for 1s
digital_1();// display number 1
delay(1000);// wait for 1s
digital_2();// display number 2
delay(1000); // wait for 1s
digital_3();// display number 3
delay(1000); // wait for 1s
digital_4();// display number 4
delay(1000); // wait for 1s
digital_5();// display number 5
delay(1000); // wait for 1s
digital_6();// display number 6
delay(1000); // wait for 1s
digital_7();// display number 7
delay(1000); // wait for 1s
digital_8();// display number 8
delay(1000); // wait for 1s
digital_9();// display number 9
delay(1000); // wait for 1s
}
Projeto 18: Display LED de 4 dígitos
// display 1234
// select pin for cathode
int a = 1;
int b = 2;
int c = 3;
int d = 4;
int e = 5;
int f = 6;
int g = 7;
int dp = 8;
// select pin for anode
int d4 = 9;
int d3 = 10;
int d2 = 11;
int d1 = 12;
// set variable
long n = 1230;
int x = 100;
int del = 55; // fine adjustment for clock
void setup()
{
pinMode(d1, OUTPUT);
pinMode(d2, OUTPUT);
pinMode(d3, OUTPUT);
pinMode(d4, OUTPUT);
pinMode(a, OUTPUT);
pinMode(b, OUTPUT);
pinMode(c, OUTPUT);
pinMode(d, OUTPUT);
pinMode(e, OUTPUT);
pinMode(f, OUTPUT);
pinMode(g, OUTPUT);
pinMode(dp, OUTPUT);
}
void loop()
{
Display(1, 1);
Display(2, 2);
Display(3, 3);
Display(4, 4);
}
void WeiXuan(unsigned char n)//
{
switch(n)
{
case 1:
digitalWrite(d1,LOW);
digitalWrite(d2, HIGH);
digitalWrite(d3, HIGH);
digitalWrite(d4, HIGH);
break;
case 2:
digitalWrite(d1, HIGH);
digitalWrite(d2, LOW);
digitalWrite(d3, HIGH);
digitalWrite(d4, HIGH);
break;
case 3:
digitalWrite(d1,HIGH);
digitalWrite(d2, HIGH);
digitalWrite(d3, LOW);
digitalWrite(d4, HIGH);
break;
case 4:
digitalWrite(d1, HIGH);
digitalWrite(d2, HIGH);
digitalWrite(d3, HIGH);
digitalWrite(d4, LOW);
break;
default :
digitalWrite(d1, HIGH);
digitalWrite(d2, HIGH);
digitalWrite(d3, HIGH);
digitalWrite(d4, HIGH);
break;
}
}
void Num_0()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, LOW);
digitalWrite(dp,LOW);
}
void Num_1()
{
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
digitalWrite(dp,LOW);
}
void Num_2()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, LOW);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Num_3()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Num_4()
{
digitalWrite(a, LOW);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Num_5()
{
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Num_6()
{
digitalWrite(a, HIGH);
digitalWrite(b, LOW);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Num_7()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
digitalWrite(dp,LOW);
}
void Num_8()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, HIGH);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Num_9()
{
digitalWrite(a, HIGH);
digitalWrite(b, HIGH);
digitalWrite(c, HIGH);
digitalWrite(d, HIGH);
digitalWrite(e, LOW);
digitalWrite(f, HIGH);
digitalWrite(g, HIGH);
digitalWrite(dp,LOW);
}
void Clear() // clear the screen
{
digitalWrite(a, LOW);
digitalWrite(b, LOW);
digitalWrite(c, LOW);
digitalWrite(d, LOW);
digitalWrite(e, LOW);
digitalWrite(f, LOW);
digitalWrite(g, LOW);
digitalWrite(dp,LOW);
}
void pickNumber(unsigned char n)// select number
{
switch(n)
{
case 0:Num_0();
break;
case 1:Num_1();
break;
case 2:Num_2();
break;
case 3:Num_3();
break;
case 4:Num_4();
break;
case 5:Num_5();
break;
case 6:Num_6();
break;
case 7:Num_7();
break;
case 8:Num_8();
break;
case 9:Num_9();
break;
default:Clear();
break;
}
}
void Display(unsigned char x, unsigned char Number)// take x as coordinate and display number
{
WeiXuan(x);
pickNumber(Number);
delay(1);
Clear() ; // clear the screen
}
Projeto 19: Display Matriz de LED 8×8
// set an array to store character of “0”
unsigned char Text[]={0x00,0x1c,0x22,0x22,0x22,0x22,0x22,0x1c};
void Draw_point(unsigned char x,unsigned char y)// point drawing function
{ clear_();
digitalWrite(x+2, HIGH);
digitalWrite(y+10, LOW);
delay(1);
}
void show_num(void)// display function, call point drawing function
{
unsigned char i,j,data;
for(i=0;i<8;i++)
{
data=Text[i];
for(j=0;j<8;j++) { if(data & 0x01)Draw_point(j,i); data>>=1;
}
}
}
void setup(){
int i = 0 ;
for(i=2;i<18;i++)
{
pinMode(i, OUTPUT);
}
clear_();
}
void loop()
{ show_num();
}
void clear_(void)// clear screen
{for(int i=2;i<10;i++)
digitalWrite(i, LOW);
for(int i=0;i<8;i++)
digitalWrite(i+10, HIGH);
}
}
Projeto 20: Display LCD 16 x 2
int DI = 12;
int RW = 11;
int DB[] = {3, 4, 5, 6, 7, 8, 9, 10};// use array to select pin for bus
int Enable = 2;
void LcdCommandWrite(int value) {
// define all pins
int i = 0;
for (i=DB[0]; i <= DI; i++) // assign value for bus { digitalWrite(i,value & 01);// for 1602 LCD, it uses D7-D0( not D0-D7) for signal identification; here, it’s used for signal inversion. value >>= 1;
}
digitalWrite(Enable,LOW);
delayMicroseconds(1);
digitalWrite(Enable,HIGH);
delayMicroseconds(1); // wait for 1ms
digitalWrite(Enable,LOW);
delayMicroseconds(1); // wait for 1ms
}
void LcdDataWrite(int value) {
// initialize all pins
int i = 0;
digitalWrite(DI, HIGH);
digitalWrite(RW, LOW);
for (i=DB[0]; i <= DB[7]; i++) { digitalWrite(i,value & 01); value >>= 1;
}
digitalWrite(Enable,LOW);
delayMicroseconds(1);
digitalWrite(Enable,HIGH);
delayMicroseconds(1);
digitalWrite(Enable,LOW);
delayMicroseconds(1); // wait for 1ms
}
void setup (void) {
int i = 0;
for (i=Enable; i <= DI; i++) {
pinMode(i,OUTPUT);
}
delay(100);
// initialize LCD after a brief pause
// for LCD control
LcdCommandWrite(0x38); // select as 8-bit interface, 2-line display, 5x7 character size
delay(64);
LcdCommandWrite(0x38); // select as 8-bit interface, 2-line display, 5x7 character size
delay(50);
LcdCommandWrite(0x38); // select as 8-bit interface, 2-line display, 5x7 character size
delay(20);
LcdCommandWrite(0x06); // set input mode
// auto-increment, no display of shifting
delay(20);
LcdCommandWrite(0x0E); // display setup
// turn on the monitor, cursor on, no flickering
delay(20);
LcdCommandWrite(0x01); // clear the scree, cursor position returns to 0
delay(100);
LcdCommandWrite(0x80); // display setup
// turn on the monitor, cursor on, no flickering
delay(20);
}
void loop (void) {
LcdCommandWrite(0x01); // clear the scree, cursor position returns to 0
delay(10);
LcdCommandWrite(0x80+3);
delay(10);
// write in welcome message
LcdDataWrite('W');
LcdDataWrite('e');
LcdDataWrite('l');
LcdDataWrite('c');
LcdDataWrite('o');
LcdDataWrite('m');
LcdDataWrite('e');
LcdDataWrite(' ');
LcdDataWrite('t');
LcdDataWrite('o');
delay(10);
LcdCommandWrite(0xc0+1); // set cursor position at second line, second position
delay(10);
LcdDataWrite('g');
LcdDataWrite('e');
LcdDataWrite('e');
LcdDataWrite('k');
LcdDataWrite('-');
LcdDataWrite('w');
LcdDataWrite('o');
LcdDataWrite('r');
LcdDataWrite('k');
LcdDataWrite('s');
LcdDataWrite('h');
LcdDataWrite('o');
LcdDataWrite('p');
delay(5000);
LcdCommandWrite(0x01); // clear the screen, cursor returns to 0
delay(10);
LcdDataWrite('I');
LcdDataWrite(' ');
LcdDataWrite('a');
LcdDataWrite('m');
LcdDataWrite(' ');
LcdDataWrite('h');
LcdDataWrite('o');
LcdDataWrite('n');
LcdDataWrite('g');
LcdDataWrite('y');
LcdDataWrite('i');
delay(3000);
LcdCommandWrite(0x02); // set mode as new characters replay old ones, where there is no new ones remain the same
delay(10);
LcdCommandWrite(0x80+5); // set cursor position at first line, sixth position
delay(10);
LcdDataWrite('t');
LcdDataWrite('h');
LcdDataWrite('e');
LcdDataWrite(' ');
LcdDataWrite('a');
LcdDataWrite('d');
LcdDataWrite('m');
LcdDataWrite('i');
LcdDataWrite('n');
delay(5000);
}
}
Projeto 21: Controlo de servomotor
int LCD1602_RS=12;
int LCD1602_RW=11;
int LCD1602_EN=10;
int DB[] = { 6, 7, 8, 9};
char str1[]="Welcome to";
char str2[]="geek-workshop";
char str3[]="this is the";
char str4[]="4-bit interface";
void LCD_Command_Write(int command)
{
int i,temp;
digitalWrite( LCD1602_RS,LOW);
digitalWrite( LCD1602_RW,LOW);
digitalWrite( LCD1602_EN,LOW);
temp=command & 0xf0;
for (i=DB[0]; i <= 9; i++)
{
digitalWrite(i,temp & 0x80);
temp <<= 1;
}
digitalWrite( LCD1602_EN,HIGH);
delayMicroseconds(1);
digitalWrite( LCD1602_EN,LOW);
temp=(command & 0x0f)<<4;
for (i=DB[0]; i <= 10; i++)
{
digitalWrite(i,temp & 0x80);
temp <<= 1;
}
digitalWrite( LCD1602_EN,HIGH);
delayMicroseconds(1);
digitalWrite( LCD1602_EN,LOW);
}
void LCD_Data_Write(int dat)
{
int i=0,temp;
digitalWrite( LCD1602_RS,HIGH);
digitalWrite( LCD1602_RW,LOW);
digitalWrite( LCD1602_EN,LOW);
temp=dat & 0xf0;
for (i=DB[0]; i <= 9; i++)
{
digitalWrite(i,temp & 0x80);
temp <<= 1;
}
digitalWrite( LCD1602_EN,HIGH);
delayMicroseconds(1);
digitalWrite( LCD1602_EN,LOW);
temp=(dat & 0x0f)<<4;
for (i=DB[0]; i <= 10; i++)
{
digitalWrite(i,temp & 0x80);
temp <<= 1;
}
digitalWrite( LCD1602_EN,HIGH);
delayMicroseconds(1);
digitalWrite( LCD1602_EN,LOW);
}
void LCD_SET_XY( int x, int y )
{
int address;
if (y ==0) address = 0x80 + x;
else address = 0xC0 + x;
LCD_Command_Write(address);
}
void LCD_Write_Char( int x,int y,int dat)
{
LCD_SET_XY( x, y );
LCD_Data_Write(dat);
}
void LCD_Write_String(int X,int Y,char *s)
{
LCD_SET_XY( X, Y ); // address setup
while (*s) // write character string
{
LCD_Data_Write(*s);
s ++;
}
}
void setup (void)
{
int i = 0;
for (i=6; i <= 12; i++)
{
pinMode(i,OUTPUT);
}
delay(100);
LCD_Command_Write(0x28);// 4 wires, 2 lines 5x7
delay(50);
LCD_Command_Write(0x06);
delay(50);
LCD_Command_Write(0x0c);
delay(50);
LCD_Command_Write(0x80);
delay(50);
LCD_Command_Write(0x01);
delay(50);
}
void loop (void)
{
LCD_Command_Write(0x01);
delay(50);
LCD_Write_String(3,0,str1);// line 1, start at the fourth address
delay(50);
LCD_Write_String(1,1,str2);// line 2, start at the second address
delay(5000);
LCD_Command_Write(0x01);
delay(50);
LCD_Write_String(0,0,str3);
delay(50);
LCD_Write_String(0,1,str4);
delay(5000);
}
Projetos UNO R3
Projeto 1: ‘Olá, mundo!’
Este é um exercício de comunicação muito básico que permite ao Arduino enviar a mensagem “Olá, mundo!” ao computador, mediante a instrução do utilizador. Conecte a placa controladora ao seu computador, através do cabo USB, abra a sua plataforma Arduino e copie para lá o código correspondente a este projeto (pode consultá-lo no separador Programação). Clique ‘Upload’, para que a informação seja enviada para a placa. Abra uma janela serial monitor no seu Arduino IDE, escreva ‘R’, envie e, como resultado, verá a mensagem ‘Olá, Mundo!’.
Componentes necessários:
Placa controladora Arduino UNO R3
Cabo USB
Ver vídeo
Projeto 2: LED intermitente
Depois do exercício de iniciação, é a vez de controlar a intermitência de um LED. Para começar, é necessário realizar as conexões entre o LED, a resistência, a Placa de controlo e a Breadboard, tal como mostra o diagrama de conexão. Neste caso, opta-se por conectar o LED a uma resistência de 220Ω, para evitar que o LED seja danificado pela alta corrente. Ligue a placa controladora ao seu computador, abra o Arduino, insira e carregue o código deste projeto (pode consultá-lo no separador Programação) e verá o LED a ligar e desligar, em curtos intervalos de tempo.
Componentes necessários:
1 LED vermelho
1 Resistência 220Ω
Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 3: Controlo de Brilho de LED com PWM
Neste exercício, utiliza-se um potenciómetro e uma porta PWM para controlar o brilho de um LED. Depois de conectar os componentes de acordo com o diagrama de conexão (o LED a uma porta PWM e o potenciómetro a uma porta analógica), ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Poderá ver que o brilho do LED se altera quando o potenciómetro é ajustado.
Componentes necessários:
1 Potenciómetro
1 LED vermelho
1 Resistência 220Ω
Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 4: Luzes de semáforo
Utilizando três LEDs de cores diferentes, é possível simular o sistema de luzes de um semáforo real, dando a cada um dos LEDs um tempo de intermitência apropriado. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o . Poderá ver os três LEDs a ligar segundo o padrão de um semáforo.
Componentes necessários:
1 LED vermelho
1 LED amarelo
1 LED azul
3 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 5: Efeito de perseguição de LED
Este projeto permite simular o efeito de perseguição com seis LEDs, que vão piscando sequencialmente. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Poderá ver que os seis LEDs vão ligar um de cada vez, por ordem, e quando estiverem todos ligados, vão começar a desligar um a um, pela mesma ordem.
Componentes necessários:
6 LEDs
6 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 6: Controlo de LED com botão
Este exercício permite ligar e desligar um LED através de um botão. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Poderá ver que o LED permanece ligado quando carrega no botão e se desliga quando deixa de carregar.
Componentes necessários:
1 LED
1 Resistência 220Ω
1 Resistência 10Ω
1 Botão Switch
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 7: Alarme ativo
Neste projeto, utiliza-se um buzzer ativo para produzir som. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Logo que este processo esteja concluído, irá ouvir o buzzer tocar continuamente.
Componentes necessários:
1 Buzzer Ativo
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 8: Alarme passivo
Desta vez, a produção de som será concretizada através de um buzzer passivo. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Logo que este processo esteja concluído, irá ouvir o buzzer tocar, em intervalos de 1ms.
Componentes necessários:
1 Buzzer Passivo
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 9: LED RGB
Com este projeto, é possível aprender a utilizar um LED RGB, um LED diferente que emite três cores: vermelho, verde e azul. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Quando o upload estiver terminado, poderá ver o LED a emitir cores diferentes, de acordo com os parâmetros da programação.
Componentes necessários:
1 LED RGB
3 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 10: Fotoresistência
Agora que já foram abordados alguns dos conceitos mais básicos do Arduino, é a altura de começar a realizar alguns projetos com sensores. Neste exercício, utilizaremos uma fotoresistência, cuja resistência é alterada consoante a força de incidência da luz. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver terminado, abra uma janela serial monitor para ver os valores da resistência. Poderá fazer com que estes valores e o brilho do LED mudem alterando as condições do meio, nomeadamente tapando a fotoresistência com os dedos – neste caso, tanto os valores como o brilho do LED vão aumentar.
Componentes necessários:
1 Fotoresistência
1 LED
1 Resistência 220Ω
1 Resistência 10KΩ
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 11: Sensor de chama
Neste projeto, podemos simular um alarme de incêndio. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver terminado, abra uma janela serial monitor para analisar as alterações de valores que surgem consoante as mudanças no meio. Verá, por exemplo, que ao acender um isqueiro perto do sensor os valores vão aumentar.
Componentes necessários:
1 Sensor de chama
1 Buzzer
1 Resistência 10KΩ
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 12: Sensor de temperatura LM35
Este exercício permite medir a temperatura com um sensor LM35. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, abra uma janela serial monitor, onde aparecerão os valores de temperatura do momento.
Componentes necessários:
1 Sensor de temperatura LM35
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 13: Interruptor por inclinação
Neste projeto, utilizaremos um sensor de inclinação com um interruptor de um LED. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, verá que o LED estará desligado. Para o ligar, basta inclinar a breadboard.
Componentes necessários:
1 Sensor de temperatura LM35
1 Resistência 220Ω
1 Resistência 10KΩ
1 LED
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 14: Controlo Remoto por infravermelho
Desta vez, iremos controlar os LEDs através de um comando de controlo remoto por infravermelhos. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino e insira o código deste projeto (pode consultá-lo no separador Programação). Antes de carregar o código, deve adicionar a pasta ‘Controlo Remoto’ ao diretório de bibliotecas Arduino, caso contrário não conseguirá compilar o programa. Assim que o upload estiver concluído, poderá começar a ligar e desligar os LEDs com o seu comando, sabendo que para cada LED existem dois botões de controlo no comando.
Componentes necessários:
1 Comando controlo remoto infravermelho
1 Recetor de infravermelhos
8 Resistências 220Ω
6 LEDs
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 15: Leitura de valores analógicos
Neste projeto, iremos converter os valores da resistência do potenciómetro para valores analógicos e a mostrá-los no ecrã. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, abra uma janela serial monitor e verá os valores atuais da resistência do potenciómetro. Ao rodar o potenciómetro, verificará que os valores também se vão alterar.
Componentes necessários:
1 Potenciómetro
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 16: Controlo de LEDs com 74HC595N
Agora vamos aprender a controlar oito LEDs com um chip 74HC595, utilizando apenas três portas. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, abra uma janela serial monitor. Para ligar e desligar os 8 LEDs basta jogar com o código binário 0 e 1, sendo que 0 significa on e 1 significa off.
Componentes necessários:
1 Chip 74HC595
8 Resistências 220Ω
4 LEDs azuis
4 LEDs vermelhos
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 17: Display LED de 1 dígito
Este projeto permite aprender a utilizar um Display Led de 7 segmentos de 1 dígito. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai começar a mostrar números de 1 a 9, em intervalos de um segundo.
Componentes necessários:
1 Display LED de 1 dígito
8 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 18: Display LED de 4 dígitos
Desta vez, vamos aprender a utilizar um Display Led de 7 segmentos de 4 dígito. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai começar a mostrar números de 1 a 4. Poderá alterar os números que aparecem no código de programação.
Componentes necessários:
1 Display LED de 4 dígito
8 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 19: Display Matriz de LED 8×8
Neste projeto, utilizaremos um Display Matriz de LED 8 x 8 para transmitir informação. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai começar a mostrar o número 0, como se estivesse a brilhar. Poderá alterar o número que é mostrado no código de programação.
Componentes necessários:
1 Display Matriz de LED 8×8
8 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 20: Display LCD 16 x 2
Com este exercício, vamos aprender a utilizar um Display LCD 16 x 2. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai mostrar os caracteres que foram definidos no programa. Pode utilizar o potenciómetro para ajustar o brilho do Display. Caso entenda, pode alterar a mensagem transmitida para outra, no código de programação.
Componentes necessários:
1 Display LCD 16 x 2
1 Potenciómetro
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Projeto 21: Controlo de servomotor
Neste último projeto, é a vez de aprendermos a utilizar um servomotor. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino e insira o código deste projeto (pode consultá-lo no separador Programação). Antes de carregar o código, deve adicionar o ficheiro ‘Servo.h’ ao diretório de bibliotecas Arduino, caso contrário não conseguirá compilar o programa. Assim que o upload estiver concluído, verá o servomotor a rodar 90 graus, como programado. Poderá alterar a programação de acordo com as necessidades do seu projeto.
Componentes necessários:
1 Servomotor 9g
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino UNO R3
Ver vídeo
Diagrama de conexão:
Para mais informações sobre estes projetos pode clicar aqui.
Projetos MEGA 2560
Projeto 1: ‘Olá, mundo!’
Este é um exercício de comunicação muito básico que permite ao Arduino enviar a mensagem “Olá, mundo!” ao computador, mediante a instrução do utilizador. Conecte a placa controladora ao seu computador, através do cabo USB, abra a sua plataforma Arduino e copie para lá o código correspondente a este projeto (pode consultá-lo no separador Programação). Clique ‘Upload’, para que a informação seja enviada para a placa. Abra uma janela serial monitor no seu Arduino IDE, escreva ‘R’, envie e, como resultado, verá a mensagem ‘Olá, Mundo!’.
Componentes necessários:
Placa controladora Arduino MEGA 2560
Cabo USB
Ver vídeo
Projeto 2: LED intermitente
Depois do exercício de iniciação, é a vez de controlar a intermitência de um LED. Para começar, é necessário realizar as conexões entre o LED, a resistência, a Placa de controlo e a Breadboard, tal como mostra o diagrama de conexão. Neste caso, opta-se por conectar o LED a uma resistência de 220Ω, para evitar que o LED seja danificado pela alta corrente. Ligue a placa controladora ao seu computador, abra o Arduino, insira e carregue o código deste projeto (pode consultá-lo no separador Programação) e verá o LED a ligar e desligar, em curtos intervalos de tempo.
Componentes necessários:
1 LED vermelho
1 Resistência 220Ω
Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 3: Controlo de Brilho de LED com PWM
Neste exercício, utiliza-se um potenciómetro e uma porta PWM para controlar o brilho de um LED. Depois de conectar os componentes de acordo com o diagrama de conexão (o LED a uma porta PWM e o potenciómetro a uma porta analógica), ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Poderá ver que o brilho do LED se altera quando o potenciómetro é ajustado.
Componentes necessários:
1 Potenciómetro
1 LED vermelho
1 Resistência 220Ω
Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 4: Luzes de semáforo
Utilizando três LEDs de cores diferentes, é possível simular o sistema de luzes de um semáforo real, dando a cada um dos LEDs um tempo de intermitência apropriado. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o . Poderá ver os três LEDs a ligar segundo o padrão de um semáforo.
Componentes necessários:
1 LED vermelho
1 LED amarelo
1 LED azul
3 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 5: Efeito de perseguição de LED
Este projeto permite simular o efeito de perseguição com seis LEDs, que vão piscando sequencialmente. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Poderá ver que os seis LEDs vão ligar um de cada vez, por ordem, e quando estiverem todos ligados, vão começar a desligar um a um, pela mesma ordem.
Componentes necessários:
6 LEDs
6 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 6: Controlo de LED com botão
Este exercício permite ligar e desligar um LED através de um botão. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Poderá ver que o LED permanece ligado quando carrega no botão e se desliga quando deixa de carregar.
Componentes necessários:
1 LED
1 Resistência 220Ω
1 Resistência 10Ω
1 Botão Switch
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 7: Alarme ativo
Neste projeto, utiliza-se um buzzer ativo para produzir som. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Logo que este processo esteja concluído, irá ouvir o buzzer tocar continuamente.
Componentes necessários:
1 Buzzer Ativo
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 8: Alarme passivo
Desta vez, a produção de som será concretizada através de um buzzer passivo. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Logo que este processo esteja concluído, irá ouvir o buzzer tocar, em intervalos de 1ms.
Componentes necessários:
1 Buzzer Passivo
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 9: LED RGB
Com este projeto, é possível aprender a utilizar um LED RGB, um LED diferente que emite três cores: vermelho, verde e azul. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Quando o upload estiver terminado, poderá ver o LED a emitir cores diferentes, de acordo com os parâmetros da programação.
Componentes necessários:
1 LED RGB
3 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 10: Fotoresistência
Agora que já foram abordados alguns dos conceitos mais básicos do Arduino, é a altura de começar a realizar alguns projetos com sensores. Neste exercício, utilizaremos uma fotoresistência, cuja resistência é alterada consoante a força de incidência da luz. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver terminado, abra uma janela serial monitor para ver os valores da resistência. Poderá fazer com que estes valores e o brilho do LED mudem alterando as condições do meio, nomeadamente tapando a fotoresistência com os dedos – neste caso, tanto os valores como o brilho do LED vão aumentar.
Componentes necessários:
1 Fotoresistência
1 LED
1 Resistência 220Ω
1 Resistência 10KΩ
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 11: Sensor de chama
Neste projeto, podemos simular um alarme de incêndio. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver terminado, abra uma janela serial monitor para analisar as alterações de valores que surgem consoante as mudanças no meio. Verá, por exemplo, que ao acender um isqueiro perto do sensor os valores vão aumentar.
Componentes necessários:
1 Sensor de chama
1 Buzzer
1 Resistência 10KΩ
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 12: Sensor de temperatura LM35
Este exercício permite medir a temperatura com um sensor LM35. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, abra uma janela serial monitor, onde aparecerão os valores de temperatura do momento.
Componentes necessários:
1 Sensor de temperatura LM35
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 13: Interruptor por inclinação
Neste projeto, utilizaremos um sensor de inclinação com um interruptor de um LED. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, verá que o LED estará desligado. Para o ligar, basta inclinar a breadboard.
Componentes necessários:
1 Sensor de temperatura LM35
1 Resistência 220Ω
1 Resistência 10KΩ
1 LED
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 14: Controlo Remoto por infravermelho
Desta vez, iremos controlar os LEDs através de um comando de controlo remoto por infravermelhos. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino e insira o código deste projeto (pode consultá-lo no separador Programação). Antes de carregar o código, deve adicionar a pasta ‘Controlo Remoto’ ao diretório de bibliotecas Arduino, caso contrário não conseguirá compilar o programa. Assim que o upload estiver concluído, poderá começar a ligar e desligar os LEDs com o seu comando, sabendo que para cada LED existem dois botões de controlo no comando.
Componentes necessários:
1 Comando controlo remoto infravermelho
1 Recetor de infravermelhos
8 Resistências 220Ω
6 LEDs
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 15: Leitura de valores analógicos
Neste projeto, iremos converter os valores da resistência do potenciómetro para valores analógicos e a mostrá-los no ecrã. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, abra uma janela serial monitor e verá os valores atuais da resistência do potenciómetro. Ao rodar o potenciómetro, verificará que os valores também se vão alterar.
Componentes necessários:
1 Potenciómetro
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 16: Controlo de LEDs com 74HC595N
Agora vamos aprender a controlar oito LEDs com um chip 74HC595, utilizando apenas três portas. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, abra uma janela serial monitor. Para ligar e desligar os 8 LEDs basta jogar com o código binário 0 e 1, sendo que 0 significa on e 1 significa off.
Componentes necessários:
1 Chip 74HC595
8 Resistências 220Ω
4 LEDs azuis
4 LEDs vermelhos
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 17: Display LED de 1 dígito
Este projeto permite aprender a utilizar um Display Led de 7 segmentos de 1 dígito. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai começar a mostrar números de 1 a 9, em intervalos de um segundo.
Componentes necessários:
1 Display LED de 1 dígito
8 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 18: Display LED de 4 dígitos
Desta vez, vamos aprender a utilizar um Display Led de 7 segmentos de 4 dígito. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai começar a mostrar números de 1 a 4. Poderá alterar os números que aparecem no código de programação.
Componentes necessários:
1 Display LED de 4 dígito
8 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 19: Display Matriz de LED 8×8
Neste projeto, utilizaremos um Display Matriz de LED 8 x 8 para transmitir informação. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai começar a mostrar o número 0, como se estivesse a brilhar. Poderá alterar o número que é mostrado no código de programação.
Componentes necessários:
1 Display Matriz de LED 8×8
8 Resistências 220Ω
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 20: Display LCD 16 x 2
Com este exercício, vamos aprender a utilizar um Display LCD 16 x 2. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino, insira o código deste projeto (pode consultá-lo no separador Programação) e carregue-o. Assim que o upload estiver concluído, o Display vai mostrar os caracteres que foram definidos no programa. Pode utilizar o potenciómetro para ajustar o brilho do Display. Caso entenda, pode alterar a mensagem transmitida para outra, no código de programação.
Componentes necessários:
1 Display LCD 16 x 2
1 Potenciómetro
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Projeto 21: Controlo de servomotor
Neste último projeto, é a vez de aprendermos a utilizar um servomotor. Depois de conectar os componentes de acordo com o diagrama de conexão, ligue a placa controladora ao seu computador, abra o Arduino e insira o código deste projeto (pode consultá-lo no separador Programação). Antes de carregar o código, deve adicionar o ficheiro ‘Servo.h’ ao diretório de bibliotecas Arduino, caso contrário não conseguirá compilar o programa. Assim que o upload estiver concluído, verá o servomotor a rodar 90 graus, como programado. Poderá alterar a programação de acordo com as necessidades do seu projeto.
Componentes necessários:
1 Servomotor 9g
1 Breadboard
Cabos jumper
Cabo USB
Placa controladora Arduino MEGA 2560
Ver vídeo
Diagrama de conexão:
Para mais informações sobre estes projetos pode clicar aqui.
