Program Arduino
Project #12: Robotics – Unmanned Vehicles 1b – Mk06
——
——
——
——
——
XBee
Digi XBee is the brand name of a family of form factor compatible radio modules from Digi International. The first XBee radios were introduced under the MaxStream brand in 2005 and were based on the IEEE 802.15.4-2003 standard designed for point-to-point and star communications at over-the-air baud rates of 250 kbit/s.
Two models were initially introduced, a lower cost 1 mW XBee and the higher power 100 mW XBee-PRO. Since the initial introduction, a number of new XBee radios have been introduced and an ecosystem of wireless modules, gateways, adapters and software has evolved.
The XBee radios can all be used with the minimum number of connections — power (3.3 V), ground, data in and data out (UART), with other recommended lines being Reset and Sleep. Additionally, most XBee families have some other flow control, input/output (I/O), analog-to-digital converter (A/D) and indicator lines built in.
DL2001Mk02
1 x Arduino Fio
1 x Arduino UNO – R3
1 x ProtoScrewShield
1 x Adafruit RGB LCD Shield 16×2 Character Display
2 x XBee S1
1 x SparkFun XBee Explorer Regulated
1 x Lithium Ion Battery – 2.5Ah
1 x LED Red
1 x LED Green
1 x LED Bi-Colour
1 x LED Yellow
4 x Jumper Wires 3″ M/M
10 x Jumper Wires 6″ M/M
1 x Half-Size Breadboard
1 x SparkFun XBee Explorer USB
1 x DIGI XCTU Software
1 x SparkFun FTDI Basic Breakout – 3.3V
1 x SparkFun Cerberus USB Cable
Arduino UNO
TX0 – Digital 1
RX0 – Digital 0
VIN – +5V
GND – GND
XBee S1: Transmitter
CH Channel: C
PAN Id: 3333
SH Serial Number: 13A200
SL Serial Number: 40717A1F
CE Coordinator: Coordinator
BD: 9600
DL2001Mk02p.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - Unmanned Vehicles 1b - Mk06 // 01-02 // DL2001Mk01p.ino 12-06 // Arduino UNO - R3 // ProtoScrewShield // Adafruit RGB LCD Shield 16×2 Character Display // EEPROM with Unique ID // Transmitter // XBee S1 // Include the library code: // EEPROM library to read and write EEPROM with unique ID for unit #include <EEPROM.h> // Adafruit RGB LCD Shield #include <Adafruit_RGBLCDShield.h> // Adafruit RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); // These #defines make it easy to set the backlight color #define OFF 0x0 #define RED 0x1 #define YELLOW 0x3 #define GREEN 0x2 #define TEAL 0x6 #define BLUE 0x4 #define VIOLET 0x5 #define WHITE 0x7 // Momentary Button int yy = 0; uint8_t momentaryButton = 0; // Communication unsigned long dTime = 1000; // The current address in the EEPROM (i.e. which byte we're going to read to next) // Version String sver = "12-2.p"; // Unit ID Information String uid = ""; void loop() { // Clear RGBLCDShield.clear(); // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Robotics"); // Robotics // Momentary Button momentaryButton = RGBLCDShield.readButtons(); switch ( yy ) { case 1: // LED Green isSwitch1(); break; case 2: // LED Bipolar (Green) isSwitch2(); break; case 3: // Right isSwitch3(); break; case 4: // Left isSwitch4(); break; case 5: // LED Red isSwitch5(); break; default: // LED Red yy = 5; RGBLCDShield.setBacklight(RED); isSwitch5(); } if ( momentaryButton ) { if ( momentaryButton & BUTTON_UP ) { yy = 1; // LED Green RGBLCDShield.setBacklight(GREEN); } if ( momentaryButton & BUTTON_DOWN ) { yy = 2; // LED Bipolar A RGBLCDShield.setBacklight(VIOLET); } if ( momentaryButton & BUTTON_LEFT ) { yy = 3; // LED Bipolar B RGBLCDShield.setBacklight(TEAL); } if ( momentaryButton & BUTTON_RIGHT ) { yy = 4; // LED Bipolar A B RGBLCDShield.setBacklight(YELLOW); } if ( momentaryButton & BUTTON_SELECT ) { yy = 5; // LED Red RGBLCDShield.setBacklight(RED); } } // Process Message isProcessMessage(); delay( dTime ); }
getEEPROM.ino
// EEPROM // isUID void isUID() { // Is Unit ID uid = ""; for (int x = 0; x < 5; x++) { uid = uid + char(EEPROM.read(x)); } }
getProcessMessage.ino
// ProcessMessage // isProcessMessage void isProcessMessage() { //int incb = 0; String msg = ""; /// Loop through serial buffer one byte at a time until you reach * which will be end of message //while ( Serial.available() ) // { // Print => XBEE + Unit ID + Version + * msg = "XBEE|" + uid + "|" + sver + "|" + yy + "|*"; Serial.println( msg ); // } }
getSwitch.ino
// Switch // Switch 1 void isSwitch1(){ yy = 1; isSwitchLEDStop(); // LED // turn LED on: RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Green"); } // Switch 2 void isSwitch2(){ yy = 2; isSwitchLEDStop(); // LED // turn LED on: RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Bi-Colour A"); } // Switch 3 void isSwitch3(){ yy = 3; isSwitchLEDStop(); // LED // turn LED on: RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Bi-Colour B"); } // Switch 4 void isSwitch4(){ yy = 4; isSwitchLEDStop(); // LED // turn LED on: RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Bi-Colour A B"); } // Switch 5 void isSwitch5(){ yy = 5; RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Stop"); //delay( 250 ); isSwitchLEDStop(); // LED // turn LED on: //digitalWrite(iLEDRed, HIGH); } void isSwitchLEDStop(){ //digitalWrite(iLEDRed, LOW); //digitalWrite(iLEDGreen, LOW); //digitalWrite(iLEDB1, LOW); //digitalWrite(iLEDB2, LOW); //digitalWrite(iLEDYellow, LOW); }
setup.ino
// Setup void setup() { //Open serial port at 9600 baud Serial.begin( 9600 ); // Pause delay(5); // EEPROM Unit ID isUID(); // Pause delay(5); // Adafruit RGB LCD Shield // Set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Robotics"); // Robotics // Serial Serial.println( "Don Luc Electronics"); Serial.println( "Robotics"); delay(5000); // Clear RGBLCDShield.clear(); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Version: "); // Version RGBLCDShield.print( sver ); // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("UID: "); // Unit ID Information RGBLCDShield.print( uid ); // Serial Serial.print( "Software Version Information: "); Serial.println( sver ); Serial.print( "Unit ID Information: "); Serial.println( uid ); delay(5000); // Clear RGBLCDShield.clear(); }
Arduino Fio
LER – Digital 13
LEG – Digital 12
LEA – Digital 11
LEB – Digital 10
LEY – Digital 9
TX0 – Digital 1
RX0 – Digital 0
VIN – +3.3V
GND – GND
XBee S1: Receiver
CH Channel: C
PAN Id: 3333
SH Serial Number: 13A200
SL Serial Number: 4076E2C5
CE Coordinator: End Device
BD: 9600
DL2001Mk02Rp.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - Unmanned Vehicles 1b - Mk06 // 01-02 // DL2001Mk02Rp.ino 12-06 // Arduino Fio // SparkFun FTDI Basic Breakout - 3.3V // EEPROM with Unique ID // LED Red // LED Green // LED Bi-Colour // LED Yellow // Lithium Ion Battery - 2.5Ah // Receiver // XBee S1 // Include the library code: // EEPROM library to read and write EEPROM with unique ID for unit #include <EEPROM.h> // LED Red int iLEDRed = 13; // LED Green int iLEDGreen = 12; // LED Bi-Colour int iLEDBiCoA = 11; int iLEDBiCoB = 10; // LED Yellow int iLEDYellow = 9; // Momentary Button int yy = ""; // Software Version Information String sver = "12-02"; // Unit ID information String uid = "DR001"; void loop() { // Check for serial messages if ( Serial.available() ) { isProcessMessage(); } // Switch isSwitch(); }
getEEPROM.ino
// EEPROM // isUID void isUID() { // Is Unit ID uid = ""; for (int x = 0; x < 5; x++) { uid = uid + char(EEPROM.read(x)); } }
getProcessMessage.ino
// ProcessMessage // isProcessMessage void isProcessMessage() { int incb = 0; String msg = ""; String zzz = ""; // Loop through serial buffer one byte at a time until you reach * which will be end of message while ( Serial.available() ) { // Read the incoming byte: incb = Serial.read(); // Add character to string msg = msg + char(incb); // Check if receive character is the end of message * if ( incb == 42 ) { Serial.println(msg); zzz = msg.charAt( 18 ); Serial.println(zzz); yy = zzz.toInt(); Serial.println( yy ); } } }
getSwitch.ino
// Switch // isSwitch void isSwitch(){ switch ( yy ) { case 1: // LED Green sLEDStop(); digitalWrite(iLEDGreen, HIGH); delay( 1000 ); break; case 2: // LED Bi-Colour A sLEDStop(); digitalWrite(iLEDBiCoA, HIGH); delay( 1000 ); break; case 3: // LED Bi-Colour B sLEDStop(); digitalWrite(iLEDBiCoB, HIGH); delay( 1000 ); break; case 4: // LED Bi-Colour A B sLEDStop(); digitalWrite(iLEDBiCoA, HIGH); digitalWrite(iLEDBiCoB, HIGH); delay( 1000 ); break; case 5: // LED Red sLEDStop(); digitalWrite(iLEDRed, HIGH); delay( 1000 ); break; default: // LED Red sLEDStop(); digitalWrite(iLEDRed, HIGH); delay( 1000 ); } } // LED Stop void sLEDStop(){ digitalWrite(iLEDRed, LOW); digitalWrite(iLEDGreen, LOW); digitalWrite(iLEDBiCoA, LOW); digitalWrite(iLEDBiCoB, LOW); }
setup.ino
// Setup void setup() { // Open the serial port at 9600 bps: Serial.begin( 9600 ); // Pause delay(5); // EEPROM Unit ID isUID(); // Pause delay(5); // Serial Serial.print( "Software Version Information: "); Serial.println( sver ); Serial.print( "Unit ID Information: "); Serial.println( uid ); delay(5000); // LED => OUTPUT pinMode(iLEDRed, OUTPUT); pinMode(iLEDGreen, OUTPUT); pinMode(iLEDBiCoA, OUTPUT); pinMode(iLEDBiCoB, OUTPUT); pinMode(iLEDYellow, OUTPUT); // LED Yellow digitalWrite(iLEDYellow, HIGH); }
Follow Us
J. Luc Paquin – Curriculum Vitae
https://www.donluc.com/DLHackster/LucPaquinCVEngMk2020a.pdf
Web: https://www.donluc.com/
Web: http://www.jlpconsultants.com/
Web: https://www.donluc.com/DLHackster/
Web: https://www.hackster.io/neosteam-labs
Web: http://neosteamlabs.com/
YouTube: https://www.youtube.com/channel/UC5eRjrGn1CqkkGfZy0jxEdA
Facebook: https://www.facebook.com/neosteam.labs.9/
Instagram: https://www.instagram.com/neosteamlabs/
Pinterest: https://www.pinterest.com/NeoSteamLabs/
Twitter: https://twitter.com/labs_steam
Etsy: https://www.etsy.com/shop/NeoSteamLabs
Don Luc
Project #12: Robotics – Unmanned Vehicles 1a – Mk05
——
——
——
——
——
——
——
EEPROM
EEPROM stands for electrically erasable programmable read-only memory and is a type of non-volatile memory used in computers, integrated in microcontrollers for smart cards and remote keyless systems, and other electronic devices to store relatively small amounts of data but allowing individual bytes to be erased and reprogrammed.
Transmitter
In electronics and telecommunications a transmitter or radio transmitter is an electronic device which produces radio waves with an antenna. The transmitter itself generates a radio frequency alternating current, which is applied to the antenna. When excited by this alternating current, the antenna radiates radio waves.
Receiver
A modern communications receiver, used in two-way radio communication stations to talk with remote locations by shortwave radio.
In radio communications, a radio receiver, also known as a receiver, wireless or simply radio is an electronic device that receives radio waves and converts the information carried by them to a usable form. It is used with an antenna. The antenna intercepts radio waves (electromagnetic waves) and converts them to tiny alternating currents which are applied to the receiver, and the receiver extracts the desired information.
DL2001Mk01
1 x Arduino Fio
1 x Arduino UNO
1 x SparkFun FTDI Basic Breakout – 3.3V
1 x SparkFun Cerberus USB Cable
Arduino UNO
VIN – +5V
GND – GND
Arduino Fio
VIN – +3.3V
GND – GND
Transmitter => DT001
DL2001Mk01p.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - Unmanned Vehicles 1a - Mk05 // 01-01 // DL2001Mk01p.ino 12-05 // Arduino UNO // Screw Shield // Adafruit RGB LCD Shield // EEPROM with Unique ID // Transmitter // Include the library code: #include <Adafruit_RGBLCDShield.h> // EEPROM library to read and write EEPROM with unique ID for unit #include <EEPROM.h> // Adafruit RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); // These #defines make it easy to set the backlight color #define GREEN 0x2 // Momentary Button int yy = 0; uint8_t momentaryButton = 0; // Software Version Information String sver = "12-05"; // Unit ID Information String uid = "DT001"; void loop() { // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron momentaryButton = RGBLCDShield.readButtons(); if ( momentaryButton ) { if ( momentaryButton & BUTTON_UP ) { isEEPROMw(); yy = 1; } if ( momentaryButton & BUTTON_DOWN ) { isUID(); yy = 2; } if ( momentaryButton & BUTTON_LEFT ) { UIDr(); yy =3; } if ( momentaryButton & BUTTON_RIGHT ) { isEEPROMc(); yy = 4; } } delay(1000); // Clear RGBLCDShield.clear(); }
getEEPROM.ino
// getEEPROM // Write and Read EEPROM with Unique ID for Unit // Write EEPROM with Unique ID for Unit void isEEPROMw() { // set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( "Write" ); // EEPROM int incb = 0; int v = 0; String msg = ""; String emp = ""; // Set Unit ID // The message starts with sid then is followed by 5 characters // First clear a string buffer emp = ""; // Loop through the 5 ID characters and write their ASCII (byte) value to the EEPROM for (int x = 0; x < 5; x++) { //Get ASCII value of character v = int(uid.charAt(x)); // + 5)); //Add the actual character to the buffer so we can send it back to the PC emp = emp + uid.charAt(x + 5); //Write the value to the EEPROM EEPROM.write(x, v); } delay( 5000 ); } // Read EEPROM with Unique ID for Unit void isUID() { // Unit ID String ruid = ""; for (int x = 0; x < 5; x++) { ruid = ruid + char(EEPROM.read(x)); } // set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( ruid ); delay( 5000 ); } // Read uid void UIDr() { // set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( uid ); delay( 5000 ); } // Clear EEPROM void isEEPROMc() { // Clear EEPROM for (int i = 0 ; i < EEPROM.length() ; i++) { EEPROM.write(i, 0); } // set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( "Clear EEPROM" ); delay( 5000 ); }
setup.ino
// Setup void setup() { // Adafruit RGB LCD Shield // Set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Unique ID"); // Unique ID delay(5000); // Clear RGBLCDShield.clear(); }
Receiver => DR001
DL2001Mk01Rp.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - Unmanned Vehicles 1a - Mk05 // 01-01 // DL2001Mk01Rp.ino 12-05 // Arduino Fio // SparkFun FTDI Basic Breakout - 3.3V // EEPROM with Unique ID // Receiver // Include the library code: // EEPROM library to read and write EEPROM with unique ID for unit #include <EEPROM.h> // Software Version Information String sver = "12-05"; // Unit ID information String uid = "DR001"; void loop() { // Write EEPROM with Unique ID for Unit int incb = 0; int v = 0; String emp = ""; String ruid = ""; // Set Unit ID // The message starts with uid then is followed by 5 characters // First clear a string buffer emp = ""; // Loop through the 5 ID characters and write their ASCII (byte) value to the EEPROM for (int y = 0; y < 5; y++) { // Get ASCII value of character v = int(uid.charAt(y)); // + 5)); // Add the actual character to the buffer emp = emp + uid.charAt(y + 5); // Write the value to the EEPROM EEPROM.write(y, v); } // Write EEPROM with Unique ID for Unit Serial.println( "Write ID Information"); // Read ID Information // Unit ID for (int y = 0; y < 5; y++) { ruid = ruid + char(EEPROM.read(y)); } // Read ID Information Serial.print( "Read ID Information: "); Serial.println( ruid ); Serial.println( "Ok!" ); ruid = ""; delay( 5000 ); }
setup.ino
// Setup void setup() { // Open the serial port at 9600 bps: Serial.begin(9600); // Serial Serial.print( "Software Version Information: "); Serial.println( sver ); Serial.print( "Unit ID Information: "); Serial.println( uid ); delay(5000); }
Follow Us
J. Luc Paquin – Curriculum Vitae
https://www.donluc.com/DLHackster/LucPaquinCVEngMk2020a.pdf
Web: https://www.donluc.com/
Web: http://www.jlpconsultants.com/
Web: https://www.donluc.com/DLHackster/
Web: https://www.hackster.io/neosteam-labs
Web: http://neosteamlabs.com/
YouTube: https://www.youtube.com/channel/UC5eRjrGn1CqkkGfZy0jxEdA
Facebook: https://www.facebook.com/neosteam.labs.9/
Instagram: https://www.instagram.com/neosteamlabs/
Pinterest: https://www.pinterest.com/NeoSteamLabs/
Twitter: https://twitter.com/labs_steam
Etsy: https://www.etsy.com/shop/NeoSteamLabs
Don Luc
Project #12: Robotics – 5-Way Switch – Mk04
——
——
——
——
——
——
——
SparkFun 5-Way Tactile Switch Breakout
This 5-way tactile switch (up, down, left, right, and center click) allows for joystick-like control in a very small package.
DL1912Mk03
1 x Adafruit RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
2 x EasyDriver – Stepper Motor Driver
1 x Small Stepper Motor
1 x Pololu Mounting
1 x Symbol Stepper Motor
2 x RC Servo Motor
2 x Potentiometer 1M Ohm
2 x Knob
2 x LED Red
1 x Rocker Switches
1 x Laser Red
1 x SparkFun 5-Way Tactile Switch Breakout
1 x LED Green
1 x LED Bi-Colour
1 x LED Yellow
17 x Jumper Wires 3″ M/M
31 x Jumper Wires 6″ M/M
4 x Half-Size Breadboard
Arduino UNO
SP1 – Digital 3
DI1 – Digital 2
SP2 – Digital 5
DI2 – Digital 4
SV1 – Digital 6
PO1 – Analog A0
SV2 – Digital 7
PO2 – Analog A1
VIN – +5V
GND – GND
DL1912Mk03.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - 5-Way Switch - Mk04 // 12-03 // DL1912Mk02p.ino 12-04 // Arduino UNO // Screw Shield // Adafruit RGB LCD Shield // 1 x Small Stepper Motor // 1 x Symbol Stepper Motor // 2 x EasyDriver // 2 x RC Servo Motor // 2 x Potentiometer // 2 x LED Red // 1 x Rocker Switches // 1 x Laser Red // 1 x SparkFun 5-Way Tactile Switch Breakout // 1 x LED Green // 1 x LED Bi-Colour // 1 x LED Yellow // include the library code: #include <Adafruit_RGBLCDShield.h> #include <Servo.h> // Adafruit RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); // These #defines make it easy to set the backlight color #define OFF 0x0 #define RED 0x1 #define YELLOW 0x3 #define GREEN 0x2 #define TEAL 0x6 #define BLUE 0x4 #define VIOLET 0x5 #define WHITE 0x7 // Momentary Button int yy = 0; uint8_t momentaryButton = 0; // 2 x EasyDriver int dirPinR = 2; // EasyDriver Right int stepPinR = 3; // stepPin Right int dirPinL = 4; // EasyDriver Left int stepPinL = 5; // stepPin Left int i = 0; // 2 x RC Servo Motor // 2 x Potentiometer Servo isRCServo1; // Create servo object to control a RCServo1 int servo1 = 6; // Servo 1 int iPot1 = A0; // Analog Potentiometer 1 int iVal1; // Variable - Analog Potentiometer 1 Servo isRCServo2; // Create servo object to control a RCServo2 int servo2 = 7; // Servo 2 int iPot2 = A1; // Analog Potentiometer 2 int iVal2; // Variable - Analog Potentiometer 2 void loop() { // Clear RGBLCDShield.clear(); // Momentary Button momentaryButton = RGBLCDShield.readButtons(); switch ( yy ) { case 1: // Up isSwitch1(); break; case 2: // Down isSwitch2(); break; case 3: // Right isSwitch3(); break; case 4: // Left isSwitch4(); break; case 5: // Stop isSwitch5(); break; default: // Stop yy = 5; RGBLCDShield.setBacklight(RED); isSwitch5(); } if ( momentaryButton ) { if ( momentaryButton & BUTTON_UP ) { yy = 1; // Up RGBLCDShield.setBacklight(GREEN); } if ( momentaryButton & BUTTON_DOWN ) { yy = 2; // Down RGBLCDShield.setBacklight(VIOLET); } if ( momentaryButton & BUTTON_LEFT ) { yy = 3; // Right RGBLCDShield.setBacklight(TEAL); } if ( momentaryButton & BUTTON_RIGHT ) { yy = 4; // Left RGBLCDShield.setBacklight(YELLOW); } if ( momentaryButton & BUTTON_SELECT ) { yy = 5; // Stop RGBLCDShield.setBacklight(RED); } } }
getServo.ino
// Servo // isServoSetup void isServoSetup() { // 2 x RC Servo Motor isRCServo1.attach( servo1 ); isRCServo2.attach( servo2 ); } // isServo1 void isServo1() { // EasyDriver isStepperStop(); // Potentiometer RC Servo Motor 1 iVal1 = analogRead( iPot1 ); // Reads the value of the iPot1 (Value between 0 and 1023) iVal1 = map(iVal1, 0, 1023, 0, 180); // Scale it to use it with the isRCServo1 (Value between 0 and 180) isRCServo1.write( iVal1 ); // isRCServo1 sets the servo position according to the scaled value delay(15); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("RC Servo 1"); // RC Servo 1 // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( iVal1 ); // Reads the value iVal1 delay(500); } // isServo2 void isServo2() { // EasyDriver isStepperStop(); // Potentiometer RC Servo Motor 1 iVal2 = analogRead( iPot2 ); // Reads the value of the iPot2 (Value between 0 and 1023) iVal2 = map(iVal2, 0, 1023, 0, 180); // Scale it to use it with the isRCServo2 (Value between 0 and 180) isRCServo2.write( iVal2 ); // isRCServo2 sets the servo position according to the scaled value delay(15); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("RC Servo 2"); // RC Servo 2 // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( iVal2 ); // Reads the value iVal2 delay(500); }
getStepper.ino
// Stepper // isStepperSetup void isStepperSetup() { // 2 x EasyDriver pinMode(dirPinR, OUTPUT); pinMode(stepPinR, OUTPUT); pinMode(dirPinL, OUTPUT); pinMode(stepPinL, OUTPUT); } // isStepper1 void isStepper1(){ // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Small Stepper"); // Small Stepper delay(500); // EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); for (i = 0; i<300; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // isStepper2 void isStepper2(){ // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Symbol Stepper"); // Symbol Stepper delay(500); // EasyDriver digitalWrite(dirPinL, HIGH); // Set the direction. delay(100); for (i = 0; i<300; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // isStepperStop void isStepperStop() { // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the }
getSwitch.ino
// Switch // Switch 1 void isSwitch1(){ // Small Stepper yy = 1; // EasyDriver isStepper1(); } // Switch 2 void isSwitch2(){ // Symbol Stepper yy = 2; // EasyDriver isStepper2(); } // Switch 3 void isSwitch3(){ // RC Servo Motor 1 yy = 3; // Potentiometer RC Servo Motor 1 isServo1(); } // Switch 4 void isSwitch4(){ // RC Servo Motor 2 yy = 4; // Potentiometer RC Servo Motor 2 isServo2(); } // Switch 5 void isSwitch5(){ // Stop yy = 5; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Robotics"); // Robotics RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Stop"); delay( 500 ); // EasyDriver isStepperStop(); }
setup.ino
// Setup void setup() { // Adafruit RGB LCD Shield // Set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Robotics"); // EasyDriver delay(5000); // Clear RGBLCDShield.clear(); // 2 x EasyDriver isStepperSetup(); // 2 x RC Servo Motor isServoSetup(); }
Follow Us
Web: https://www.donluc.com/
Web: http://www.jlpconsultants.com/
Web: https://www.donluc.com/DLHackster/
Web: https://www.hackster.io/neosteam-labs
Web: http://neosteamlabs.com/
YouTube: https://www.youtube.com/channel/UC5eRjrGn1CqkkGfZy0jxEdA
Facebook: https://www.facebook.com/neosteam.labs.9/
Instagram: https://www.instagram.com/neosteamlabs/
Pinterest: https://www.pinterest.com/NeoSteamLabs/
Twitter: https://twitter.com/labs_steam
Etsy: https://www.etsy.com/shop/NeoSteamLabs
Don Luc
Project #12: Robotics – Laser Diode – Mk03
——
——
——
——
——
——
Laser Diode
A laser diode is a semiconductor device similar to a light-emitting diode in which a diode pumped directly with electrical current can create lasing conditions at the diode’s junction. Laser diodes can directly convert electrical energy into light. Due to the drop of the electron from a higher energy level to a lower one, radiation, in the form of an emitted photon is generated. This is spontaneous emission. Stimulated emission can be produced when the process is continued and further generate light with the same phase, coherence and wavelength.
The choice of the semiconductor material determines the wavelength of the emitted beam, which in today’s laser diodes range from infra-red to the UV spectrum. Laser diodes are the most common type of lasers produced, with a wide range of uses that include fiber optic communications, barcode readers, laser pointers, CD/DVD/Blu-ray disc reading/recording, laser printing, laser scanning and light beam illumination. With the use of a phosphor like that found on white LEDs, Laser diodes can be used for general illumination.
DL1912Mk02
1 x Adafruit RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
2 x EasyDriver – Stepper Motor Driver
1 x Small Stepper Motor
1 x Pololu Mounting
1 x Symbol Stepper Motor
2 x RC Servo Motor
2 x Potentiometer 1M Ohm
2 x Knob
1 x LED Red
1 x Rocker Switches
1 x Laser Red
5 x Jumper Wires 3″ M/M
29 x Jumper Wires 6″ M/M
3 x Half-Size Breadboard
Arduino UNO
SP1 – Digital 3
DI1 – Digital 2
SP2 – Digital 5
DI2 – Digital 4
SV1 – Digital 6
PO1 – Analog A0
SV2 – Digital 7
PO2 – Analog A1
VIN – +5V
GND – GND
DL1912Mk02.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - Laser Diode - Mk03 // 12-02 // DL1912Mk02p.ino 12-03 // Arduino UNO // Screw Shield // Adafruit RGB LCD Shield // 1 x Small Stepper Motor // 1 x Symbol Stepper Motor // 2 x EasyDriver // 2 x RC Servo Motor // 2 x Potentiometer // 1 x LED Red // 1 x Rocker Switches // 1 x Laser Red // include the library code: #include <Adafruit_RGBLCDShield.h> #include <Servo.h> // Adafruit RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); // These #defines make it easy to set the backlight color #define OFF 0x0 #define RED 0x1 #define YELLOW 0x3 #define GREEN 0x2 #define TEAL 0x6 #define BLUE 0x4 #define VIOLET 0x5 #define WHITE 0x7 // Momentary Button int yy = 0; uint8_t momentaryButton = 0; // 2 x EasyDriver int dirPinR = 2; // EasyDriver Right int stepPinR = 3; // stepPin Right int dirPinL = 4; // EasyDriver Left int stepPinL = 5; // stepPin Left int i = 0; // 2 x RC Servo Motor // 2 x Potentiometer Servo isRCServo1; // Create servo object to control a RCServo1 int servo1 = 6; // Servo 1 int iPot1 = A0; // Analog Potentiometer 1 int iVal1; // Variable - Analog Potentiometer 1 Servo isRCServo2; // Create servo object to control a RCServo2 int servo2 = 7; // Servo 2 int iPot2 = A1; // Analog Potentiometer 2 int iVal2; // Variable - Analog Potentiometer 2 void loop() { // Clear RGBLCDShield.clear(); // Momentary Button momentaryButton = RGBLCDShield.readButtons(); switch ( yy ) { case 1: // Up isSwitch1(); break; case 2: // Down isSwitch2(); break; case 3: // Right isSwitch3(); break; case 4: // Left isSwitch4(); break; case 5: // Stop isSwitch5(); break; default: // Stop yy = 5; RGBLCDShield.setBacklight(RED); isSwitch5(); } if ( momentaryButton ) { if ( momentaryButton & BUTTON_UP ) { yy = 1; // Up RGBLCDShield.setBacklight(GREEN); } if ( momentaryButton & BUTTON_DOWN ) { yy = 2; // Down RGBLCDShield.setBacklight(VIOLET); } if ( momentaryButton & BUTTON_LEFT ) { yy = 3; // Right RGBLCDShield.setBacklight(TEAL); } if ( momentaryButton & BUTTON_RIGHT ) { yy = 4; // Left RGBLCDShield.setBacklight(YELLOW); } if ( momentaryButton & BUTTON_SELECT ) { yy = 5; // Stop RGBLCDShield.setBacklight(RED); } } }
getServo.ino
// Servo // isServoSetup void isServoSetup() { // 2 x RC Servo Motor isRCServo1.attach( servo1 ); isRCServo2.attach( servo2 ); } // isServo1 void isServo1() { // EasyDriver isStepperStop(); // Potentiometer RC Servo Motor 1 iVal1 = analogRead( iPot1 ); // Reads the value of the iPot1 (Value between 0 and 1023) iVal1 = map(iVal1, 0, 1023, 0, 180); // Scale it to use it with the isRCServo1 (Value between 0 and 180) isRCServo1.write( iVal1 ); // isRCServo1 sets the servo position according to the scaled value delay(15); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("RC Servo 1"); // RC Servo 1 // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( iVal1 ); // Reads the value iVal1 delay(500); } // isServo2 void isServo2() { // EasyDriver isStepperStop(); // Potentiometer RC Servo Motor 1 iVal2 = analogRead( iPot2 ); // Reads the value of the iPot2 (Value between 0 and 1023) iVal2 = map(iVal2, 0, 1023, 0, 180); // Scale it to use it with the isRCServo2 (Value between 0 and 180) isRCServo2.write( iVal2 ); // isRCServo2 sets the servo position according to the scaled value delay(15); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("RC Servo 2"); // RC Servo 2 // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( iVal2 ); // Reads the value iVal2 delay(500); }
getStepper.ino
// Stepper // isStepperSetup void isStepperSetup() { // 2 x EasyDriver pinMode(dirPinR, OUTPUT); pinMode(stepPinR, OUTPUT); pinMode(dirPinL, OUTPUT); pinMode(stepPinL, OUTPUT); } // isStepper1 void isStepper1(){ // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Small Stepper"); // Small Stepper delay(500); // EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); for (i = 0; i<300; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // isStepper2 void isStepper2(){ // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Symbol Stepper"); // Symbol Stepper delay(500); // EasyDriver digitalWrite(dirPinL, HIGH); // Set the direction. delay(100); for (i = 0; i<300; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // isStepperStop void isStepperStop() { // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the }
getSwitch.ino
// Switch // Switch 1 void isSwitch1(){ // Small Stepper yy = 1; // EasyDriver isStepper1(); } // Switch 2 void isSwitch2(){ // Symbol Stepper yy = 2; // EasyDriver isStepper2(); } // Switch 3 void isSwitch3(){ // RC Servo Motor 1 yy = 3; // Potentiometer RC Servo Motor 1 isServo1(); } // Switch 4 void isSwitch4(){ // RC Servo Motor 2 yy = 4; // Potentiometer RC Servo Motor 2 isServo2(); } // Switch 5 void isSwitch5(){ // Stop yy = 5; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Robotics"); // Robotics RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Stop"); delay( 500 ); // EasyDriver isStepperStop(); }
setup.ino
// Setup void setup() { // Adafruit RGB LCD Shield // Set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Robotics"); // EasyDriver delay(5000); // Clear RGBLCDShield.clear(); // 2 x EasyDriver isStepperSetup(); // 2 x RC Servo Motor isServoSetup(); }
Follow Us
Web: https://www.donluc.com/
Web: http://neosteamlabs.com/
Web: http://www.jlpconsultants.com/
YouTube: https://www.youtube.com/channel/UC5eRjrGn1CqkkGfZy0jxEdA
Facebook: https://www.facebook.com/neosteam.labs.9/
Instagram: https://www.instagram.com/neosteamlabs/
Pinterest: https://www.pinterest.com/NeoSteamLabs/
Twitter: https://twitter.com/labs_steam
Etsy: https://www.etsy.com/shop/NeoSteamLabs
Don Luc
Project #12: Robotics – RC Servo Motor – Mk02
——
——
——
——
——
——
——
——
——
Servo (Radio Control)
Servos (also RC servos) are small, cheap, mass-produced servomotors or other actuators used for radio control and small-scale robotics.
Radio control servos are connected through a standard three-wire connection: two wires for a DC power supply and one for control, carrying a pulse-width modulation (PWM) signal. Each servo has a separate connection and PWM signal from the radio control receiver. This signal is easily generated by simple electronics, or by microcontrollers such as the Arduino. This, together with their low-cost, has led to their wide adoption for robotics and physical computing.
DL1912Mk01
1 x Adafruit RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
2 x EasyDriver – Stepper Motor Driver
2 x Small Stepper Motor
2 x Pololu Mounting
2 x RC Servo Motor
2 x Potentiometer 1M Ohm
2 x Knob
4 x Jumper Wires 3″ M/M
22 x Jumper Wires 6″ M/M
3 x Half-Size Breadboard
Arduino UNO
SP1 – Digital 3
DI1 – Digital 2
SP2 – Digital 5
DI2 – Digital 4
SV1 – Digital 6
PO1 – Analog A0
SV2 – Digital 7
PO2 – Analog A1
VIN – +5V
GND – GND
DL1912Mk01.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - RC Servo Motor - Mk02 // 12-01 // DL1912Mk01p.ino 12-02 // Arduino UNO // Screw Shield // Adafruit RGB LCD Shield // 2 x Small Stepper Motor // 2 x EasyDriver // 2 x RC Servo Motor // 2 x Potentiometer // include the library code: #include <Adafruit_RGBLCDShield.h> #include <Servo.h> // Adafruit RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); // These #defines make it easy to set the backlight color #define OFF 0x0 #define RED 0x1 #define YELLOW 0x3 #define GREEN 0x2 #define TEAL 0x6 #define BLUE 0x4 #define VIOLET 0x5 #define WHITE 0x7 // Momentary Button int yy = 0; uint8_t momentaryButton = 0; // 2 x EasyDriver int dirPinR = 2; // EasyDriver Right int stepPinR = 3; // stepPin Right int dirPinL = 4; // EasyDriver Left int stepPinL = 5; // stepPin Left int i = 0; // 2 x RC Servo Motor // 2 x Potentiometer Servo isRCServo1; // Create servo object to control a RCServo1 int servo1 = 6; // Servo 1 int iPot1 = A0; // Analog Potentiometer 1 int iVal1; // Variable - Analog Potentiometer 1 Servo isRCServo2; // Create servo object to control a RCServo2 int servo2 = 7; // Servo 2 int iPot2 = A1; // Analog Potentiometer 2 int iVal2; // Variable - Analog Potentiometer 2 void loop() { // Clear RGBLCDShield.clear(); // Momentary Button momentaryButton = RGBLCDShield.readButtons(); switch ( yy ) { case 1: // Up isSwitch1(); break; case 2: // Down isSwitch2(); break; case 3: // Right isSwitch3(); break; case 4: // Left isSwitch4(); break; case 5: // Stop isSwitch5(); break; default: // Stop yy = 5; RGBLCDShield.setBacklight(RED); isSwitch5(); } if ( momentaryButton ) { if ( momentaryButton & BUTTON_UP ) { yy = 1; // Up RGBLCDShield.setBacklight(GREEN); } if ( momentaryButton & BUTTON_DOWN ) { yy = 2; // Down RGBLCDShield.setBacklight(VIOLET); } if ( momentaryButton & BUTTON_LEFT ) { yy = 3; // Right RGBLCDShield.setBacklight(TEAL); } if ( momentaryButton & BUTTON_RIGHT ) { yy = 4; // Left RGBLCDShield.setBacklight(YELLOW); } if ( momentaryButton & BUTTON_SELECT ) { yy = 5; // Stop RGBLCDShield.setBacklight(RED); } } }
getServo.ino
// Servo // isServoSetup void isServoSetup() { // 2 x RC Servo Motor isRCServo1.attach( servo1 ); isRCServo2.attach( servo2 ); } // isServo1 void isServo1() { // EasyDriver isStepperStop(); // Potentiometer RC Servo Motor 1 iVal1 = analogRead( iPot1 ); // Reads the value of the iPot1 (Value between 0 and 1023) iVal1 = map(iVal1, 0, 1023, 0, 180); // Scale it to use it with the isRCServo1 (Value between 0 and 180) isRCServo1.write( iVal1 ); // isRCServo1 sets the servo position according to the scaled value delay(15); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("isRCServo 1"); // isRCServo 1 // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( iVal1 ); // Reads the value iVal1 delay(500); } // isServo2 void isServo2() { // EasyDriver isStepperStop(); // Potentiometer RC Servo Motor 1 iVal2 = analogRead( iPot2 ); // Reads the value of the iPot2 (Value between 0 and 1023) iVal2 = map(iVal2, 0, 1023, 0, 180); // Scale it to use it with the isRCServo2 (Value between 0 and 180) isRCServo2.write( iVal2 ); // isRCServo2 sets the servo position according to the scaled value delay(15); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("isRCServo 2"); // isRCServo 2 // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print( iVal2 ); // Reads the value iVal2 delay(500); }
getStepper.ino
// Stepper // isStepperSetup void isStepperSetup() { // 2 x EasyDriver pinMode(dirPinR, OUTPUT); pinMode(stepPinR, OUTPUT); pinMode(dirPinL, OUTPUT); pinMode(stepPinL, OUTPUT); } // isStepper1 void isStepper1(){ // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Up"); delay(500); // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); for (i = 0; i<300; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // isStepper2 void isStepper2(){ // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Down"); delay(500); // 2 x EasyDriver digitalWrite(dirPinR, HIGH); // Set the direction. delay(100); digitalWrite(dirPinL, HIGH); // Set the direction. delay(100); for (i = 0; i<300; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // isStepperStop void isStepperStop() { // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the }
getSwitch.ino
// Switch // Switch 1 void isSwitch1(){ // Up yy = 1; // 2 x EasyDriver isStepper1(); } // Switch 2 void isSwitch2(){ // Down yy = 2; // 2 x EasyDriver isStepper2(); } // Switch 3 void isSwitch3(){ // Right yy = 3; // Potentiometer RC Servo Motor 1 isServo1(); } // Switch 4 void isSwitch4(){ // Left yy = 4; // Potentiometer RC Servo Motor 2 isServo2(); } // Switch 5 void isSwitch5(){ // Stop yy = 5; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Robotics"); // Robotics RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Stop"); delay( 500 ); // EasyDriver isStepperStop(); }
setup.ino
// Setup void setup() { // Adafruit RGB LCD Shield // Set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Robotics"); // EasyDriver delay(5000); // Clear RGBLCDShield.clear(); // 2 x EasyDriver isStepperSetup(); // 2 x RC Servo Motor isServoSetup(); }
Follow Us
Web: https://www.donluc.com/
Web: http://neosteamlabs.com/
Web: http://www.jlpconsultants.com/
YouTube: https://www.youtube.com/channel/UC5eRjrGn1CqkkGfZy0jxEdA
Facebook: https://www.facebook.com/neosteam.labs.9/
Instagram: https://www.instagram.com/neosteamlabs/
Pinterest: https://www.pinterest.com/NeoSteamLabs/
Twitter: https://twitter.com/labs_steam
Etsy: https://www.etsy.com/shop/NeoSteamLabs
Don Luc
Project #12: Robotics – EasyDriver – Mk01
——
——
——
——
——
——
Small Stepper Motor
Stepper motors are great motors for position control. They can be found in desktop printers, plotters, 3D printers, CNC milling machines, and anything else requiring precise position control. Steppers are a special segment of brushless motors. They are purposely built for high-holding torque. This high-holding torque gives the user the ability to incrementally “step” to the next position. This results in a simple positioning system that doesn’t require an encoder. This makes stepper motor controllers very simple to build and use. These small steppers are a great way to get things moving, especially when positioning and repeatability is a concern. This is a Bipolar motor.
Pros
Excellent position accuracy
High holding torque
High reliability
Most steppers come in standard sizes
Cons
Small step distance limits top speed
It’s possible to “skip” steps with high loads
Draws maximum current constantly
DL1911Mk04
1 x Adafruit RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
2 x EasyDriver – Stepper Motor Driver
2 x Small Stepper Motor
2 x Pololu Mounting
4 x Jumper Wires 3″ M/M
10 x Jumper Wires 6″ M/M
2 x Half-Size Breadboard
Arduino UNO
SP1 – Digital 3
DI1 – Digital 2
SP2 – Digital 5
DI2 – Digital 4
VIN – +5V
GND – GND
DL1911Mk04.ino
// ***** Don Luc Electronics © ***** // Software Version Information // Project #12: Robotics - EasyDriver - Mk01 // 11-04 // DL1911Mk04p.ino 12-01 // Arduino UNO // Screw Shield // Adafruit RGB LCD Shield // 2 x Small Stepper Motor // 2 x EasyDriver // include the library code: #include <Adafruit_RGBLCDShield.h> // Adafruit RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); // These #defines make it easy to set the backlight color #define OFF 0x0 #define RED 0x1 #define YELLOW 0x3 #define GREEN 0x2 #define TEAL 0x6 #define BLUE 0x4 #define VIOLET 0x5 #define WHITE 0x7 // Momentary Button int yy = 0; uint8_t momentaryButton = 0; // 2 x EasyDriver int dirPinR = 2; // EasyDriver Right int stepPinR = 3; // stepPin Right int dirPinL = 4; // EasyDriver Left int stepPinL = 5; // stepPin Left int i = 0; void loop() { // Clear RGBLCDShield.clear(); // Momentary Button momentaryButton = RGBLCDShield.readButtons(); switch ( yy ) { case 1: // Up isSwitch1(); break; case 2: // Down isSwitch2(); break; case 3: // Right isSwitch3(); break; case 4: // Left isSwitch4(); break; case 5: // Stop isSwitch5(); break; default: // Stop yy = 5; RGBLCDShield.setBacklight(RED); isSwitch5(); } if ( momentaryButton ) { if ( momentaryButton & BUTTON_UP ) { yy = 1; // Up RGBLCDShield.setBacklight(GREEN); } if ( momentaryButton & BUTTON_DOWN ) { yy = 2; // Down RGBLCDShield.setBacklight(VIOLET); } if ( momentaryButton & BUTTON_LEFT ) { yy = 3; // Right RGBLCDShield.setBacklight(TEAL); } if ( momentaryButton & BUTTON_RIGHT ) { yy = 4; // Left RGBLCDShield.setBacklight(YELLOW); } if ( momentaryButton & BUTTON_SELECT ) { yy = 5; // Stop RGBLCDShield.setBacklight(RED); } } }
getSwitch.ino
// Switch // Switch 1 void isSwitch1(){ // Up yy = 1; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Up"); // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); for (i = 0; i<1000; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // Switch 2 void isSwitch2(){ // Down yy = 2; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Down"); // 2 x EasyDriver digitalWrite(dirPinR, HIGH); // Set the direction. delay(100); digitalWrite(dirPinL, HIGH); // Set the direction. delay(100); for (i = 0; i<1000; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // Switch 3 void isSwitch3(){ // Right yy = 3; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Hight"); // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, HIGH); // Set the direction. delay(100); for (i = 0; i<1000; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // Switch 4 void isSwitch4(){ // Left yy = 4; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Left"); // 2 x EasyDriver digitalWrite(dirPinR, HIGH); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); for (i = 0; i<1000; i++) // Iterate for 1000 microsteps. { digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinR, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, HIGH); // "Rising Edge" so the easydriver knows to when to step. delayMicroseconds(170); // This delay time is close to top speed. } } // Switch 5 void isSwitch5(){ // Stop yy = 5; // set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("EasyDriver"); // EasyDriver RGBLCDShield.setCursor(0,1); RGBLCDShield.print("Stop"); delay( 1000 ); // 2 x EasyDriver digitalWrite(dirPinR, LOW); // Set the direction. delay(100); digitalWrite(dirPinL, LOW); // Set the direction. delay(100); digitalWrite(stepPinR, LOW); // This LOW to HIGH change is what creates the digitalWrite(stepPinL, LOW); // This LOW to HIGH change is what creates the }
setup.ino
// Setup void setup() { // Adafruit RGB LCD Shield // Set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc Electron"); // Don luc Electron // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("EasyDriver"); // EasyDriver delay(5000); // Clear RGBLCDShield.clear(); // 2 x EasyDriver pinMode(dirPinR, OUTPUT); pinMode(stepPinR, OUTPUT); pinMode(dirPinL, OUTPUT); pinMode(stepPinL, OUTPUT); }
Follow Us
Web: https://www.donluc.com/
Web: http://neosteamlabs.com/
Web: http://www.jlpconsultants.com/
YouTube: https://www.youtube.com/channel/UC5eRjrGn1CqkkGfZy0jxEdA
Facebook: https://www.facebook.com/neosteam.labs.9/
Instagram: https://www.instagram.com/neosteamlabs/
Pinterest: https://www.pinterest.com/NeoSteamLabs/
Twitter: https://twitter.com/labs_steam
Etsy: https://www.etsy.com/shop/NeoSteamLabs
Don Luc
Project #7: RGB LCD Shield – MCP4131 – Mk10
Microchip Technology Inc – MCP4131
Features:
-7-bit: 128 Resistors with 129 Taps to VSS and VDD
-SPI compatible interface
-Automatic Recall of Potentiometer Wiper Settings Resistance Values: 5k Ohm, 10k Ohm, 50k Ohm, 100k Ohm
-Absolute (Rheostat): <100 ppm (typ.)
-Ratiometric (Potentiometer): <10 ppm (typ.)
Device Overview – Summary
The MCP41/423X devices are volatile, 7-bit (129 wiper steps) digital potentiometers with an SPI compatible interface. The MCP41/42XX family is available with end-to-end resistor values of 5K Ohm, 10K Ohm, 50k Ohm and 100K Ohm. These devices offer a variety of configurations simplifying design while minimizing cost, package size and pin count.
Additional Features
-7-bit: 128 Resistors with 129 Taps to VSS and VDD
-SPI compatible interface
-Automatic Recall of Potentiometer Wiper Settings Resistance Values: 5k Ohm, 10k Ohm, 50k Ohm, 100k Ohm
-Low Tempco: Absolute (Rheostat): <100 ppm (typ.)
-Ratiometric (Potentiometer): <10 ppm (typ.)
-Low Wiper Resistance: 100 Ohm (typ.)
-Low-Power Operation: 1µA Max Static Current
-Wide Operating Voltage: 1.8V to 5.5V
-Extended Temperature Range: -40°C to +125°C
MCP4131 – Digital Potentiometer – 10K
Potentiometers are incredibly useful, whether you’re controlling the volume on your stereo or the ‘mood lighting’ in your room. The problem with traditional potentiometers is the fact that your microcontroller doesn’t have an easy way to interface with them. Digital potentiometers solve that problem by allowing you to control a voltage splitter with digital signals.
Wire it up just like a potentiometer and use serial signals to ‘turn the knob’. Another handy feature of digital potentiometers is that because they aren’t controlled mechanically, they don’t have a pre-determined sweep profile. In other words, depending on the way you write your code the potentiometer can ‘sweep’ in a linear fashion, a logarithmic fashion, or according to any other profile you like. Digital potentiometers can also be used in conjunction with rotary encoders to consolidate large banks of potentiometers into one ‘smart’ rotary control.
Digital Potentiometer MCP41131 and Arduino
We know the analog potentiometer, is a three-terminal resistor with a sliding contact that forms an adjustable voltage divider. Potentiometers many application such like:
1- Volume controls on audio equipment
2- Control the amplifier gain and offset
3- Transducer displacement transducers
Many other application, but did you want to control the resistance value by Arduino instead of using analog one. Analog potentiometers have some problem with Arduino doesn’t have an easy way to interface with them. The digital potentiometer, give you an ability to adjust the resistance, allowing you to control a voltage splitter with digital signals. This IC using SPI Protocol to communicate with Arduino.
DonLuc1808Mk03
1 x RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
1 x MCP4131
1 x LED Green
1 x 270 Ohm Resistance
1 x NeoPixel Stick – 8 x 5050 RGB LED
1 x 100K Potentiometer
1 x Black Knob
7 x Jumper Wires 3″ M/M
12 x Jumper Wires 6″ M/M
1 x Full-Size Breadboard
1 x USB Cable A to B
Arduino UNO
MC1 – Digital 13
MC2 – Digital 11
MC3 – Digital 10
LR1 – Digital 3
POT – Analog 1
GND – GND
VIN – +5V
DonLuc1808Mk03p.ino
// ***** Don Luc Electronics ***** // Software Version Information // Project #7: RGB LCD Shield – MCP4131 – Mk10 // 8-03 // DonLuc1808Mk03p 8-03 // RGB LCD Shield // MCP4131 // Include Library Code #include <Adafruit_MCP23017.h> #include <Adafruit_RGBLCDShield.h> #include <Adafruit_NeoPixel.h> #include <SPI.h> // RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); #define GREEN 0x2 // NeoPixels #define PIN 3 // On digital pin 3 #define NUMPIXELS 8 // NeoPixels NUMPIXELS = 8 Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int red = 0; // Red int green = 0; // Green int blue = 0; // Blue int iNeo = 0; // Neopix const int iBriPin = A1; // Panel Mount 1K potentiometer Brightneed int iBri = 0; // Neopix Brightness int iBriMin = 1023; // Brightneed minimum sensor value int iBriMax = 0; // Brightneed maximun sensor value int z = 0; // Value // MCP4131 int pinCS = 10; // MCP4131 byte address = 0x00; // Address int i = 0; // Value void loop() { // MCP4131 isMCP4131(); delay(1000); // Clear RGBLCDShield.clear(); }
getMCP4131.ino
// MCP4131 void isMCP4131() { // NeoPixels isNUMPIXELSoff(); // isNUMPIXELSoff // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("MCP4131"); // MCP4131 // MCP4131 // Move the potentiometer in one direction for ( i = 0; i <= 128; i++) { isNUMPIXELSoff(); // isNUMPIXELSoff MCP4131PotWrite(i); isNUMPIXELS(); // isNUMPIXELS delay(100); // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Level = "); // MCP4131 RGBLCDShield.print(i); // MCP4131 } delay(2000); // wait a couple seconds // Now mover potentiometer in other directions for ( i = 128; i >= 0; i--) { isNUMPIXELSoff(); // isNUMPIXELSoff MCP4131PotWrite(i); isNUMPIXELS(); // isNUMPIXELS delay(100); RGBLCDShield.setCursor(0, 1); RGBLCDShield.print(" "); RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Level = "); // MCP4131 RGBLCDShield.print(i); // MCP4131 } delay(2000); } // MCP4131PotWrite int MCP4131PotWrite(int value) { digitalWrite(pinCS, LOW); // pinCS Off SPI.transfer(address); // SPI Address SPI.transfer(value); // SPI Value digitalWrite(pinCS, HIGH); // pinCS On }
neopix.ino
// NeoPixels void neopix() { // Brightness iBri = analogRead(iBriPin); // iBri apply the calibration to the sensor reading iBri = map(iBri, iBriMin, iBriMax, 0, 255); // iBri in case the sensor value is outside the range seen during calibration iBri = constrain(iBri, 0, 255); pixels.setBrightness( iBri ); // Pixels.Color takes RGB values, from 0,0,0 up to 255,255,255 pixels.setPixelColor( iNeo, pixels.Color(red,green,blue) ); // This sends the updated pixel color to the hardware pixels.show(); // Delay for a period of time (in milliseconds) delay(50); } // isNUMPIXELS void isNUMPIXELS() { // Neopix Value z = ( i / 16 ); // Value // Neopix Value switch ( z ) { case 0: // NeoPixels // Green for(int y=0; y<=0; y++) { red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 1: // Green // NeoPixels for(int y=0; y<=1; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 2: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 3: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Yellow for(int y=3; y<=3; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 4: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Yellow for(int y=3; y<=4; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 5: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Yellow for(int y=3; y<=5; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 6: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Yellow for(int y=3; y<=5; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Red for(int y=6; y<=6; y++){ red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 7: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Yellow for(int y=3; y<=5; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Red for(int y=6; y<=7; y++){ red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 8: // NeoPixels // Green for(int y=0; y<=2; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Yellow for(int y=3; y<=5; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Red for(int y=6; y<=7; y++){ red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; } } // isNUMPIXELSoff void isNUMPIXELSoff() { // Black // NeoPixels for(int y=0; y < NUMPIXELS; y++) { red = 0; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } }
setup.ino
// Setup void setup() { // set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc"); // Don luc // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("MCP4131"); // MCP4131 delay(5000); // Clear RGBLCDShield.clear(); // NeoPixels pixels.begin(); // This initializes the NeoPixel library // NeoPixels isNUMPIXELSoff(); // isNUMPIXELSoff // MCP4131 pinMode(pinCS, OUTPUT); // MCP4131 OUTPUT SPI.begin(); // SPI }
Don Luc
Project #7: RGB LCD Shield – Bi-Color LED – Mk09
Bi-Color LED
Bi-color LEDs contain two different LED emitters in one case. There are two types of these. One type consists of two dies connected to the same two leads antiparallel to each other. Current flow in one direction emits one color, and current in the opposite direction emits the other color. The other type consists of two dies with separate leads for both dies and another lead for common anode or cathode so that they can be controlled independently. The most common bi-color combination is red/traditional green, however, other available combinations include amber/traditional green, red/pure green, red/blue, and blue/pure green.
Super Bright BiPolar LEDs
Package of 12 super bright Red/Green jumbo T1 3/4 5mm LEDs. These have a diffused frosted lens and 3 long leads. Prime 100% perfect and bright. CODE 7: 100% Prime Parts. Stock # GP55
DonLuc1808Mk02
1 x RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
3 x Bi-Color LED GP55
3 x 270 Ohm Resistance
3 x 330 Ohm Resistance
3 x Jumper Wires 3″ M/M
7 x Jumper Wires 6″ M/M
1 x Size Breadboard
1 x USB Cable A to B
Arduino UNO
LG3 – Digital 5
LR3 – Digital 4
LG2 – Digital 3
LR2 – Digital 2
LG1 – Digital 1
LR1 – Digital 0
GND – GND
DonLuc1808Mk02p.ino
// ***** Don Luc ***** // Software Version Information // Project #7: RGB LCD Shield – Bi-Color LED – Mk09 // 8-02 // DonLuc1808Mk02p 8-02 // RGB LCD Shield // Bi-Color LED // Include Library Code #include <Adafruit_MCP23017.h> #include <Adafruit_RGBLCDShield.h> // RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); #define GREEN 0x2 // Bi-Color LED int iLR1 = 0; // LED Red 1 int iLG1 = 1; // LED Green 1 int iLR2 = 2; // LED Red 2 int iLG2 = 3; // LED Green 2 int iLR3 = 4; // LED Red 3 int iLG3 = 5; // LED Green 3 void loop() { // Bi-Color LED isBiColor(); delay(1000); // Clear RGBLCDShield.clear(); }
getBiColor.ino
// Bi-Color LED void isBiColor() { // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Bi-Color LED"); // Bi-Color LED // Bi-Color LED // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("L1x- L2x- L3x-"); // Bi-Color LED Red digitalWrite(iLR1, HIGH); // LED Red 1 digitalWrite(iLG1, LOW); // LED Green 1 digitalWrite(iLR2, HIGH); // LED Red 2 digitalWrite(iLG2, LOW); // LED Green 2 digitalWrite(iLR3, HIGH); // LED Red 3 digitalWrite(iLG3, LOW); // LED Green 3 delay( 2000 ); // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("L1-x L2-x L3-x"); // Bi-Color LED Green digitalWrite(iLR1, LOW); // LED Red 1 digitalWrite(iLG1, HIGH); // LED Green 1 digitalWrite(iLR2, LOW); // LED Red 2 digitalWrite(iLG2, HIGH); // LED Green 2 digitalWrite(iLR3, LOW); // LED Red 3 digitalWrite(iLG3, HIGH); // LED Green 3 delay( 2000 ); // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("L1xx L2xx L3xx"); // Bi-Color LED Red-Green digitalWrite(iLR1, HIGH); // LED Red 1 digitalWrite(iLG1, HIGH); // LED Green 1 digitalWrite(iLR2, HIGH); // LED Red 2 digitalWrite(iLG2, HIGH); // LED Green 2 digitalWrite(iLR3, HIGH); // LED Red 3 digitalWrite(iLG3, HIGH); // LED Green 3 delay( 2000 ); }
setup.ino
// Setup void setup() { // set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc"); // Don luc // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Bi-Color LED"); // Bi-Color LED delay(5000); // Clear RGBLCDShield.clear(); // Bi-Color LED pinMode(iLR1, OUTPUT); // LED Red 1 pinMode(iLG1, OUTPUT); // LED Green 1 pinMode(iLR2, OUTPUT); // LED Red 2 pinMode(iLG2, OUTPUT); // LED Green 2 pinMode(iLR3, OUTPUT); // LED Red 3 pinMode(iLG3, OUTPUT); // LED Green 3 }
Don Luc
Project #7: RGB LCD Shield – Rotary Switch – Mk08
Rotary Switch – 10 Position
This is a single pole, 10 position rotary switch able to select up to 10 different states in a durable package. Unlike our other rotary switch, this model is much more robust and capable of handling larger currents and voltages.
With a max voltage rating of 125VAC at 0.3A and a dielectric strength of 250VAC for 1 minute this is a serious little rotary switch capable of working with some of your bigger projects. Though this switch requires you to use 11 pins and is not breadboard friendly we do offer a breakout board (found in the Recommended Products section below) to provide easier access to its capabilities.
1 x Rotary Switch – 10 Position
1 x Hex Nut
2 x Washer
Rating: 0.3A/125VAC
Contact Resistance: 50M Ohm max
Insulation Resistance: 100M Ohm @ 500VDC min
Dielectric Strength: 250VAC for 1 minute
Rotation torque: 1.0+0.5KG/cm
Shaft: 3/8″
Rotary Switch Breakout
This is the SparkFun Rotary Switch Breakout, a very simple board designed to easily provide you access to each pin on our 10-position rotary switches. This breakout allows you to easily add a rotary switch to your next project without having to worry about attaching its unique footprint to a custom board or solderless breadboard. All you need to do is solder the 10-position rotary switch into the breakout (using the silkscreen on the board as a guide) and each pin will become available for breadboard or hookup wire compatibility.
Each one of these boards breaks out the common ( C ), 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10 positions on the board into 0.1″ spaced pins.
NeoPixel Stick – 8 x 5050 RGB LED
Make your own little LED strip arrangement with this stick of NeoPixel LEDs. We crammed 8 of the tiny 5050 (5mm x 5mm) smart RGB LEDs onto a PCB with mounting holes and a chainable design. Use only one microcontroller pin to control as many as you can chain together! Each LED is addressable as the driver chip is inside the LED. Each one has ~18mA constant current drive so the color will be very consistent even if the voltage varies, and no external choke resistors are required making the design slim. Power the whole thing with 5VDC (4-7V works) and you’re ready to rock.
DonLuc1808Mk01
1 x RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
1 x Rotary Switch – 10 Position
1 x Rotary Switch Breakout
1 x Black Knob
1 x NeoPixel Stick – 8 x 5050 RGB LED
1 x 100K Potentiometer
1 x Black Knob
11 x 1K Ohm Resistance
17 x Jumper Wires 3″ M/M
6 x Jumper Wires 6″ M/M
1 x Size Breadboard
1 x USB Cable A to B
Arduino UNO
NEO – Digital 0
ROT – Analog 1
POT – Analog 0
GND – GND
VIN – +5V
DonLuc1808Mk01p.ino
// ***** Don Luc ***** // Software Version Information // Project #7: RGB LCD Shield – Rotary Switch – Mk08 // 8-01 // DonLuc1808Mk01p 8-01 // RGB LCD Shield // Rotary Switch // Include Library Code #include <Adafruit_MCP23017.h> #include <Adafruit_RGBLCDShield.h> #include <Adafruit_NeoPixel.h> // RGB LCD Shield Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); #define GREEN 0x2 // NeoPixels #define PIN 0 // On digital pin 3 #define NUMPIXELS 8 // NeoPixels NUMPIXELS = 8 Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800); int red = 0; // Red int green = 0; // Green int blue = 0; // Blue int iNeo = 0; // Neopix const int iBriPin = A0; // Panel Mount 1K potentiometer Brightneed int iBri = 0; // Neopix Brightness int iBriMin = 1023; // Brightneed minimum sensor value int iBriMax = 0; // Brightneed maximun sensor value // Rotary Switch // Rotary Switch - 10 Position // Number = 1 => 10 int iRotNum = A1; // Rotary Switch int iVal = 0; // iVal - Value int z = 0; // Number void loop() { // Rotary Switch isRot(); delay(1000); // Clear RGBLCDShield.clear(); }
getRot.ino
// Rotary Switch void isRot() { // NeoPixels for(int y=0; y < NUMPIXELS; y++) { // Black red = 0; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Rotary Switch"); // Rotary Switch // Rotary Switch z = analogRead( iRotNum ); // Rotary Switch iVal = ( z / 100 ); // Rotary Value // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("iVal = "); // Rotary Value RGBLCDShield.print( iVal + 1 ); // Range Value switch ( iVal ) { case 0: // Red // NeoPixels for(int y=0; y<NUMPIXELS; y++){ red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 1: // Green // NeoPixels for(int y=0; y<NUMPIXELS; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 2: // Blue // NeoPixels for(int y=0; y<NUMPIXELS; y++){ red = 0; // Red green = 0; // Green blue = 255; // Blue iNeo = y; // Neopix neopix(); } break; case 3: // White // NeoPixels for(int y=0; y<NUMPIXELS; y++){ red = 255; // Red green = 255; // Green blue = 255; // Blue iNeo = y; // Neopix neopix(); } break; case 4: // NeoPixels // Red for(int y=0; y<NUMPIXELS; y++){ red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } delay( 2000 ); // Green for(int y=0; y<NUMPIXELS; y++){ red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } delay( 2000 ); // Blue for(int y=0; y<NUMPIXELS; y++){ red = 0; // Red green = 0; // Green blue = 255; // Blue iNeo = y; // Neopix neopix(); } break; case 5: // NeoPixels // Yellow for(int y=0; y<NUMPIXELS; y++){ red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 6: // NeoPixels // Orange for(int y=0; y<NUMPIXELS; y++){ red = 255; // Red green = 102; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } break; case 7: // NeoPixels // Violet for(int y=0; y<NUMPIXELS; y++){ red = 204; // Red green = 102; // Green blue = 204; // Blue iNeo = y; // Neopix neopix(); } break; case 8: // NeoPixels // Red red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = 0; // Neopix neopix(); delay( 1000 ); // Green red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = 1; // Neopix neopix(); delay( 1000 ); // Blue red = 0; // Red green = 0; // Green blue = 255; // Blue iNeo = 2; // Neopix neopix(); delay( 1000 ); // White red = 255; // Red green = 255; // Green blue = 255; // Blue iNeo = 3; // Neopix neopix(); delay( 1000 ); // Pink red = 255; // Red green = 153; // Green blue = 203; // Blue iNeo = 4; // Neopix neopix(); delay( 1000 ); // Orange red = 255; // Red green = 102; // Green blue = 0; // Blue iNeo = 5; // Neopix neopix(); delay( 1000 ); // Violet red = 204; // Red green = 102; // Green blue = 204; // Blue iNeo = 6; // Neopix neopix(); delay( 1000 ); // Yellow red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = 7; // Neopix neopix(); delay( 1000 ); break; case 9: // NeoPixels // Red red = 255; // Red green = 0; // Green blue = 0; // Blue iNeo = 7; // Neopix neopix(); delay( 1000 ); // Green red = 0; // Red green = 255; // Green blue = 0; // Blue iNeo = 6; // Neopix neopix(); delay( 1000 ); // Blue red = 0; // Red green = 0; // Green blue = 255; // Blue iNeo = 5; // Neopix neopix(); delay( 1000 ); // White red = 255; // Red green = 255; // Green blue = 255; // Blue iNeo = 4; // Neopix neopix(); delay( 1000 ); // Pink red = 255; // Red green = 153; // Green blue = 203; // Blue iNeo = 3; // Neopix neopix(); delay( 1000 ); // Orange red = 255; // Red green = 102; // Green blue = 0; // Blue iNeo = 2; // Neopix neopix(); delay( 1000 ); // Violet red = 204; // Red green = 102; // Green blue = 204; // Blue iNeo = 1; // Neopix neopix(); delay( 1000 ); // Yellow red = 255; // Red green = 255; // Green blue = 0; // Blue iNeo = 0; // Neopix neopix(); delay( 1000 ); break; } }
neopix.ino
// NeoPixels void neopix() { // Brightness iBri = analogRead(iBriPin); // iBri apply the calibration to the sensor reading iBri = map(iBri, iBriMin, iBriMax, 0, 255); // iBri in case the sensor value is outside the range seen during calibration iBri = constrain(iBri, 0, 255); pixels.setBrightness( iBri ); // Pixels.Color takes RGB values, from 0,0,0 up to 255,255,255 pixels.setPixelColor( iNeo, pixels.Color(red,green,blue) ); // This sends the updated pixel color to the hardware pixels.show(); // Delay for a period of time (in milliseconds) delay(50); }
setup.ino
// Setup void setup() { // set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc"); // Don luc // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("Rotary Switch"); // Rotary Switch delay(5000); // Clear RGBLCDShield.clear(); // NeoPixels pixels.begin(); // This initializes the NeoPixel library // NeoPixels for(int y=0; y < NUMPIXELS; y++) { // Black red = 0; // Red green = 0; // Green blue = 0; // Blue iNeo = y; // Neopix neopix(); } }
Don Luc
Project #7: RGB LCD Shield – Line Sensor Breakout – Mk07
Line Sensor Breakout – QRE1113 (Analog)
Description
This version of the QRE1113 breakout board features an easy-to-use analog output, which will vary depending on the amount of IR light reflected back to the sensor. This tiny board is perfect for line sensing applications and can be used in both 3.3V and 5V systems.
The board’s QRE1113 IR reflectance sensor is comprised of two parts – an IR emitting LED and an IR sensitive phototransistor. When you apply power to the VCC and GND pins the IR LED inside the sensor will illuminate. A 100 Ohm resistor is on-board and placed in series with the LED to limit current. A 10k Ohm resistor pulls the output pin high, but when the light from the LED is reflected back onto the phototransistor the output will begin to go lower. The more IR light sensed by the phototransistor, the lower the output voltage of the breakout board.
These sensors are widely used in line following robots – white surfaces reflect much more light than black, so, when directed towards a white surface, the voltage output will be lower than that on a black surface.
The power input and analog output pins are brought out to a 3-pin, 0.1″ pitch header. The board also has a single mounting hole if you want to screw the board onto something.
Features
* 5VDC operating voltage
* 25mA supply current
* Optimal sensing distance: 0.125″ (3mm)
* 0.30 x 0.55 “ (7.62 x 13.97 mm)
Common Reflectance Sensor
The QRE1113 is a common reflectance sensor often used in robotic line followers. The sensor works by shining an IR LED down and seeing how much of that light bounces back using a phototransistor. Because dark colors will bounce back less of the light, the sensor can be used to tell the difference between white and black areas. So an array of these can be used to help a robot determine where a dark line is on the ground so it can follow it. But they can also be used to determine proximity under an inch.
The an analog input on your microcontroller but still need an analog reading of how much light was reflected. It does this by allowing you to charge a capacitor on the board, and then timing how long it takes to discharge. The more light that is reflected, the less time it takes to discharge the capacitor. Hooking the QRE1113 to your Arduino is very simple. It just needs power (5V), ground, and an analog pin.
DonLuc1807Mk11
1 x RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
1 x Line Sensor Breakout – QRE1113 (Analog)
3 x Jumper Wires 6″ M/M
1 x Half-Size Breadboard
Arduino UNO
CRS – Analog 0
GND – GND
VIN – +5V
DonLuc1807Mk11p.ino
// ***** Don Luc ***** // Software Version Information // Project #7: RGB LCD Shield – Line Sensor Breakout – Mk07 // 7-11 // DonLuc1807Mk10p 7-11 // RGB LCD Shield // QRE1113 (Analog) // include the library code: #include <Adafruit_MCP23017.h> #include <Adafruit_RGBLCDShield.h> Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield(); #define GREEN 0x2 // Seven-Segment Display int iQRE1113 = A0; // iQRE1113 int iQRE1113Value = 0; // iQRE1113Value void loop() { // QRE1113 (Analog) isCRS(); delay(2000); // Clear RGBLCDShield.clear(); }
getSeven.ino
// Line Sensor Breakout - QRE1113 void isCRS() { // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("QRE1113 (Analog)"); // Line Sensor Breakout - QRE1113 iQRE1113Value = analogRead(iQRE1113); // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("iQRE1113 = "); // iQRE1113 RGBLCDShield.print( iQRE1113Value ); // iQRE1113Value }
setup.ino
// Setup void setup() { // set up the LCD's number of columns and rows: RGBLCDShield.begin(16, 2); RGBLCDShield.setBacklight(GREEN); // Display // Set the cursor to column 0, line 0 RGBLCDShield.setCursor(0,0); RGBLCDShield.print("Don Luc"); // Don luc // Set the cursor to column 0, line 1 RGBLCDShield.setCursor(0, 1); RGBLCDShield.print("QRE1113 (Analog)"); // Seven-Segment Display delay(5000); // Clear RGBLCDShield.clear(); }
Don Luc