Project #10: ESP8266 Thing – Web Server – Mk03

AP Web Server

Not only can the ESP8266 connect to a WiFi network and interact with the Internet, but it can also set up a network of its own, allowing other devices to connect directly to it. This example demonstrates how to turn the ESP8266 into an access point (AP), and serve up web pages to any connected client.

After uploading this sketch, find another device that you can connect to a WiFi network – phone, laptop, etc. Look for a network called “Thing-XXXX”, where XXXX is the last 2 bytes of the Thing’s MAC address.

WiFi => Yes

ESP8266 Thing XXXX

He sketch sets the network’s password to “donlucmk01”.

After connecting to your Thing’s AP network, load up a browser and point it to 192.168.4.1/read. The Thing should serve up a web page showing you its ADC and digital pin 12 readings:

Analog Pin = XXX
Digital Pin: XXX
Humidity and Temperature
Humidity: XX.XX%
Celsius: XX.XX*C
Fahrenheit: XX.XX*F

LED Green

After that, give 192.168.4.1/led/0 (No) and 192.168.4.1/led/1 (Yes) a try, and keep an eye on the Thing’s green LED while you do.

RHT03 Humidity and Temperature Sensor

The RHT03 is a low cost humidity and temperature sensor with a single wire digital interface. The sensor is calibrated and doesn’t require extra components so you can get right to measuring relative humidity and temperature.

DonLuc1901Mk02

1 x SparkFun ESP8266 Thing
1 x SparkFun FTDI Basic Breakout – 3.3V
1 x RHT03 Humidity and Temperature Sensor
3 x Jumper Wires 6″ M/M
1 x Full-Size Breadboard
1 x SparkFun Cerberus USB Cable

SparkFun ESP8266 Thing

LG1 – Digital 5
RHT – Digital 4
GND – GND
VIN – +3.3V

DonLuc1901Mk02p.ino

// ***** Don Luc Electronics *****
// Software Version Information
// Project #10: SparkFun ESP8266 Thing – AP Web Server - Mk02
// 01-02
// DonLuc1901Mk01p.ino 01-02
// SparkFun ESP8266 Thing
// AP Web Server
// RHT03 Humidity and Temperature Sensor

// Include Library Code
#include <ESP8266WiFi.h>
#include <SparkFun_RHT03.h>

// WiFi Definitions 
const char WiFiAPPSK[] = "donlucmk01";

// Pin Definitions 
const int LED_PIN = 5;                  // Thing's onboard, green LED
const int ANALOG_PIN = A0;              // The only analog pin on the Thing
const int DIGITAL_PIN = 12;             // Digital pin to be read

// WiFi
WiFiServer server(80);

// RHT Humidity and Temperature Sensor
const int RHT03_DATA_PIN = 4;           // RHT03 data pin Digital 4
RHT03 rht;                              // This creates a RTH03 object, which we'll use to interact with the sensor
float latestHumidity;
float latestTempC;
float latestTempF;
  
void loop() 
{

  // RHT03 Humidity and Temperature Sensor
  isRHT03();

  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }

  // Read the first line of the request
  String req = client.readStringUntil('\r');
  Serial.println(req);
  client.flush();

  // Match the request
  int val = -1; // We'll use 'val' to keep track of both the request type (read/set) and value if set.
  if (req.indexOf("/led/0") != -1)
    val = 0; // Will write LED low
  else if (req.indexOf("/led/1") != -1)
    val = 1; // Will write LED high
  else if (req.indexOf("/read") != -1)
    val = -2; // Will print pin reads
  // Otherwise request will be invalid. We'll say as much in HTML
  // Set GPIO5 according to the request
  if (val >= 0)
    digitalWrite(LED_PIN, val);

  client.flush();

  // Prepare the response. Start with the common header:
  String s = "HTTP/1.1 200 OK\r\n";
  s += "Content-Type: text/html\r\n\r\n";
  s += "<!DOCTYPE HTML>\r\n<html>\r\n";
  // If we're setting the LED, print out a message saying we did
  if (val >= 0)
  {
    s += "LED is now ";
    s += (val)?"on":"off";
  }
  else if (val == -2)
  { // If we're reading pins, print out those values:
    s += "Analog Pin = ";
    s += String(analogRead(ANALOG_PIN));
    s += "<br>";                                       // Go to the next line.
    s += "Digital Pin 12 = ";
    s += String(digitalRead(DIGITAL_PIN));
    s += "<br>";                                       // Go to the next line.
    s += "Humidity and Temperature";
    s += "<br>";                                       // Go to the next line.    
    s += "Humidity : ";
    s += String(latestHumidity);                       // Humidity
    s += "%";
    s += "<br>"; // Go to the next line.
    s += "Celsius: ";
    s += String(latestTempC);                          //  Temperature *C
    s += "*C";
    s += "<br>"; // Go to the next line.
    s += "Fahrenheit: ";
    s += String(latestTempF);                          // Temperature *F 
    s += "*F";        
  }
  else
  {
    s += "Invalid Request.<br> Try /led/1, /led/0, or /read.";
  }
  s += "</html>\n";

  // Send the response to the client
  client.print(s);
  delay(1);
  Serial.println("Client disonnected");

  // The client will actually be disconnected when the function returns and 'client' object is detroyed
  
}

getRHT.ino

// RHT03 Humidity and Temperature Sensor
void isRHT03(){

  // Call rht.update() to get new humidity and temperature values from the sensor.
  int updateRet = rht.update();

  // The humidity(), tempC(), and tempF() functions can be called -- after 
  // a successful update() -- to get the last humidity and temperature value 
  latestHumidity = rht.humidity();
  latestTempC = rht.tempC();
  latestTempF = rht.tempF();
  
}

setWiFi.ino

// WiFi
void setupWiFi()
{
  
  // WiFi mode WIFI_AP
  WiFi.mode(WIFI_AP);

  // Append the last two bytes of the MAC (HEX'd) to "Thing-":
  uint8_t mac[WL_MAC_ADDR_LENGTH];
  WiFi.softAPmacAddress(mac);
  String macID = String(mac[WL_MAC_ADDR_LENGTH - 2], HEX) +
                 String(mac[WL_MAC_ADDR_LENGTH - 1], HEX);
  macID.toUpperCase();
  String AP_NameString = "ESP8266 Thing " + macID;

  char AP_NameChar[AP_NameString.length() + 1];
  memset(AP_NameChar, 0, AP_NameString.length() + 1);

  for (int i=0; i<AP_NameString.length(); i++)
    AP_NameChar[i] = AP_NameString.charAt(i);

  WiFi.softAP(AP_NameChar, WiFiAPPSK);
  
}
// init Hardware
void initHardware()
{

  // Serial
  Serial.begin(115200);
  // LED Green
  pinMode(DIGITAL_PIN, INPUT_PULLUP);
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);
  // RHT03 Humidity and Temperature Sensor
  // Call rht.begin() to initialize the sensor and our data pin
  rht.begin(RHT03_DATA_PIN);
  
}

setup.ino

// Setup
void setup() 
{

  // Hardware
  initHardware();
  // WiFi
  setupWiFi();
  server.begin();
  
}

Don Luc

Project #10: ESP8266 Thing – Blink – Mk02

Soldering

Plated through-hole soldering (PTH), flux-core solder alloys commonly used for electrical soldering are 60/40 Sn-Pb used principally in electrical/electronic work and TENMA soldering station temperature controlled digital.

Hardware Assembly

We’re getting ahead of ourselves. To connect the FTDI programmer to your Thing you’ll need to solder something to the Thing. What, exactly, you solder to the board depends both on how you’ll use it in your project, and how you’ll interface it with the programmer. When it comes to selecting a header (or wire) to solder, there are a variety of options. We’ve tried a lot of them with the Thing:

Or you can mix and match headers to best fit your needs. Right-angle male headers may help to interface between the FTDI and the Thing. Straight male headers are a good choice for low-profile connections. Straight female headers may help with connecting to I2C sensors. And, of course, wire can be soldered to any of the pins that have a long way to connect to something.

10 pin – Break Away Headers – Straight
4 pin – Break Away Headers – Straight
6 pin – Break Away Male Headers – Right Angle

Once you’ve soldered up at least the programming port, you’re ready to load some code onto the Thing.

Programming the Thing

The ESP8266 has a built-in serial bootloader, which allows for easy programming and re-programming. You don’t need a specialized, expensive programmer – just a simple, USB-to-Serial converter. The FTDI Basic’s 6-pin header matches up exactly to the Thing’s 6-pin serial port header. To set up for programming, simply connect the FTDI directly to this port – take care to match up the DTR and GND pins.

Blink

Let’s blink some LEDs and IoT (Internet our Thing). To verify that everything works Blink: toggle pin 5, which is attached to the onboard LED Green, toggle pin 4 which is LED Green.

DonLuc1901Mk01

1 x SparkFun ESP8266 Thing
1 x SparkFun FTDI Basic Breakout – 3.3V
1 x LED Green
1 x 100 Ohm
4 x Jumper Wires 3″ M/M
1 x Full-Size Breadboard
1 x USB Cable A to Mini-B

SparkFun ESP8266 Thing

LG1 – Digital 5
LG2 – Digital 4
GND – GND
VIN – +3.3V

DonLuc1901Mk01p.ino

// ***** Don Luc Electronics *****
// Software Version Information
// Project #10: SparkFun ESP8266 Thing – Blink - Mk02
// 01-01
// DonLuc1901Mk01p.ino 01-01
// SparkFun ESP8266 Thing
// Blink

// Include Library Code

#define ESP8266_LED 5      // LED Green
int iLEDGreen = 4;         // LED Green

void loop() 
{

  // ESP8266_LED, iLEDGreen
  digitalWrite(ESP8266_LED, LOW);
  digitalWrite(iLEDGreen, LOW);
  delay(2000);
  digitalWrite(ESP8266_LED, HIGH);
  delay(2000);
  digitalWrite(ESP8266_LED, LOW);
  delay(2000);
  digitalWrite(iLEDGreen, HIGH);
  delay(2000);
  
}


setup.ino

// Setup
void setup() 
{

  // LED
  pinMode(ESP8266_LED, OUTPUT);                 // ESP8266_LED Green
  pinMode(iLEDGreen, OUTPUT);                   // LED Green
      
}

Don Luc

Project #10: SparkFun ESP8266 Thing – Mk01

Description

The SparkFun ESP8266 Thing is a breakout and development board for the ESP8266 WiFi SoC – a leading platform for Internet of Things (IoT) or WiFi-related projects. The Thing is low-cost and easy to use, and Arduino IDE integration can be achieved in just a few steps. We’ve made the ESP8266 easy to use by breaking out all of the module’s pins, adding a LiPo charger, power supply, and all of the other supporting circuitry it requires.

Why the name? We lovingly call it the “Thing” due to it being the perfect foundation for your Internet of Things project. The Thing does everything from turning on an LED to posting data with datastream, and can be programmed just like any microcontroller. You can even program the Thing through the Arduino IDE by installing the ESP8266 Arduino addon.

The SparkFun ESP8266 Thing is a relatively simple board. The pins are broken out to two parallel, breadboard-compatible rows. USB and LiPo connectors at the top of the board provide power – controlled by the nearby ON/OFF switch. LEDs towards the inside of the board indicate power, charge, and status of the IC. The ESP8266’s maximum voltage is 3.6V, so the Thing has an onboard 3.3V regulator to deliver a safe, consistent voltage to the IC. That means the ESP8266’s I/O pins also run at 3.3V, you’ll need to level shift any 5V signals running into the IC. A 3.3V FTDI Basic is required to program the SparkFun ESP8266 Thing, but other serial converters with 3.3V I/O levels should work just fine as well. The converter does need a DTR line in addition to the RX and TX pins.

Features

  • All module pins broken out
  • On-board LiPo charger/power supply
  • 802.11 b/g/n
  • Wi-Fi Direct (P2P), soft-AP
  • Integrated TCP/IP protocol stack
  • Integrated TR switch, balun, LNA, power amplifier and matching network
  • Integrated PLLs, regulators, DCXO and power management units
  • Integrated low power 32-bit CPU could be used as application processor
  • +19.5dBm output power in 802.11b mode

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

Propaganda Electronics

Electronics

Electronics has been linked to by thousands of schools and universities, professional associations and research organizations, reference sources and other information authorities, newspapers, magazines and other news services, and increasingly bloggers and social networking sites such as Facebook, Twitter, Google+, and LinkedIn. Electronics enjoys high rankings with popular web search engines such as Google and Yahoo for hundreds of electronically important keywords, including the word “electronics” for which the site comes up in typically the top three search results.

Propaganda

Propaganda is information that is not objective and is used primarily to influence an audience and further an agenda, often by presenting facts selectively to encourage a particular synthesis or perception, or using loaded language to produce an emotional rather than a rational response to the information that is presented. Propaganda is often associated with material prepared by governments, but activist groups, companies and the media can also produce propaganda.

In the twentieth century, the term propaganda has been associated with a manipulative approach, but propaganda historically was a neutral descriptive term. A wide range of materials and media are used for conveying propaganda messages, which changed as new technologies were invented, including paintings, cartoons, posters, pamphlets, films, radio shows, TV shows, and websites.

Advertising

Propaganda shares techniques with advertising and public relations, each of which can be thought of as propaganda that promotes a commercial product or shapes the perception of an organization, person, or brand.

Journalistic theory generally holds that news items should be objective, giving the reader an accurate background and analysis of the subject at hand. On the other hand, advertisements evolved from the traditional commercial advertisements to include also a new type in the form of paid articles or broadcasts disguised as news. These generally present an issue in a very subjective and often misleading light, primarily meant to persuade rather than inform. Normally they use only subtle propaganda techniques and not the more obvious ones used in traditional commercial advertisements.

If the reader believes that a paid advertisement is in fact a news item, the message the advertiser is trying to communicate will be more easily “believed” or “internalized”. Such advertisements are considered obvious examples of “covert” propaganda because they take on the appearance of objective information rather than the appearance of propaganda, which is misleading. Federal law specifically mandates that any advertisement appearing in the format of a news item must state that the item is in fact a paid advertisement.

Techniques

Common media for transmitting propaganda messages include news reports, government reports, historical revision, junk science, books, leaflets, movies, radio, television, and posters. Some propaganda campaigns follow a strategic transmission pattern to indoctrinate the target group. This may begin with a simple transmission, such as a leaflet or advertisement dropped from a plane or an advertisement.

Generally these messages will contain directions on how to obtain more information, via a web site, hot line, radio program, etc. (as it is seen also for selling purposes among other goals). The strategy intends to initiate the individual from information recipient to information seeker through reinforcement, and then from information seeker to opinion leader through indoctrination.

A number of techniques based in social psychological research are used to generate propaganda. Many of these same techniques can be found under logical fallacies, since propagandists use arguments that, while sometimes convincing, are not necessarily valid.

Some time has been spent analyzing the means by which the propaganda messages are transmitted. That work is important but it is clear that information dissemination strategies become propaganda strategies only when coupled with propagandistic messages. Identifying these messages is a necessary prerequisite to study the methods by which those messages are spread.

Identifying

1. Consider the source (to understand its mission and purpose)
2. Read beyond the headline (to understand the whole story)
3. Check the authors (to see if they are real and credible)
4. Assess the supporting sources (to ensure they support the claims)
5. Check the date of publication (to see if the story is relevant and up to date)
6. Review your own biases (to see if they are affecting your judgement)
7. Ask experts (to get confirmation from independent people with knowledge)

Fake Electronics

The counterfeit means to imitate something. Counterfeit products are fakes or unauthorized replicas of the real product. Counterfeit products are often produced with the intent to take advantage of the superior value of the imitated product. The word counterfeit frequently describes both pharmaceuticals, aviation and automobile parts, watches, electronics (both parts and finished products), software.

Counterfeit products tend to have fake have a reputation for being lower quality (sometimes not working at all) and may even include toxic elements such as lead. This has resulted in the deaths of hundreds of thousands of people, due to automobile and aviation accidents, poisoning, or ceasing to take essential compounds (e.g., in the case a person takes non-working medicine).

Well, here are several online portals offering best stuff on electronics. But you should bear in mind that all the providers are not safe and may be you will provide you best quality products but charge of the products are very high. And I will tell you the best websites where you can get the attire as per your taste, if you’re looking for cheaper purchases.

Think of all the popular hardware brands in technology right now. The Apple and Sony that have the distinct honor of being considered a luxury brand. Everyone wants one and anyone who’s anyone would buy and flaunt them to their peers, creating an appeal. Unfortunately, not everyone can afford them and that’s where knockoffs come to the rescue.

These knockoffs were made as a copy of the original, sometimes using the logo and design of the original. Sometimes they get it right and many might not notice. Often at times, they get it wrong. Very wrong, in fact, to the point of hilarity. Here of the most amusing knockoffs of popular tech brands that you may have seen.

From quirky gadgets to fab mobile phones, India, South Korea, Japan and China are famous for producing trend-setting technologies that often take years to find their way to the West. Turns out there are a number of websites selling ultra-cool Asian electronics internationally for you techies out there. We’ve created a list of what we think are some of the top Asian tech-selling sites.

Another wholesaler for quirky, cool fake electronics tech stuff, stocks mobile phones and laptops as well as less mainstream gadgets. Spy on neighbors with the digital surveillance pen featuring image capture and video recording. The extreme sports helmet camera will let you capture crazy want to show your friends.

Fake electronics is the infamous shopping site offering B2B sales. Businesses can connect directly with wholesalers and manufacturers in India, South Korea, Japan, China, Taiwan, Hong Kong, Malaysia or Singapore.

Don Luc

Consultant

A consultant is a professional who provides expert advice in a particular area such as security (electronic or physical), management, education, accountancy, law, human resources, marketing (and public relations), finance, engineering, science or any of many other specialized fields.

A consultant is usually an expert or an experienced professional in a specific field and has a wide knowledge of the subject matter. The role of consultant outside the medical sphere (where the term is used specifically for a grade of doctor) can fall under one of two general categories:

Internal consultant: someone who operates within an organization but is available to be consulted on areas of their specialization by other departments or individuals (acting as clients); or

External consultant: someone who is employed externally to the client (either by a consulting firm or some other agency) whose expertise is provided on a temporary basis, usually for a fee. Consulting firms range in size from sole proprietorships consisting of a single consultant, small businesses consisting of a small number of consultants, to mid- to large consulting firms, which in some cases are multinational corporations. This type of consultant generally engages with multiple and changing clients, which are typically companies, non-profit organizations, or governments.

By hiring a consultant, clients have access to deeper levels of expertise than would be financially feasible for them to retain in-house on a long-term basis. Moreover, clients can control their expenditures on consulting services by only purchasing as much services from the outside consultant as desired.

Consultants provide their advice to their clients in a variety of forms. Reports and presentations are often used. However, in some specialized fields, the consultant may develop customized software or other products for the client. Depending on the nature of the consulting services and the wishes of the client, the advice from the consultant may be made public, by placing the report or presentation online, or the advice may be kept confidential, and only given to the senior executives of the organization paying for the consulting services.

Why be a consultant?

There are many reasons why one would want to become a consultant.

Some would love to ditch their corporate jobs and be lured to become self-employed. After being self-employed all of my adult life I would not know what to recommend to those as I do not know any other way. I know that my wife Norma had problems getting adapted to the consultant way, as she had the opposite experience of being employed all of her adult life by banks or investment firm. Being self-employed to her was very traumatic at first, and still is when business slows down.

Leaving the security of a good job is very hard to do, especially if you are used to have and count on a regular income. It becomes very difficult to plan things like mortgages and car loans or other regular types of expenses, when you are never sure of exactly of what your income will be next month. For some this is something they cannot live with, and to others like me, it is something so normal that you never really think about it. You just have to be very careful with your expenses and plan your life and budget accordingly. Those who cannot live with that kind of uncertainty should no even think of being a consultant or to be self-employed for that matter.

Other people would love to work at home like a lot of us do. For that too you need to have a certain sense of organization to be able to do it without all the normal distractions around the house preventing you from doing any works. It all depends on how well organized you are and how you can isolate yourself from other things and concentrate on your work. Most people find it difficult at first, but get used to it with time. For those who can’t it might be better to think about working for some consulting firm that will place you at their client’s site.

Others are lured by the large fees that some consultants charge. This might look very tempting at first glance, but when you start analyzing it in depth once you take this high fee, deduct from it your operating expenses, the equipment, tools and software you might need to perform your consulting, publicity, legal and accounting fees, office expenses, and the fact that you are rarely billing the full time you are working each week, you might not be making a huge amount more than you are doing right now at your current job. Add to that all of those other things that you never think of, like the fact that normally when you are on your own you do not have the niceties of things like health and other types of insurance, retirement plans, benefits and more.

Does that mean that you should not become a consultant? Of course not! If you can live with all of the above and more and have the personality to enjoy those kinds of challenges and live your life differently than most of your neighbors and friends, consulting is an immensely rewarding profession that can offer you things that you would never have the chance of experiencing otherwise. I would not even dream of doing something else and if I have not become a consultant so long ago I would never had the life and the experiences I have had. Sure, it can be very hard at times, all the good things in life are hard to achieve, but the rewards are huge for those who like a challenge and can focus to achieve their goals.

What type of consultant am I?

There are many ways of defining oneself as a consultant. The traditional consultant is normally somebody who is an expert in his field with either a long career behind him or very specific specialized knowledge that is not common in a field. He is hired to resolve specific issues by clients or “consulted” when his client need information on some topic that they are an expert.

The term is also used for people who do contract work in a specific field. They usually work one contract at a time and they will build something, or deliver a project for their client. This used to be called a contractor, but these days the definition is getting fuzzier as a lot of “Consulting” firms are normally placing “Contractors” at their client’s sites and calling them “Consultants”.

More and more self-employed workers, or workers moonlighting in their spare times are now calling themselves “Consultants” though they might not be doing much actual consulting or contracting work.

This confuses a lot of people looking to hire external resources as a lot of people are calling themselves “Consultants” and actually offer a wide variety of services only some of which are actual consulting. It is a good thing for people who which to hire external help, consultant or other, to make sure before they start looking that they know what kind of help they are looking for.

Coming back to the main topic of this post. I started in the mid 1980’s as a traditional consultant in the food and wine business. My various clients hired me for my specialized knowledge and consulted me on various topics and I would also do specific contracts for them on a regular basis like travel to various places worldwide to purchase various things for them or just analyze what was available in the market. I started during that period doing consulting work in computer graphics and animation which was a new field in those days and then I started to consult more and more about IT using the knowledge I had as I trained as a mainframe programmer at university ten years earlier.

In the early 1990’s I was doing more and more IT consulting for local clients and prior to the advent of the Internet, in the old days of the original CompuServe network of which I had been a member since around 1986, I started consulting with many clients worldwide from my office at the edge of a lake in Northern Quebec. I also started doing more and more contracting for various large companies in the United States and elsewhere. I spent most of the 1990’s traveling over 6 months of the year to work onsite with many clients worldwide. The rest of the year was spent either consulting or contracting, as I do differentiate, for my clients from my office in Quebec.

In the late 1990’s during the time of the big Internet crash, I started developing my own line of software products for retail business management, point of sales, ticketing systems, kiosk systems, and decision support systems. In 2003 I moved to Mexico City to promote some of my products and to get away from the cold of Quebec as my Mexican wife was feeling somewhat unaccustomed to the long winters and isolated over there.

Today I am back to being a traditional consultant full time, though I still work regularly on my software products and actively promote and find new markets for them. I continue my IT consulting as always and consult with businesses looking for new markets or with startups looking for advice. I also do contract work developing innovative software, integrate software with hardware, and of course I still do consult in the food and wine industry, my first love.

My motto has always been since I was a kid that I need to learn something new every single day as if I do not that day is wasted. Since I have been in the consulting business for so long, and tried hard to not waste any day of it, I have accumulated a lot of knowledge over the years. This is why for many years now that I love to teach and give conferences to pass this knowledge to others. I tend to be very passionate about this, as I have always love to educate people and convince them that they should learn something new every day. My wife Norma always says that I should have been a preacher, but what I am really is a traditional consultant that likes to share is experience and knowledge with others.

Common Types Don Luc

Information-Technology (IT) Consultants in many disciplines such as computer hardware, software engineering, or networks.

Process Consultants who are specialists in the design or improvement of operational processes and can be specific to the industry or sector.

3D Consultants who are specialists in the field of 3D scanning, printing, modeling, designing, engineering, building, and everything that has to do with the three dimensions.

Internet Consultants who are specialists in business use of the internet and keep themselves up-to-date with new and changed capabilities offered by the web. Ideally internet consultants also have practical experience and expertise in management skills such as strategic planning, change, projects, processes, training, team-working and customer satisfaction.

Specialties Don Luc:

IT and Technology Consulting
IT Project Feasibility Studies
IT Project Management
3D Consultants
Custom Software Programming (Desktop, Web and Mobile)
Microcontroller programming
Software Internationalization and Localization
Hardware-Software Integration Consulting
Factory and Process Automation Consulting
Robotics Consulting
Custom Electronic Hardware Design and Sourcing
R&D Services

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

Project #7: RGB LCD Shield – Seven-Segment Display – Mk06

Seven-Segment Display

A seven-segment display (SSD), or seven-segment indicator, is a form of electronic display device for displaying decimal numerals that is an alternative to the more complex dot matrix displays.

Seven-segment displays are widely used in digital clocks, electronic meters, basic calculators, and other electronic devices that display numerical information.

Your basic 7-segment LED. Common anode. Two decimal points, but only the one on the right is wired. Digit height is 0.6″. Overall height is 1″.

Common Cathode

In a common-cathode display, the positive terminal of all the eight LEDs are connected together and then connected to iSeven2 and iSeven8. To turn on an individual segment, you ground one of the pins. The following diagram shows the internal structure of the common-cathode seven-segment display.

The internal structure of both types is nearly the same. The difference is the polarity of the LEDs and common terminal. In a common cathode seven-segment display, all seven LEDs plus a dot LED have the cathodes connected To use this display, we need to connect VIN to make the individual segments light up. The following diagram shows the internal structure of common-cathode seven-segment display.

If your Arduino application only needs to display numbers, consider using a seven-segment display. The severn-segment display has seven LEDs arranged in the shape of number eight. They are easy to use and cost effective. The picture below shows a typical seven-segment display.

DonLuc1807Mk10

1 x RGB LCD Shield 16×2 Character Display
1 x Arduino UNO – R3
1 x ProtoScrewShield
1 x Seven-Segment Display Red
7 x 220 ohm resistor
4 x Jumper Wires 3″ M/M
8 x Jumper Wires 6″ M/M
1 x Half-Size Breadboard

Arduino UNO

7S8 – Digital 8
7S7 – Digital 7
7S6 – Digital 6
7S5 – Digital 5
7S4 – Digital 4
7S3 – Digital 3
7S2 – Digital 2
VIN – +5V

DonLuc1807Mk10p.ino

// ***** Don Luc *****
// Software Version Information
// Project #7: RGB LCD Shield – Seven-Segment Display – Mk06
// 7-10
// DonLuc1807Mk10p 7-10
// RGB LCD Shield
// Seven-Segment Display

// include the library code:
#include <Adafruit_MCP23017.h>
#include <Adafruit_RGBLCDShield.h>

Adafruit_RGBLCDShield RGBLCDShield = Adafruit_RGBLCDShield();
#define GREEN 0x2

// Seven-Segment Display
int iSeven2 = 2;     // iSeven2
int iSeven3 = 3;     // iSeven3
int iSeven4 = 4;     // iSeven4
int iSeven5 = 5;     // iSeven5
int iSeven6 = 6;     // iSeven6
int iSeven7 = 7;     // iSeven7
int iSeven8 = 8;     // iSeven8

void loop() 
{

  // Seven-Segment Display
  isSeven();
  
  // Clear
  RGBLCDShield.clear();
  
}

getSeven.ino

// Seven-Segment Display
void isSeven()
{

  // Display
  // Set the cursor to column 0, line 0  
  RGBLCDShield.setCursor(0,0);
  RGBLCDShield.print("Seven-Segment");          // Seven-Segment Display
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven2 +    ");          // iSeven2 +
  digitalWrite(iSeven2, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven2 -      ");        // iSeven2 -

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven3 +    ");          // iSeven3 +
  digitalWrite(iSeven3, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven3 -      ");        // iSeven3 -

  delay(2000);
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven4 +   ");           // iSeven4 +
  digitalWrite(iSeven4, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven4 -      ");        // iSeven4 -

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven5 +   ");           // iSeven5 +
  digitalWrite(iSeven5, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven5 -      ");        // iSeven5 -  

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven6 +   ");           // iSeven6 +
  digitalWrite(iSeven6, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven6 -      ");        // iSeven6 -

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven7 +   ");           // iSeven7 +
  digitalWrite(iSeven7, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven7 -      ");        // iSeven7 -

  delay(2000);
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven8 +   ");           // iSeven8 +
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("iSeven8 -      ");        // iSeven8 -

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 0    ");           // iSeven 0
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven6, LOW);
  digitalWrite(iSeven7, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 1    ");           // iSeven 1
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 2    ");           // iSeven 2
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven6, LOW);
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 3    ");           // iSeven 3
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 4    ");           // iSeven 4
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven7, LOW);
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 5    ");           // iSeven 5
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven7, LOW);
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 6    ");           // iSeven 6
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven6, LOW);
  digitalWrite(iSeven7, LOW);
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 7    ");           // iSeven 7
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 8    ");           // iSeven 8
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven6, LOW);
  digitalWrite(iSeven7, LOW);
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1); 
  RGBLCDShield.print("iSeven 9    ");           // iSeven 9
  digitalWrite(iSeven2, LOW);
  digitalWrite(iSeven3, LOW);
  digitalWrite(iSeven4, LOW);
  digitalWrite(iSeven5, LOW);  
  digitalWrite(iSeven7, LOW);
  digitalWrite(iSeven8, LOW);
  
  delay(5000);

  // Seven - Off
  isSevOff();
  
  // Set the cursor to column 0, line 1
  RGBLCDShield.setCursor(0, 1);
  RGBLCDShield.print("Seven - Off    ");        // Seven - Off

  delay(2000);

}

// Seven - Off
void isSevOff()
{

  // Seven - Off
  digitalWrite(iSeven2, HIGH);
  digitalWrite(iSeven3, HIGH);
  digitalWrite(iSeven4, HIGH);
  digitalWrite(iSeven5, HIGH);  
  digitalWrite(iSeven6, HIGH);
  digitalWrite(iSeven7, HIGH);
  digitalWrite(iSeven8, HIGH);
  
}

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("Seven-Segment");     // Seven-Segment Display
  delay(5000);

  // Clear
  RGBLCDShield.clear();

  // Seven-Segment Display
  pinMode(iSeven2, OUTPUT);                // iSeven2
  pinMode(iSeven3, OUTPUT);                // iSeven3
  pinMode(iSeven4, OUTPUT);                // iSeven4
  pinMode(iSeven5, OUTPUT);                // iSeven5
  pinMode(iSeven6, OUTPUT);                // iSeven6
  pinMode(iSeven7, OUTPUT);                // iSeven7
  pinMode(iSeven8, OUTPUT);                // iSeven8
        
  isSevOff();                              // Seven - Off
  
}

Don Luc