The Edwin Robotics DRV8833 breakout board is capable of controlling up to 2 DC motors or one bi/uni-polar stepper motor a max current of 1.2A. The DRV8833 comes with 2 full H-bridges which give bi-directional control of your DC motors. It is similar to the L9110S in its voltage range ( 2.7V – 10.8V), but carrying 50% more oomph. This makes it ideal for projects where the motors will be run from a 9V battery.

The board can be powered using the provided screw terminals or through micro-USB, checkout out micro-USB to DC Jack adapter if you would like to use a standard power adapter with the board

 Hardware Required

Edwin Robotics DRV8833 Motor Driver	Arduino UNO	Male-Female Jumper wires
DC Geared Motor with Wheel	9V DC Battery Snapper	microUSB to DC Jack Female Connector

Features

• Dual-H-bridge motor driver: can drive two DC motors or one uni/bi-polar stepper motor
• Operating voltage: 2.7‌‌ V to 10.8 V
• Output current: 1.2 A continuous (2 A peak) per motor
• Motor outputs can be paralleled to deliver 2.4 A continuous (4 A peak) to a single motor
• Inputs are 3V- and 5V-compatible
• Under-voltage lockout and protection against over-current and over-temperature
• Reverse-voltage protection circuit
• Current limiting can be enabled by adding sense resistors (not included)

Pinouts:

DRV8833 Motor driver pin description

 

Power

• Vm – This is the voltage supply for the motors. Keep this voltage between 2.7V and 10.8V. This Supply Pin is not Reverse polarity protected, so care must be taken while connecting jumper wires to it.
• Power Screw Terminal: The Power Screw terminal is labelled with + and -, connect your power supply according to label, this terminal is reverse polarity protected.
• USB Power In: You can power the board with micro USB connector provided; this is reverse polarity protected as well.
• GND – This is the shared logic and motor ground. All grounds are connected

Current Limiting Pins

As/ Bs: The DRV8833 can perform current limiting for each motor H-bridge by connecting a resistor between As/Bs and ground to set the Motor A/ Motor B Limit.

By default , the current limiting feature is disabled and can be enabled by modifying the jumper, refer the image below:

Current Limiting and Status LED’s Jumper Pads.

The Current limiting can be enabled by cutting out the solder joint between the jumper Pads for Asen and Bsen. Once the jumper pads are modified you can either solder SMD resistor (1206 Size) on board or you can use the AS/BS headers pin to make connection with through hole resistors. You can also totally disable current limiting whenever needed by soldering the two jumpers on the back.

The current limiting rule is: LimitCurrent (amps) = 0.2 V / RSENSE

Add 1206 resistors here to modify the current supplied to the respective motors

 

Connection’s

You can use any stepper motor or dc motor rated upto 10.8v with this board. We have used the following kit to get it tested:

Robotics Kit

 

 Refer the image below for the motor connections

Motor Connections

Power Supply Connections

Arduino DRV8833 Connections

Test Codes

#define Ain1 5
#define Ain2 6
#define Bin1 9
#define Bin2 10

int speed = 0;

void setup() {
pinMode(Ain1, OUTPUT);  //Ain1
pinMode(Ain2, OUTPUT);  //Ain2
pinMode(Bin1, OUTPUT);  //Bin1
pinMode(Bin2, OUTPUT);  //Bin2

}

void loop() {

    digitalWrite(Ain1,HIGH);
    digitalWrite(Ain2,LOW);
    digitalWrite(Bin1,HIGH);
    digitalWrite(Bin2,LOW);
    delay(700);
    digitalWrite(Ain1,LOW);
    digitalWrite(Ain2,LOW);
    digitalWrite(Bin1,LOW);
    digitalWrite(Bin2,LOW);

    digitalWrite(Ain1,LOW);
    digitalWrite(Ain2,HIGH);
    digitalWrite(Bin1,LOW);
    digitalWrite(Bin2,HIGH);
    delay(700);
    digitalWrite(Ain1,LOW);
    digitalWrite(Ain2,LOW);
    digitalWrite(Bin1,LOW);
    digitalWrite(Bin2,LOW);
  
}

Download DRV8833 Datasheet

References:

Adafruit Hookup Guide

Polulu Blog

Welcome to our Getting started guide on ESP-WROOM-02 board. We had already introduced this board in our previous guide Introduction to ESP8266, there we had mentioned about the ESP-WROOM-02 adapter board as well. Here in this blog, we are using ESP-WROOM-02 with Adapter board, since using the adapter board will give us the flexibility to build and test circuit on a breadboard. Let us have a look at the list of items we needed for getting started with ESP-WROOM-02.

Hardware Needed:

ESP-WROOM-02 Board	Breadboard	3.3V Voltage Regulator	1K Resistors
100uf Electrolytic Capacitor	7mm Tactile Switch	5V Power Adapter	10k Resistor
5mm LED	Mini USB Cable	USB to Serial Converter	Jumper Wires
3.3uf Electrolytic Capacitor	Breadboard Power Supply	Micro USB Pin Breakout Board	0.1uf Ceramic Capacitor

You do not need all the above mentioned hardware, some of them are optional, which we had mentioned in details in various sections below.

ESP-WROOM-02 Pinouts:

It is always important to understand the board which you are working with, is capable of what all stuffs, for this we had added a graphical pinouts and description below:

ESP-Wroom-02 Graphical Description

Circuit Schematics:

The ESP-WROOM-02 boards needs few external components to get it working, we had a schematics for ESP-WROOM-02 board below:

Circuit Schematics

Now, if you notice in the schematics, we had added pullup resistors on most of the communication lines, if you are not using those pins, you can ignore those resistors. But the resistors on following lines are must to get it working, i.e GPIO0, reset and enable.

Note: The power Supply schematics is not included in the above circuit.

The power supply to the circuit must be 3.3v and you can use any option to power the circuit, like using breadboard power supply(listed in the hardware needed section) and 9v battery or you can power the board directly from USB to serial converter, make sure that converter must be 3.3v logic ones and it is capable enough to supply minimum of 500mA. We tried to power the system from Sparkfun basic 3.3v FTDI converter but we had faced issue several times, if you are looking to power from converter only, we will recommend you to use the Sparkfun beefy FTDI board. We had used 5v Power Adapter and a 3.3V voltage regulator setup on breadboard to power the system, We had added the 3.3V voltage regulator Schematics below:

3.3V Voltage Regulator Schematics

The voltage Regulator Part is really Simple, if you seen the schematics, you can notice that, we used 4 capacitor in the circuit, Cout capacitor can be replaced with 3.3uF Capacitor or some other higher value than 10uF if you have. We supplied Vin from the 5v USB power Adapter (Refer the hardware needed section), we used the Micro USB Breakout Board (Refer the hardware needed section) to breakout the power lines from USB adapter, you can use your phone chargers as well,if you have these breakout board with you.

Make sure you use the proper pins of the voltage regulator while assembling your circuit. Refer the LD33V pinouts below:

LD33V Pinouts

Now, its time to assemble all this circuit into a breadboard, make sure you follow the connections, as shown, otherwise, your circuit might not work.

Assemble the Circuit on a Breadboard:

The first thing in the breadboarding is always begin with Power supply, if you are using breadboard Power Supply module (Refer the hardware needed section)  then you do not have to worry much, all you need is battery with DC Jack Male Connector or you might have power adapter with DC Male Jack on it, use it and you are ready to go. Refer the below diagram for using a breadboard power supply.

Breadboard Power Supply

But we are using Voltage regulator to build our own power supply and which we can use to fed power from standard micro USB power adapter/ Mobile Charger. Refer the Power Supply section below for better idea on this.

3.3V Breadbord Power Supply

Note: If you are using some other voltage regulator than what we mentioned, then make sure that you cross check the pinouts and connect accordingly. Refer the hardware needed section for the USB Breakout Board which you can use.

Once the power supply is done, now we will assemble the circuit for ESP-WROOM-02 Board as shown in the schematics above.

ESP-WROOM-02 Breadboard Arrangement

Now you are all done with connections, now its time to upload the code, now for this you need a USB to Serial Converter to establish a Serial communication between the WROOM board and the computer. We used the sparkfun basic ftdi board to made it work, you can use any 3.3V logic converter to do the serial communication, just make sure to make the proper connection with this WROOM board. For this we had added a simple graphical representation, where you need to make the connections, refer the image below:

ESP-WROOM-02 Serial Communication

As you can see that it is clearly labeled which connection will go where into this breadboard, all you need to do is connect jumper wires to your Serial Converter and connect it exactly at the same position, i.e RX,TX and GND , these three lines are required. There is no need to cross connect the RX TX line, since it is already been take care of while labeling, just connect straight away the converter TX pin to WROOM pin 11 and Converter RX pin to WROOM pin 12 and common ground is must between the circuits. Lets begin with programming the WROOM board.

Uploading first Program

Step 1: Put the WROOM Board in Program Download Mode:

Since you are ready with hardware, its time to put the WROOM board into UART Download mode,to do so, all you need to do is:

1. Press both the RESET button and PROGRAM Button together.
2. Leave the RESET button alone and keep Pressing the PROGRAM button for 1 more second.
3. Leave the PROGRAM Button, now you are in UART Download mode.

So every time, when you need to upload the code, you have to do this before uploading, this is because the “auto Program” is not implemented in the circuit we built. To do so you need to add some transistors and you need to make some more connections from the Serial Converter board, this feature is not covered in this tutorial. Refer the Reset and Program Switch in the above image.

Step 2: Set proper serial port and board in the Arduino

Once the board is in download mode. You need to Open the Arduino and install the ESP8266 Core for the Arduino, if you have this in Arduino, you can ignore this. If you don’t have any ESP8266 board present in you Arduino. You need to do the following :

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Add the above mentioned line to Arduino: File -> Preferences -> Additional Board Managers URL

If there is an entry already, add the line by inserting a comma. If you need more instruction visit this github page.

Restart the Arduino after above step and open the boards manager from tools -> boards option and install the ESP8266 Core to the boards, after installation ,restart the Arduino again and you will see a set of ESP8266 boards as follows:

ESP8266 Boards

Now if you see we had selected the board option as ThaiEasyElec’s ESPino , we tried out other boards as well and we did not had any issue with other boards as well. The common setting for most of the board is to set the frequency to 80Mhz, you can overclock the board if needed. Flash Size if available set to 2M, else leave it to defualt option. The WROOM board comes with 2MB SPI Flash with four supported SPI modes: Standard SPI, DIO (Dual I/O), DOUT (Dual Output), QIO (Quad I/O) and QOUT (Quad Output).

Refer the latest WROOM Board Datasheet here

Once the Clock and Flash is set, select the proper serial port and you are ready to upload the code.

Step 3: Upload the first program

Since you are done with everything, lets begin uploading the first code. Refer the image below:

Example Program

Upload the following code from File -> Examples -> ESP8266 -> Blink

/*
 ESP8266 Blink by Simon Peter
 Blink the blue LED on the ESP-01 module
 This example code is in the public domain
 
 The blue LED on the ESP-01 module is connected to GPIO1 
 (which is also the TXD pin; so we cannot use Serial.print() at the same time)
 
 Note that this sketch uses LED_BUILTIN to find the pin with the internal LED
*/

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output
}

// the loop function runs over and over again forever
void loop() {
  digitalWrite(LED_BUILTIN, LOW);   // Turn the LED on (Note that LOW is the voltage level
                                    // but actually the LED is on; this is because 
                                    // it is acive low on the ESP-01)
  delay(1000);                      // Wait for a second
  digitalWrite(LED_BUILTIN, HIGH);  // Turn the LED off by making the voltage HIGH
  delay(2000);                      // Wait for two seconds (to demonstrate the active low LED)
}

Note: Make Sure the converter is connected and board is in program Download Mode.

Once uploaded you can see that the LED connected in the GPIO Pin 16 will start blinking. The LED_BUILTIN is defined different to other boards but for ThaiEasyElec’s ESPino board, the LED_BUILTIN is set to GPIO 16, if you still feel doubtful we will recommend you to initialize pin numbers manually with pinMode(Pin_number, INPUT/OUTPUT);

Note: If you are not able to get any blinking, try the serial window debugging and if you are getting any WDT(Watchdog Timer) related issues, try changing the power supply, since the WROOM board needs a stable power supply.

Hope you enjoyed this getting started tutorial, now its your turn to build some cool IoT Projects with this cheap and tiny little board. Do let us know, what you build with this little beast. We are happy to help if you found yourself in some sort of trouble.

This quick guide will give you idea about ESP8266 and some boards based on it. The ESP8266 (presently ESP8266EX), it is a chip with which manufacturers are making wirelessly networkable micro-controller modules. More specifically, ESP8266 is a system-on-a-chip (SoC) with capabilities for 2.4 GHz Wi-Fi (802.11 b/g/n), general-purpose input/output, Inter-Integrated Circuit (I²C), analog-to-digital conversion (10-bit ADC), Serial Peripheral Interface (SPI), I²S interfaces with DMA (sharing pins with GPIO), UART and pulse-width modulation (PWM). It employs a 32-bit RISC CPU based on the Tensilica Xtensa LX106 running at 80 MHz (or overclocked to 160 MHz). It has a 64 KB boot ROM, 64 KB instruction RAM and 96 KB data RAM. External flash memory can be accessed through SPI.

The ESP8266 is an amazing chip for all your home automation & Internet of Things projects. This chip costs less and has WiFi connectivity and is compatible with the Arduino IDE.Various vendors have consequently created modules containing the ESP8266 chip at their cores. Some of these modules have specific identifiers, like “ESP-01” through “ESP-13”. ESP8266-based modules have demonstrated themselves as a capable, low-cost, networkable foundation for facilitating end-point IoT developments. Espressif’s official module is presently the ESP-WROOM-02. The AI-Thinker modules are labeled ESP-01 through ESP-13. NodeMCU boards extend upon the AI-Thinker modules. Olimex, Adafruit, Sparkfun, WeMos, ESPert (ESPresso) all make various modules as well. See this ESP8266 article for more information about popular ESP8266 modules. There are many choices available in the market, and it is easy to get lost between all of them. we do have a bunch of them in our store, check out our ESP8266 boards collection.

First, We would like to show you the basic ESP8266 module, i.e ESP-01

ESP-01 Module

ESP-01

This is the first module that came out on the market. It is the cheapest and nearly the smallest module available. It is perfectly usable with the Arduino IDE for example.However, it comes with serious disadvantages. First, you can’t plug it into a breadboard without an adapter or you need to use jumper wires. Then, you don’t have access to all the input/output pins of the ESP8266 chip, which is a problem if you have complex projects that you want to build. However, for simple projects, this is a good module to start with.

Have a look at the pinouts:

ESP-01 Pinouts

ESP-WROOM-02 Module

ESP-WROOM-02 is a low-power 32-bit MCU Wi-Fi module, based on the ESP8266 chip. TCP/IP network stacks, 10-bit ADC, and HSPI/UART/PWM/I2C/I2S interfaces are all embedded in this module.It uses a 2 MB SPI flash connected to HSPI, working as the SDIO/SPI slave with the SPI speed of up to 8 Mbps. This module can be easily integrated into space-limited devices, due to its small size of only 18mm x 20mm x 3mm.

ESP-WROOM-02

This official WROOM board is perfect option if you are planning to build something using ESP8266 Core. This module has most of the things built in, you just needs few external components to get it working. The Board comes in SMD package, thus saving the space on the mother board. Due to its tiny size its perfect for IoT applications. Following pins are accessible on the WROOM board:

ESP-WROOM-02 Pinouts

But it is very difficult to start using ESP-WROOM-02 PCB without any soldering, thus we are offering a presoldered ESP-WROOM-02 Adapter board in out store.Have a look at the adapter board below:

ESP-WROOM-02 with Adapter Baord

ESP-WROOM-02 Board with Adapter

This board is perfect to use with breadboard, you do not need any soldering, it will sit easily on the breadboard. This board will also give you the option to solder the board easily to proto boards, without any complication. The adapter board dimensions will be 25.5mm x 26mm.

We do have different types of ESP8266 boards from different manufacturers which uses ESP8266 as it core. The difference in these boards is that every manufacturer will add their own peripherals and their own standard pinouts, even some boards comes with onboard USB to Serial Converter, so it will be very easy to program those board. Have a look at the ESP8266 Boards we having with us.Below we had added the Summary table for ESP8266 modules, to get better idea and see the difference between them:

Hope things are more clear to you now, before we finish with this blog, have a look at variety of projects and tutorials based on the ESP8266 boards we had added in our blog.

Want to check if you left your lights ON remotely, need to detect the zero crossing point for your dimming circuit or do you just need to interface a 230V signal to your Arduino? The AC Mains Detector board simplifies interfacing high voltage signals by giving a digital output when an AC voltage is detected. By disabling the on board capacitor, zero crossing detection is possible as well.

AC Line detection Module

You can buy this item from the following links:

Within GCC: Edwin Robotics

International Order: Tindie

Let us have a look at the guide contents, refer to the list below:

• Components

• Board Pinouts

• Circuit Schematics

• Interfacing with Arduino

• Zero Crossing detection using Arduino

Components

AC Line detection Module

Arduino UNO

Male-Female Jumper wires

Board Pinouts

Top Side

Bottom Side

• AC-IN – Connect the AC line that needs to be detected here.
• – (negative sign) – Connect to ground of microcontroller
• + (positive sign) – Connect to VCC of microcontroller in case external pull-up is required
• S – Connect to a digital/interrupt pin of microcontroller

Note: Working with AC voltages is DANGEROUS, care must be taken to prevent any short circuits or mistakes in connection. And as always, you are doing this project at your own risk and Edwin Robotics or the Author cannot be held liable for any damages.

Circuit Schematics

The circuit consists of two main parts, first is the Bridge Rectifier (DB107) which converts the AC signal to DC and the second is the Optocoupler (LTV816), which provides isolation between High voltage(HV) side and Low Voltage (LV) Side.

A pull-up resistor is provided for use with microcontrollers (e.g. ESP8266) that do not have an internal pullup resistor.

Interfacing with Arduino

The hardware connections are pretty straightforward. On the low voltage side the + (positive symbol) goes to VCC of microcontroller, – (negative symbol) goes to GND and S goes any digital/interrupt pin. On the high voltage side, the AC lines are connected.

Arduino Connections

In this example, Pin 2 on the arduino is used in this example as it can be used as an interrupt pin as well.

Sample Code:

#define Signal_Pin 2  // Modify this pin as per your connection

void setup() {
  pinMode(Signal_Pin , INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  if ( digitalRead(Signal_Pin) == 0 )
    Serial.println (" AC Mains 230v Detected ");
}

Note: Do not touch the PCB once powered, you can get electrocuted. Keep it away from reach of humans/Animals. Make sure that there are no shorted wires, when connecting the 230v AC mains supply.

Zero Crossing Detection using Arduino

By default zero crossing detection is disabled by the use of a 2.2uF capacitor, in order to use the board for zero crossing detection the capacitor needs to be bypassed by cutting the trace shown below. It can be resoldered at any time later to disable zero crossing:

Modify the jumper

The Arduino connection will be same as before, upload the following code and view the output on Serial Monitor at 9600 baud rate:

#define Signal_Pin 2 //Use Arduino Pin 2 or pin 3, both supports hardware interrupt
int counter=0;

void setup()
{
  pinMode(Signal_Pin , INPUT_PULLUP);
  Serial.begin(9600);
  attachInterrupt(0, zero_crosss_int, RISING);  // Choose the zero cross interrupt # from the table above
}

void zero_crosss_int()  // function to be fired at the zero crossing to dim the light
{
  counter++;
}

void loop()
{
  Serial.println(counter);
}

You can see that the counter value increases with every cycle of AC line and the moment you turn off the AC line, the counter Stops as well.

References:

• DB107 Rectifier Datasheet
• LTV-816 Datasheet

Now a days we have seen lots of devices are available in the market which can be controlled over the internet either using web browser or using mobile application. This project is all about controlling the Power socket over internet using web browser. We had used ESP8266 Thing in this Project, since it will give you the flexibility to make a flexible product with internet connectivity using the wifi. Particle photon is another option to be used in this project and it will give great advantage over ESP8266 Thing that, you can flash the code over the internet without bothering about where the product is. Now we will show you how to build your own eSocket.

• Parts Needed
• ESP8266 Thing 
• Circuit Integration
• Source Code

Parts Needed

• ESP8266 Thing
• FTDI Basic USB to Serial Converter
• Relay
• ULN2803
• Power Supply 5v
• Power Supply 12v

ESP8266 Thing

The ESP8266 is a low-cost Wi-Fi chip with full TCP/IP stack and Microcontroller capability produced by Shanghai-based Chinese manufacturer, Espressif. There are many third party modules With ESP8266 available in the market and you can decide which one suits best for your application, we are using the Sprakfun ESP8266 Thing in this tutorial.

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. These are some features of the board:

ESP8266 Thing 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
• Arduino IDE integration
• Breadboard Compatible Breakout Headers position
• Power On-Off Switch
• Status LED
• Operating Voltage: 3.3v

Refer the Graphical Datasheet for hardware description

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.

We use a 3.3V FTDI Basic to program the Thing, but other serial converters with 3.3V I/O levels should work. The converter does need a DTR line in addition to the RX and TX pins.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!

Note: While programming the Thing, it’s best to power it off USB. We’ve noticed programming is more likely to fail if the Thing is only powered via the battery.

Going further we need to interface relay with ESP8266 Thing, since we need to control the power socket, the relay we used in this project is of Industrial grade 10A, 250vAC rated and Coil Supply with 12v DC control voltage, you can use any other relay as per your convenience. Our ESP8266 Thing runs on 3.3v control logic, thus we are not able to straight away control the relay from ESP8266 IO Pins, we used ULN2803 Darlington array IC as relay driver, this IC is easily available in the market and can be used to control 8 relays at a time, since we need to interface just one relay to control the socket, we used only one channel of the IC.

Relay

Specifications:

• DPDT
• Mini Middle Electromagnetic Relay
• 8Pins 2NO+2NC
• Current:10A
• contacts:silver plated gold
• LED color:green
• Terminal form:socket type
• LED voltage: AC220/240V
• 12V DC voltage Controlled
• Secondary Side: 10A/240vAC, 10A/28vDC

The relay base module is separate part and needs to be purchased separately, its is rated for 15A, 250v AC, all the pin marking are made on the base itself thus connection is really simple, just refer the schematic shown on the relay body itself.

ULN2803

The ULN2803A device is a high-voltage, high-curren Darlington transistor array. The device consists of eight NPN Darlington pairs that feature high-voltage outputs with common-cathode clamp diodes for switching inductive loads. The collector-current rating of each Darlington pair is 500 mA. The Darlington pairs may be connected in parallel for higher current Types of Logic capability.

Features:

• 500-mA-Rated Collector Current (Single Output).
• High-Voltage Outputs: 50 V
• Output Clamp Diodes
• Inputs Compatible with Various types of Logic
• Relay-Driver Applications
• Compatible with ULN2800A Series

Simplified Schematics:

Pin Diagram:

Connections with ULN2803 are really simple, the channel mentioned with 1B , 2B, …, 8B all are inputs and you can pass on your logic control voltage from microcontroller to these pins, its 3.3v/5v Compatible. The corresponding inverted out will be present on the other side i.e 1C,2C,…,8C.

Connect the GND pin with GND from power supply and COM pin with 12v Supply Input, When a logic one is fed to 1B , you are able to get the ground from 1C, we used the channel 8, thus we connected 8B with ESP8266 pin 12 and and 8C to relay coil ground Pin, we already provided relay coil +ve pin with 12v supply. Refer the schematics in the next section to get a clear idea of the circuit connection.

Click here to See the Datasheet.

Circuit Integration

The complete circuit integration won’t take much time, you can use  breadboard  to integrate the circuit to save your time, we used the protoboards to make breakout boards for the ULN2803 IC and ESP8266 Thing. we used fritzing to make breadboard design for you, just refer the circuit diagram to build your own circuit.

The 12v and 5v power supply is something you can get from adapter around you, power socket or power extension box is something you need to buy. you must buy a big box to fit in maximum circuit Inside it, Precaution must be taken when you assemble this high power circuits.

Schematics:

If you check the above image, you won’t find 5v power supply, its because we fitted it in inside the power socket, the two green wires coming out of the power socket is 5v and GND. The rest you are able to figure out just by referring the schematic shown. We had added working video of the prototype to show you how the things work, use the source code we provided to build your own device.

Source Code

//ON Device                        Control command:   http://192.168.1.167/led?params=1                
//OFF Device                      Control command:   http://192.168.1.167/led?params=2            

#include <ESP8266WiFi.h>
#include <aREST.h>

#define PIN1 13
#define PIN2 12

aREST rest = aREST();

// WiFi parameters
const char* ssid = “xxxx”;
const char* password = “xxxxxxxx”;

// The port to listen for incoming TCP connections
#define LISTEN_PORT 80

// Create an instance of the server
WiFiServer server(LISTEN_PORT);

// Declare functions to be exposed to the API
int ledControl(String command);
void setup(void){
Serial.begin(57600);
pinMode(PIN1,OUTPUT);
pinMode(PIN2,OUTPUT);

// Function to be exposed
rest.function(“led”,ledControl);

// Give name and ID to device
rest.set_id(“1”);
rest.set_name(“esp8266”);

// Connect to WiFi
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
}

// Start the server
server.begin();
Serial.println(WiFi.localIP());
}
void loop() {
// Handle REST calls
WiFiClient client = server.available();
if (!client) {
return;
}

while(!client.available()){
delay(1);
}
rest.handle(client);
}
int ledControl(String command) {
int state = command.toInt();

if(state==1){
digitalWrite( PIN1, 1);
digitalWrite( PIN2, 1);
}

else
if(state==2){
digitalWrite( PIN1, 0);
digitalWrite( PIN2, 0);
}

return 1;
}

Make sure that you had replaced the Wifi SSID and password credentials in the code with your own network one.

Once you upload the code to you device, you are able to get your local IP address from the serial terminal, open the arduino serial terminal at 57600 baud rate, when you are able to see the IP address just copy it and open your browser either from computer or mobile, whichever connected to same network, use the following two commands in the address bar to control the socket:

//ON Device                        Control command:   http://192.168.1.167/led?params=1                
//OFF Device                      Control command:   http://192.168.1.167/led?params=2      

Replace the IP address with you own IP address in the command shown above. Whenever a successful communication is established between ESP8266 and Web, you will get response from the ESP8266 at web end, you are able to see this in the video we added.

We had used the arest in this project, which made our task looks simple, using the arest command line we are able to pass on multiple parameters(all at once) to ESP8266 as string or vise versa.

Download the arest library to run the above code. you need to unzip and copy the library to the arduino library folder.

If you are a web developer the things will be more easier for you, just use the mentioned commands in your web page to link it to the web User Interface. In the next part we will come with more advanced options for the same project so that things will be more easier for you.

Source:

ESP8266 Thing
Frtizing

Introduction to Micro OLED Display

An organic light-emitting diode (OLED) is a light-emitting diode (LED) in which the emissive electroluminescent layer is a film of organic compound that emits light in response to an electric current. This layer of organic semiconductor is situated between two electrodes typically and at least one of these electrodes is transparent.

The Micro OLED Display used in this tutorial is a small monochrome, blue-on-black OLED. It’s 64 pixels wide and 48 pixels tall, measuring 0.66″ across. It’s micro sized and sufficient enough to fit a deceivingly large amount of graphics on there. this Micro OLED is easy to control over either an SPI or I²C interface.

Sparkfun have the breakout board for this display, its easy and time saving to use the same breakout for any projects.This Micro OLED Breakout provides access to 16 of the OLED’s pins. This breakout board operates at 3.3V with a current of 10mA (20mA max).The Micro OLED present in this breakout is same as  Display used in the SparkFun MicroView – OLED Arduino Module.

The breakout board is an open source design and you can get the design files here

Display board Features:

• Operating Voltage: 3.3V
• Screen Size: 64×48 pixels (0.66″ Across)
• Monochrome Blue-on-Black
• SPI or I²C Interface

OLED Pin Reference:

Pin Label	SPI Function	I2C Function	Notes
GND	Ground	Ground	0V
3V3 (VDD)	Power	Power	Should be a regulated 3.3V supply.
D1 (SDI)	MOSI	SDA	Serial data in
D0 (SCK)	SCK	SCL	SPI and I2C clock
D2 (SDO)	MISO	—	Can be unused in SPI mode. No function for I2C.
D/C	Data/Command	I2C address selection	Digital pin to signal if incoming byte is a command or screen data.
RST	Reset	Reset	Active-low screen reset.
CS	CS	—	SPI chip select (active-low)

Sparkfun has provided detailed hookup guide on their blog to setup the OLED breakout board.Follow the links below to see the detailed Instructions.

• Breakout Board Overview
• Hardware Assembly
• Hardware Hookup
• Arduino Library Download, Install, and Test
• Using the Arduino Library

When we tested the board with Sparkfun library we faced some issue with displaying text, thus we made changes to library and sorted out the issue. The library is available to download from GitHub, Click here to download the library.

When you use this Library, make sure you either replace the Sparkfun library or remove and make a backup of the Sparkfun library from the Arduino.

The hookup guide to setup the Micro OLED display with different boards can be found below:

• Micro OLED Breakout Hookup with ESP8266 
• Micro OLED Breakout Hookup with Particle Photon

Micro OLED Breakout Hookup with ESP8266

The ESP8266 is a low-cost Wi-Fi chip with full TCP/IP stack and Microcontroller capability produced by Shanghai-based Chinese manufacturer, Espressif. There are many third party modules With ESP8266 available in the market and you can decide which one suits best for your application, we are using the Sprakfun ESP8266 Thing in this tutorial.

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. These are some features of the board:

ESP8266 Thing 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
• Arduino IDE integration
• Breadboard Compatible Breakout Headers position
• Power On-Off Switch
• Status LED
• Operating Voltage: 3.3v

Refer the Graphical Datasheet for hardware description

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.

We use a 3.3V FTDI Basic to program the Thing, but other serial converters with 3.3V I/O levels should work. The converter does need a DTR line in addition to the RX and TX pins.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!

Note: While programming the Thing, it’s best to power it off USB. We’ve noticed programming is more likely to fail if the Thing is only powered via the battery.

Now we will see how to connect the ESP8266 Thing with Micro OLED Breakout in I²C Mode:

• Setup the jumpers in the Hardware

Setting Jumpers for I2C Mode:

• Short D1/D2 – This will combine the data output line and data input line into one.
• Set BS1 to 1 – The BS1 jumpers comes defaulted to 0, which does half the job of setting it to SPI. To set the display to I2C, you’ll need to flip that jumper to 1. Also make sure the BS2 jumper remains set to 0.
• Set D/C – In I2C mode, the D/C pin configures the display’s 7-bit address. You can set it to either 0 or 1, just keep that value in mind when you get to the code part of this tutorial.

Once you’re done setting jumpers, the back of the board should look a little something like this:

Follow the above shown connections for I2C interface between OLED and ESP8266 Thing. Any Digital pin can be connected to RST(Reset) Pin of OLED, we used Pin number 5 from the ESP8266 Thing.

Note: Pin 5 on the ESP8266 Thing is connected to onboard LED, we tampered the tracks to LED to disable it.

Try out the following code on the ESP8266 Things and check whether your board is working fine or not, We used the modified library (The link to download the library is mentioned above), make sure you must use the same to made it work.

#include <Wire.h> //Include Wire if you’re using I2C
//#include <SPI.h> // Include SPI if you’re using SPI
#include <ER_MicroOLED.h> // Include the ER_MicroOLED library
#define PIN_RESET 5 // Connect RST to pin 9 (req. for SPI and I2C)
//#define PIN_DC 8 // Connect DC to pin 8 (required for SPI)
//#define PIN_CS 10 // Connect CS to pin 10 (required for SPI)
#define DC_JUMPER 1
// Also connect pin 13 to SCK and pin 11 to MOSI
// Declare a MicroOLED object. The parameters include:
// 1 – Reset pin: Any digital pin
// 2 – D/C pin: Any digital pin (SPI mode only)
// 3 – CS pin: Any digital pin (SPI mode only, 10 recommended)
//MicroOLED oled(PIN_RESET, PIN_DC, PIN_CS);
MicroOLED oled(PIN_RESET, DC_JUMPER); // Example I2C declaration

void setup()
{
oled.begin();

// clear(ALL) will clear out the OLED’s graphic memory.
// clear(PAGE) will clear the Arduino’s display buffer.
oled.clear(ALL); // Clear the display’s memory (gets rid of artifacts)
// To actually draw anything on the display, you must call the
// display() function.
oled.display();
delay(2000);

oled.clear(PAGE);
oled.clear(ALL);
oled.setCursor(0,0);
oled.setTextColor(WHITE);
oled.setTextSize(0);

oled.println(“hello !!!!”);
oled.display();
}

void loop()
{
//oled.line(x0, y0, x1, y1); // Draw a line from (x0,y0) to (x1,y1);
oled.line(5, 15, 57, 15); // Draw a line from (x0,y0) to (x1,y1);

//oled.rect(x0, y0, width, height); // Draw a rectange from (7,5) to (31,18)
oled.rect(5, 20, 52, 20); // Draw a rectange from (7,5) to (31,18)

oled.line(5, 45, 57, 45); // Draw a line from (x0,y0) to (x1,y1);

//oled.rectFill(7, 5, 35, 5); // Fill a rectangle from (7, 5) to (42, 10)
oled.rectFill(10, 25, 42, 10); // Fill a rectangle from (7, 5) to (42, 10)

//oled.circleFill(42, 20, 7); // Fill a circle, 7 radius, centered at (42, 20)

oled.display(); // Draw to the screen
}

Micro OLED Hookup with Particle Photon

The Photon is a development kit for creating Wi-Fi connected products. It’s based on Broadcom’s WICED architecture, and combines a powerful STM32 ARM Cortex M3 microcontroller and a Broadcom Wi-Fi chip (the same one that’s in Nest Protect, LIFX, and Amazon Dash).

Photon Features:

• Fits in a standard breadboard (with headers)
• Surface mountable for machine assembly (without headers)
• Backwards compatible with the Spark Core
• Broadcom BCM43362 Wi-Fi chip
• STM32F205 120Mhz ARM Cortex M3
• 1MB flash, 128KB RAM
• 802.11b/g/n
• FCC/CE/IC certified
• Open source hardware
• On-board RGB status LED (ext. drive provided)
• 18 Mixed-signal GPIO and advanced peripherals
• Real-time operating system (FreeRTOS)
• Soft AP setup

Notes:

^[1] FT = 5.0V tolerant pins. All pins except A3 and DAC are 5V tolerant (when not in analog mode). If used as a 5V input the pull-up/pull-down resistor must be disabled.

^[2] 3V3 = 3.3V max pins.

^[3] PWM is available on D0, D1, D2, D3, A4, A5, WKP, RX, TX with a caveat: PWM timer peripheral is duplicated on two pins (A5/D2) and (A4/D3) for 7 total independent PWM outputs. For example: PWM may be used on A5 while D2 is used as a GPIO, or D2 as a PWM while A5 is used as an analog input. However A5 and D2 cannot be used as independently controlled PWM outputs at the same time.

Photon Graphical Pin Description:

Click here to see the Complete Datasheet for Particle Photon.

To hookup the OLED with Photon in I2C mode is pretty much same as what we seen with ESP8266 Thing except this point that both the SDA and SCL lines must be pulled high always. Refer the connection diagram for better idea.

Pullup is the thing you need to take care of, we used 10kΩ Resistor for pullup and connected it to 3v3 supply line as shown in the figure.

Programme the Particle Photon:

Photon can be programmed in three ways:

• Particle Build(Online)
• Particle Dev(Half Online, Half Offline)
• ARM GCC and the DFU Bootloader (Offline)

We recommend you to start with Particle Build(Online), the Particle Build IDE is an always-online, browser-based portal where your Photon code can be edited, saved, and shared. This cloud-based IDE handles code compilation and flashes the built binaries to your Photon over-the-air. You don’t even need your Photon next to you to update its program!

To load the Build IDE head over to build.particle.io.

Sparkfun has provided more detailed Instructions for the beginners to understand the IDE better, Click here to see the Particle Build(Online) guide.

Similarly they provided instruction to understand Particle Dev(Half Online, Half Offline) guide and ARM GCC and the DFU Bootloader (Offline) guide.

To run the OLED program in the Particle Build(online), follow these steps:

• Add your device to the Particle Build.
  • Download Particle Mobile App to your Handset- iPhone | Android
  • Open the app on your phone. Log in or sign up for an account with Particle if you don’t have one.
  • Use this Particle First time setup guide
• Open the online terminal build.particle.io and login in to your account
• Check under devices tab that whether your devices is listed or not, if not try to add it using mobile app.
• Goto ” code tab  -> Create New App “
• Add micro OLED library to current App.
• To add Librbary, goto: ” Libraries Tab -> Community Library Search Box -> type OLED “
• There you will see SPARKFUNMICROOLED Library, Click ” Include in App ” option.
• Save the App using save option.
• Use the following code to begin with

/******************************************************************************
Micro-OLED-Shield-Example.ino
SparkFun Micro OLED Library Hello World Example
Jim Lindblom @ SparkFun Electronics
Original Creation Date: June 22, 2015

This sketch prints a friendly, recognizable logo on the OLED Shield, then
goes on to demo the Micro OLED library’s functionality drawing pixels,
lines, shapes, and text.

Hardware Connections:
This sketch was written specifically for the Photon Micro OLED Shield,
which does all the wiring for you. If you have a Micro OLED breakout,
use the following hardware setup:

MicroOLED ————- Photon
GND ——————- GND
VDD ——————- 3.3V (VCC)
D1/MOSI —————– A5 (don’t change)
D0/SCK —————— A3 (don’t change)
D2
D/C ——————- D6 (can be any digital pin)
RST ——————- D7 (can be any digital pin)
CS ——————- A2 (can be any digital pin)

Development environment specifics:
IDE: Particle Build
Hardware Platform: Particle Photon
SparkFun Photon Micro OLED Shield

This code is beerware; if you see me (or any other SparkFun
employee) at the local, and you’ve found our code helpful,
please buy us a round!

Distributed as-is; no warranty is given.
*******************************************************************************/
#include “SparkFunMicroOLED/SparkFunMicroOLED.h” // Include MicroOLED library
#include “math.h”

//////////////////////////////////
// MicroOLED Object Declaration //
//////////////////////////////////
// Declare a MicroOLED object. If no parameters are supplied, default pins are
// used, which will work for the Photon Micro OLED Shield (RST=D7, DC=D6, CS=A2)
//MicroOLED oled;
MicroOLED oled(MODE_I2C, D6); // Example I2C declaration RST=D7, DC=LOW (0)

//SYSTEM_MODE(MANUAL);

void setup()
{
Serial.begin(9600);
oled.begin(); // Initialize the OLED
oled.clear(ALL); // Clear the display’s internal memory
oled.display(); // Display what’s in the buffer (splashscreen)
delay(1000); // Delay 1000 ms
randomSeed(analogRead(A0) + analogRead(A1));
}

void loop()
{
pixelExample(); // Run the pixel example function
lineExample(); // Then the line example function
shapeExample(); // Then the shape example
textExamples(); // Finally the text example
}

void pixelExample()
{
printTitle(“Pixels”, 1);

for (int i=0; i<512; i++)
{
oled.pixel(random(oled.getLCDWidth()), random(oled.getLCDHeight()));
oled.display();
}
}

void lineExample()
{
int middleX = oled.getLCDWidth() / 2;
int middleY = oled.getLCDHeight() / 2;
int xEnd, yEnd;
int lineWidth = min(middleX, middleY);

printTitle(“Lines!”, 1);

for (int i=0; i<3; i++)
{
for (int deg=0; deg<360; deg+=15)
{
xEnd = lineWidth * cos(deg * M_PI / 180.0);
yEnd = lineWidth * sin(deg * M_PI / 180.0);

oled.line(middleX, middleY, middleX + xEnd, middleY + yEnd);
oled.display();
delay(10);
}
for (int deg=0; deg<360; deg+=15)
{
xEnd = lineWidth * cos(deg * M_PI / 180.0);
yEnd = lineWidth * sin(deg * M_PI / 180.0);

oled.line(middleX, middleY, middleX + xEnd, middleY + yEnd, BLACK, NORM);
oled.display();
delay(10);
}
}
}

void shapeExample()
{
printTitle(“Shapes!”, 0);

// Silly pong demo. It takes a lot of work to fake pong…
int paddleW = 3; // Paddle width
int paddleH = 15; // Paddle height
// Paddle 0 (left) position coordinates
int paddle0_Y = (oled.getLCDHeight() / 2) – (paddleH / 2);
int paddle0_X = 2;
// Paddle 1 (right) position coordinates
int paddle1_Y = (oled.getLCDHeight() / 2) – (paddleH / 2);
int paddle1_X = oled.getLCDWidth() – 3 – paddleW;
int ball_rad = 2; // Ball radius
// Ball position coordinates
int ball_X = paddle0_X + paddleW + ball_rad;
int ball_Y = random(1 + ball_rad, oled.getLCDHeight() – ball_rad);//paddle0_Y + ball_rad;
int ballVelocityX = 1; // Ball left/right velocity
int ballVelocityY = 1; // Ball up/down velocity
int paddle0Velocity = -1; // Paddle 0 velocity
int paddle1Velocity = 1; // Paddle 1 velocity

//while(ball_X >= paddle0_X + paddleW – 1)
while ((ball_X – ball_rad > 1) &&
(ball_X + ball_rad < oled.getLCDWidth() – 2))
{
// Increment ball’s position
ball_X+=ballVelocityX;
ball_Y+=ballVelocityY;
// Check if the ball is colliding with the left paddle
if (ball_X – ball_rad < paddle0_X + paddleW)
{
// Check if ball is within paddle’s height
if ((ball_Y > paddle0_Y) && (ball_Y < paddle0_Y + paddleH))
{
ball_X++; // Move ball over one to the right
ballVelocityX = -ballVelocityX; // Change velocity
}
}
// Check if the ball hit the right paddle
if (ball_X + ball_rad > paddle1_X)
{
// Check if ball is within paddle’s height
if ((ball_Y > paddle1_Y) && (ball_Y < paddle1_Y + paddleH))
{
ball_X–; // Move ball over one to the left
ballVelocityX = -ballVelocityX; // change velocity
}
}
// Check if the ball hit the top or bottom
if ((ball_Y <= ball_rad) || (ball_Y >= (oled.getLCDHeight() – ball_rad – 1)))
{
// Change up/down velocity direction
ballVelocityY = -ballVelocityY;
}
// Move the paddles up and down
paddle0_Y += paddle0Velocity;
paddle1_Y += paddle1Velocity;
// Change paddle 0’s direction if it hit top/bottom
if ((paddle0_Y <= 1) || (paddle0_Y > oled.getLCDHeight() – 2 – paddleH))
{
paddle0Velocity = -paddle0Velocity;
}
// Change paddle 1’s direction if it hit top/bottom
if ((paddle1_Y <= 1) || (paddle1_Y > oled.getLCDHeight() – 2 – paddleH))
{
paddle1Velocity = -paddle1Velocity;
}

// Draw the Pong Field
oled.clear(PAGE); // Clear the page
// Draw an outline of the screen:
oled.rect(0, 0, oled.getLCDWidth() – 1, oled.getLCDHeight());
// Draw the center line
oled.rectFill(oled.getLCDWidth()/2 – 1, 0, 2, oled.getLCDHeight());
// Draw the Paddles:
oled.rectFill(paddle0_X, paddle0_Y, paddleW, paddleH);
oled.rectFill(paddle1_X, paddle1_Y, paddleW, paddleH);
// Draw the ball:
oled.circle(ball_X, ball_Y, ball_rad);
// Actually draw everything on the screen:
oled.display();
delay(25); // Delay for visibility
}
delay(1000);
}

void textExamples()
{
printTitle(“Text!”, 1);

// Demonstrate font 0. 5×8 font
oled.clear(PAGE); // Clear the screen
oled.setFontType(0); // Set font to type 0
oled.setCursor(0, 0); // Set cursor to top-left
// There are 255 possible characters in the font 0 type.
// Lets run through all of them and print them out!
for (int i=0; i<=255; i++)
{
// You can write byte values and they’ll be mapped to
// their ASCII equivalent character.
oled.write(i); // Write a byte out as a character
oled.display(); // Draw on the screen
delay(10); // Wait 10ms
// We can only display 60 font 0 characters at a time.
// Every 60 characters, pause for a moment. Then clear
// the page and start over.
if ((i%60 == 0) && (i != 0))
{
delay(500); // Delay 500 ms
oled.clear(PAGE); // Clear the page
oled.setCursor(0, 0); // Set cursor to top-left
}
}
delay(500); // Wait 500ms before next example

// Demonstrate font 1. 8×16. Let’s use the print function
// to display every character defined in this font.
oled.setFontType(1); // Set font to type 1
oled.clear(PAGE); // Clear the page
oled.setCursor(0, 0); // Set cursor to top-left
// Print can be used to print a string to the screen:
oled.print(” !\”#$%&'()*+,-./01234″);
oled.display(); // Refresh the display
delay(1000); // Delay a second and repeat
oled.clear(PAGE);
oled.setCursor(0, 0);
oled.print(“56789:;<=>?@ABCDEFGHI”);
oled.display();
delay(1000);
oled.clear(PAGE);
oled.setCursor(0, 0);
oled.print(“JKLMNOPQRSTUVWXYZ[\\]^”);
oled.display();
delay(1000);
oled.clear(PAGE);
oled.setCursor(0, 0);
oled.print(“_`abcdefghijklmnopqrs”);
oled.display();
delay(1000);
oled.clear(PAGE);
oled.setCursor(0, 0);
oled.print(“tuvwxyz{|}~”);
oled.display();
delay(1000);

// Demonstrate font 2. 10×16. Only numbers and ‘.’ are defined.
// This font looks like 7-segment displays.
// Lets use this big-ish font to display readings from the
// analog pins.
for (int i=0; i<25; i++)
{
oled.clear(PAGE); // Clear the display
oled.setCursor(0, 0); // Set cursor to top-left
oled.setFontType(0); // Smallest font
oled.print(“A0:”); // Print “A0”
oled.setFontType(2); // 7-segment font
oled.print(analogRead(A0)); // Print a0 reading
oled.setCursor(0, 16); // Set cursor to top-middle-left
oled.setFontType(0); // Repeat
oled.print(“A1:”);
oled.setFontType(2);
oled.print(analogRead(A1));
oled.setCursor(0, 32);
oled.setFontType(0);
oled.print(“A7:”);
oled.setFontType(2);
oled.print(analogRead(A7));
oled.display();
delay(100);
}

// Demonstrate font 3. 12×48. Stopwatch demo.
oled.setFontType(3); // Use the biggest font
int ms = 0;
int s = 0;
while (s <= 50)
{
oled.clear(PAGE); // Clear the display
oled.setCursor(0, 0); // Set cursor to top-left
if (s < 10)
oled.print(“00”); // Print “00” if s is 1 digit
else if (s < 100)
oled.print(“0”); // Print “0” if s is 2 digits
oled.print(s); // Print s’s value
oled.print(“:”); // Print “:”
oled.print(ms); // Print ms value
oled.display(); // Draw on the screen
ms++; // Increment ms
if (ms >= 10) // If ms is >= 10
{
ms = 0; // Set ms back to 0
s++; // and increment s
}
delay(1);
}
}

// Center and print a small title
// This function is quick and dirty. Only works for titles one
// line long.
void printTitle(String title, int font)
{
int middleX = oled.getLCDWidth() / 2;
int middleY = oled.getLCDHeight() / 2;

oled.clear(PAGE);
oled.setFontType(font);
// Try to set the cursor in the middle of the screen
oled.setCursor(middleX – (oled.getFontWidth() * (title.length()/2)),
middleY – (oled.getFontWidth() / 2));
// Print the title:
oled.print(title);
oled.display();
delay(1500);
oled.clear(PAGE);
}

Care must be taken to initialize object in the code for I2C communication, use the following parameter for declartion based on your application.
//MicroOLED oled(MODE_SPI, PIN_RESET, PIN_DC, PIN_CS); // Example SPI declaration
//MicroOLED oled(MODE_I2C, PIN_RESET); // Example I2C declaration

Note: The Hookup shown here for I2C communication is tested and in working condition, to do the SPI interface of the OLED Module, you need to do the following things:

• Modify the Jumpers on the back of the OLED breakout for SPI Communication
• Visit here for jumper settings
• Refer the shown connection chart below for SPI connection.
• Make sure to initialize these connected pins in the object declaration.

 

OLED	Photon	ESP8266
GND	GND	GND
3v3	3v3	3v3
D1-MOSI	A5 D2	13
D0-SCK	A3 D4	14
D2-MISO	A4 D3	12
DC	– –	–
RST	Any Digital pin Any Digital pin	D5
CS	Any Digital Pin Any Digital Pin	D4/D2

 Note: Use any one of the SPI peripheral of the photon. MISO pins can be unused.

Buy:

• SparkFun MicroView – OLED Arduino Module
• Particle Photon

Source:

• ESp8266 Wiki
• Particle Photon
• Sparkfun Micro OLED Hookup
• Particle Photon Docs
• ESP8266 Thing Hookup Guide
• Sparkfun Photon Development Guide
• OLED Wiki