Envio Grátis a partir de 90€
,

Kit avançado para Arduino Keyestudio

REF: KS0074


Este Kit avançado para Arduino reúne um conjunto componentes que, ao serem utilizados em conjunto, podem ser úteis para construir projetos Arduino muito interessantes. Inclui uma seleção de módulos e sensores, com diversas funcionalidades, de LEDs, de Resistências, de Displays LCD/LED e muito mais.

 

52,45 IVA INCL.

Kit Avançado para Arduino Keyestudio

Inclui:

Kit Avançado para Arduino

1 Breadboard 830
5 LED 10 mm Amarelo
5 LED 10 mm Azul
5 LED 10 mm Vermelho
5 Led RGB
3 Fotoresistências
8 Resistência 220Ω 1/4W
5 Resistência 1KΩ 1/4W
5 Resistência 10KΩ 1/4W
1 Display Led 7 Segmentos 1 dígito
1 Display Led 7 Segmentos 4 dígitos
1 Display LED Matriz 8×8
1 Shield Display LCD 16 x 2
1 Buzzer passivo 5V
1 Buzzer Ativo 5V
1 Sensor de chama
1 Sensor de temperatura LM35
2 Sensores de vibração (Tilt HDX)
1 IR Receiver
1 Comando controlo remoto por infravermelhos
1 Módulo driver motor stepper
1 Módulo Joystick
1 Módulo relé simples 5V
1 Módulo de aceleração de três eixos ADXL345
1 Módulo sensor movimento PIR
1 Módulo sensor de gás combustível (MQ-6)
1 Módulo sensor ultrassónico de movimento/distância SR04
1 Motor de Passo
1 Servomotor SG90 9g Tower Pro (180º)
1 Circuito integrado 74HC595N
1 Potenciómetros Trimmer 10K
4 Botões tipo Push Button
1 Suporte de 6 pilhas AA
30 Cabos Jumper
Pin Headers
Cabo USB
10 Cabos conectores Dupont

REF: KS0074 Categorias: , Etiquetas: , ,
Marca

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 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 4 “Luzes de semáforo”

//////////////////////////////////////////////////////////
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 5 “Efeito de perseguição de LED”

//////////////////////////////////////////////////////////
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 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 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 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);
}
}
void updateLEDs(int value)
{
digitalWrite(latch, LOW);//
shiftOut(data, clock, MSBFIRST, ~value);// serial data “output”, high level first
digitalWrite(latch, HIGH);// latch
}
//////////////////////////////////////////////////////////</br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br >

 

Projeto 17 “Controlo de LEDs com 74HC595N”

//////////////////////////////////////////////////////////
// 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”

A
//////////////////////////////////////////////////////////
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);
}

//////////////////////////////////////////////////////////





B
//////////////////////////////////////////////////////////
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);
   
}
//////////////////////////////////////////////////////////</br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br ></br >

 

Projeto 21 “Controlo de servomotor”

//////////////////////////////////////////////////////////
int servopin=9;// select digital pin 9 for servomotor signal line
int myangle;// initialize angle variable
int pulsewidth;// initialize width variable
int val;
void servopulse(int servopin,int myangle)// define a servo pulse function
{
pulsewidth=(myangle*11)+500;// convert angle to 500-2480 pulse width
digitalWrite(servopin,HIGH);// set the level of servo pin as “high”
delayMicroseconds(pulsewidth);// delay microsecond of pulse width
digitalWrite(servopin,LOW);// set the level of servo pin as “low”
delay(20-pulsewidth/1000);
}
void setup()
{
pinMode(servopin,OUTPUT);// set servo pin as “output”
Serial.begin(9600);// connect to serial port, set baud rate at “9600”
Serial.println("servo=o_seral_simple ready" ) ;
}
void loop()// convert number 0 to 9 to corresponding 0-180 degree angle, LED blinks corresponding number of time
{
val=Serial.read();// read serial port value
if(val>='0'&&val<='9')
{
val=val-'0';// convert characteristic quantity to numerical variable
val=val*(180/9);// convert number to angle
Serial.print("moving servo to ");
Serial.print(val,DEC);
Serial.println();
for(int i=0;i<=50;i++) // giving the servo time to rotate to commanded position
{
servopulse(servopin,val);// use the pulse function
}
}
}
//////////////////////////////////////////////////////////

 

Projeto 22 “Motor de passo”

//////////////////////////////////////////////////////////
#include    
#define STEPS 100  
Stepper stepper(STEPS, 8, 9, 10, 11);  
int previous = 0;  
void setup()
{
  stepper.setSpeed(90);
 }   
 void loop()
 {    
   int val = analogRead(0);      
   stepper.step(val - previous);     
   previous = val;
 }

//////////////////////////////////////////////////////////

 

Projeto 23 “Sensor de movimento PIR”

//////////////////////////////////////////////////////////
byte sensorPin = 3;
byte indicator = 13;
void setup()
{
  pinMode(sensorPin,INPUT);
  pinMode(indicator,OUTPUT);
  Serial.begin(9600);
}

void loop()
{
  byte state = digitalRead(sensorPin);
  digitalWrite(indicator,state);
  if(state == 1)Serial.println("Somebody is in this area!");
  else if(state == 0)Serial.println("No one!");
  delay(500);
}
//////////////////////////////////////////////////////////

 

Projeto 24 “Medir o gás”

//////////////////////////////////////////////////////////
void setup()
{
  Serial.begin(9600); //Set serial baud rate to 9600 bps
}
void loop()
{int val;
val=analogRead(0);//Read Gas value from analog 0
Serial.println(val,DEC);//Print the value to serial port
delay(100);
}
//////////////////////////////////////////////////////////

 

Projeto 25 “Medir a aceleração”

//////////////////////////////////////////////////////////
/*
The circuit:
 VCC: 5V
 GND: ground
 SCL: UNO SLC
 SDA: UNO SDA
 
 This example code is in the public domain.

*/
#include 
// Registers for ADXL345
#define ADXL345_ADDRESS (0xA6 >> 1)  // address for device is 8 bit but shift to the
                                     // right by 1 bit to make it 7 bit because the
                                     // wire library only takes in 7 bit addresses
#define ADXL345_REGISTER_XLSB (0x32)

int accelerometer_data[3];
// void because this only tells the cip to send data to its output register
// writes data to the slave's buffer
void i2c_write(int address, byte reg, byte data) {
  // Send output register address
  Wire.beginTransmission(address);
  // Connect to device
  Wire.write(reg);
  // Send data
  Wire.write(data); //low byte
  Wire.endTransmission();
}

// void because using pointers
// microcontroller reads data from the sensor's input register
void i2c_read(int address, byte reg, int count, byte* data) {
  // Used to read the number of data received
  int i = 0;
  // Send input register address
  Wire.beginTransmission(address);
  // Connect to device
  Wire.write(reg);
  Wire.endTransmission();

  // Connect to device
  Wire.beginTransmission(address);
  // Request data from slave
  // Count stands for number of bytes to request
  Wire.requestFrom(address, count);
  while(Wire.available()) // slave may send less than requested
  {
    char c = Wire.read(); // receive a byte as character
    data[i] = c;
    i++;
  }
  Wire.endTransmission();
}

void init_adxl345() {
  byte data = 0;

  i2c_write(ADXL345_ADDRESS, 0x31, 0x0B);   // 13-bit mode  +_ 16g
  i2c_write(ADXL345_ADDRESS, 0x2D, 0x08);   // Power register

  i2c_write(ADXL345_ADDRESS, 0x1E, 0x00);   // x
  i2c_write(ADXL345_ADDRESS, 0x1F, 0x00);   // Y
  i2c_write(ADXL345_ADDRESS, 0x20, 0x05);   // Z
 
  // Check to see if it worked!
  i2c_read(ADXL345_ADDRESS, 0X00, 1, &data);
  if(data==0xE5)
    Serial.println("it work Success");
  else
    Serial.println("it work Fail");
}

void read_adxl345() {
  byte bytes[6];
  memset(bytes,0,6);

  // Read 6 bytes from the ADXL345
  i2c_read(ADXL345_ADDRESS, ADXL345_REGISTER_XLSB, 6, bytes);
  // Unpack data
  for (int i=0;i<3;++i) {
    accelerometer_data[i] = (int)bytes[2*i] + (((int)bytes[2*i + 1]) << 8);
  }
}
// initialise and start everything
void setup() {
  Wire.begin();
  Serial.begin(9600);
  for(int i=0; i<3; ++i) {
    accelerometer_data[i]  = 0;
  }
  init_adxl345();
}
void loop() {
  read_adxl345();
  Serial.print("ACCEL: ");
  Serial.print(float(accelerometer_data[0])*3.9/1000);//3.9mg/LSB scale factor in 13-bit mode
  Serial.print("\t");
  Serial.print(float(accelerometer_data[1])*3.9/1000);
  Serial.print("\t");
  Serial.print(float(accelerometer_data[2])*3.9/1000);
  Serial.print("\n");
  delay(100);
}
 //////////////////////////////////////////////////////////

 

Projeto 26 “Medir a distância”

//////////////////////////////////////////////////////////

#define echoPin 7 // Echo Pin
#define trigPin 8 // Trigger Pin
#define LEDPin 13 // Onboard LED

int maximumRange = 200; // Maximum range needed
int minimumRange = 0; // Minimum range needed
long duration, distance; // Duration used to calculate distance

void setup() {
 Serial.begin (9600);
 pinMode(trigPin, OUTPUT);
 pinMode(echoPin, INPUT);
 pinMode(LEDPin, OUTPUT); // Use LED indicator (if required)
}

void loop() {
/* The following trigPin/echoPin cycle is used to determine the
 distance of the nearest object by bouncing soundwaves off of it. */ 
 digitalWrite(trigPin, LOW); 
 delayMicroseconds(2); 

 digitalWrite(trigPin, HIGH);
 delayMicroseconds(10); 
 
 digitalWrite(trigPin, LOW);
 duration = pulseIn(echoPin, HIGH);
 
 //Calculate the distance (in cm) based on the speed of sound.
 distance = duration/58.2;
 
 if (distance >= maximumRange || distance <= minimumRange){
 /* Send a negative number to computer and Turn LED ON 
 to indicate "out of range" */
 Serial.println("-1");
 digitalWrite(LEDPin, HIGH); 
 }
 else {
 /* Send the distance to the computer using Serial protocol, and
 turn LED OFF to indicate successful reading. */
 Serial.println(distance);
 digitalWrite(LEDPin, LOW); 
 }
 
 //Delay 50ms before next reading.
 delay(50);
}
//////////////////////////////////////////////////////////

Projetos

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-se 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. 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.  epois 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:


Projeto 22: Motor de passo

Neste projeto controlamos a velocidade de um motor de passo. 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. Tenha atenção para ligar o motor de passo aos pinos 8, 9, 10 e 11 da placa controladora. Assim que o upload estiver concluído, poderá ver o motor a rodar numa velocidade de 90 passos por minuto.

Componentes necessários:

1 Motor de passo
1 Driver Motor de passo
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:


Projeto 23: Sensor de movimento PIR

Desta vez vamos aprender a detetar a presença de movimento humano ou animal, utilizando um sensor de movimento PIR. 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 no seu Arduino. Quando não houver movimento, aparecerá na janela a mensagem “No one”, ou seja, “Ninguém”. Quando for detetado movimento, a mensagem será “Somebody is in the area”, ou seja, “Alguém está por perto”.

Componentes necessários:

Sensor de movimento PIR
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:


Projeto 24: Medir o gás

Neste projeto, é possível verificar os níveis do gás do meio ambiente com um sensor de gás MQ-2. Depois de conectar os componentes de acordo com o diagrama de conexão (sensor de gás vai ligar aos 5V, GND e A0 da placa), 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 no seu Arduino. Poderá ver que quando liberta gás perto do sensor (por exemplo acendendo um isqueiro), os valores na janela serial monitor aumentam.

Componentes necessários:

Sensor de Gás analógico
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:


Projeto 25: Medir a aceleração

Este projeto permite aprender como medir a aceleração através de um Sensor de aceleração de três eixos ADXL345. 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 no seu Arduino para poder ver os valores de aceleração. Ao mover o sensor, poderá verificar que os valores se alteram.

Componentes necessários:

Sensor de aceleração de três eixos ADXL345
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:


Projeto 26: Medir a distância

Neste exercício, utilizaremos um sensor ultrassónico HC-SR04 para medir a distância. 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 no seu Arduino. Poderá fazer a experiência de colocar um objeto em várias posições para ver os valores da distância a mudarem no computador.

Componentes necessários:

Sensor ultrassónico HC-SR04
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:


Projeto 27: Controlo de direção com Joystick

Com esta experiência, vamos aprender a controlar três direções com um joystick. 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 programa carregar, abra uma janela serial monitor. Sem mover o módulo, mova o eixo para a esquerda, para a direita e para baixo e verá que os valores x, y e z (respetivamente) se vão alterar.

Componentes necessários:

Módulo Joystick
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:


Projeto 28: Controlo de LED com Relé

Para terminar o conjunto de projetos deste kit avançado, vamos aprender a controlar um LED através de um Relé. 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 liga e desliga de acordo com o estado do Relé.

Componentes necessários:

Módulo Relé 5V
LED vermelho
Cabos jumper MF
Cabo USB
Placa controladora Arduino UNO R3

Ver vídeo

Diagrama de conexão:

Baseada em 0 avaliações

0.0 pontuação
0
0
0
0
0

Seja o primeiro a avaliar “Kit avançado para Arduino Keyestudio”

Não há comentários ainda.

Também pode gostar…