Home > Arduino Projects > Mini Slideshow using OLED
Description:

Small OLED displays are handy for showing data and status, but they are also great for displaying pictures.
Here is how you can use an Arduino and a small OLED display to show a mini slideshow from your PC!
The Arduino in this case is our Freetronics' Eleven, and the display is Seeed Studio's Grove 96x96 OLED display.

Video:



Parts Required:

Freetronics' Eleven or any compatible Arduino
Seeed Studio's Grove OLED Display 96x96
Seeed Studio's Grove Base Shield
Seeed Studio's Grove Universal Cables

Software:


Arduino IDE (v0023 - Please note: Later versions are not supported)
Processing IDE
Seeed Studio's Gray OLED Library - unzip these files and copy them into the Arduino Library folder

Sketch:

Sketch

Freetronics' Eleven / Arduino Sketch:

 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
// OLED Slideshow: Arduino Sketch written by ScottC 21/07/2012

#include <Wire.h>
#include <SeeedGrayOLED.h> //From http://garden.seeedstudio.com/images/c/c4/SeeedGrayOLED.zip
#include <avr/pgmspace.h>

int counter=0;

void setup()
{
//Allow communication to OLED
Wire.begin();

//Allow Serial communication between Freetronics Eleven and Computer
Serial.begin(28800);

//Initialise the OLED
SeeedGrayOled.init();
//Clear the OLED display
SeeedGrayOled.clearDisplay();
//Set to vertical mode - horizontal mode doesn't work with this example
SeeedGrayOled.setVerticalMode();

}

void loop(){
//Listen for Serial comunication
while (Serial.available()>0) {
// Read data and send directly to the OLED
sendMyData(Serial.read());
counter++;

//When counter reaches 4608 pixels, the picture is complete.
if(counter>4607){
//Insert delay to allow viewing of picture.
delay(4000);
Serial.println("End of Transmission");

//Reset the counter for the next picture
counter=0;
}
}
}

// This function was adapted from the SEEED Gray OLED driver so that
// character bytes could be sent directly to the OLED.
void sendMyData(unsigned char Data){
Wire.beginTransmission(SeeedGrayOLED_Address); // begin I2C transmission
Wire.send(SeeedGrayOLED_Data_Mode); // data mode
Wire.send(Data);
Wire.endTransmission();
}


// This function was adapted from the SEEED Gray OLED driver so that
// commands could be sent directly to the OLED.
// NOT USED IN THIS EXAMPLE ***********************
void sendMyCommand(unsigned char Cmd){
Wire.beginTransmission(SeeedGrayOLED_Address); // begin I2C communication
Wire.send(SeeedGrayOLED_Command_Mode); // Set OLED Command mode
Wire.send(Cmd);
Wire.endTransmission(); // End I2C communication
}


Processing Sketch:


 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
/* OLED Slideshow: Processing Sketch Written by ScottC 21/7/2012 

References:
Getting Pixels: http://www.learningprocessing.com/examples/chapter-15/example-15-7/
Greyscale conversion = http://www.openprocessing.org/sketch/60336
*/


import processing.serial.*; /* Needed for Serial Communication */

/* Global variables */
Serial comPort;
String [] comPortList;
String comPortString;
PImage img;
char[] tempGrey=new char[4609];
int startOffset=0;
ArrayList picNames;
int curLoop=1;
int totalPics=0;
int curPicNum=0;
boolean toggleSend=true;
boolean sendBouncer=true;

//Change maxLoops to a number > 1 if you want the pictures to loop.
int maxLoops=1;


void setup() {
//The size of the display is critical (must match the OLED)
size(96, 96);
//setup Serial
comPortList = Serial.list();
if(comPortList.length>0){
//baud rates greater than 28800 may produce unexpected results
comPort = new Serial(this, comPortList[0], 28800);
comPort.bufferUntil('\n');
} else{
println("NO COM PORTS AVAILABLE");
}

//Create an Array of pictures
picNames=new ArrayList();
picNames.add("Picture1.bmp");
picNames.add("Picture2.bmp");
picNames.add("Picture3.bmp");
picNames.add("Picture4.bmp");
// for more pictures just keep adding them to the list.
//The actual pictures must be located in the data folder of this project.
//Select Sketch/Add File to add the files to this folder.
//Make sure that the name of pictures match the names above.

//Get the total number of pictures added
totalPics=picNames.size();
}

void draw(){
if(toggleSend && sendBouncer){

// Debugging code: print("STARTED:");
// Debugging code: println(picNames.get(curPicNum));

sendImage((String)picNames.get(curPicNum)); //Send the picture to the OLED
toggleSend=false; //temporarily stop sending any more pictures until authorised
curPicNum++; //increment in preparation for the next picture

if(curPicNum==totalPics){
curPicNum=0; //go back to the first picture
curLoop++; //increment the loop counter
}
if(curLoop>maxLoops){
sendBouncer=false; //Stop any further looping
println("ANIMATION COMPLETE");
}
}
}


void sendImage(String imgName){
img = loadImage(imgName);
image(img,0,0,width,height);
loadPixels();
int counter=0;
for (int x = 0; x < width; x=x+2) {
for (int y = 0; y < height; y++) {
counter++;
int PixLoc = x + y*height; // this reads down then across2.
//Left pixel nibble
int Pix1=(round((red(pixels[PixLoc])*0.222+green(pixels[PixLoc])*0.707+blue(pixels[PixLoc])*0.071)))/16;
//Right pixel nibble
int Pix2=(round((red(pixels[PixLoc+1])*0.222+green(pixels[PixLoc+1])*0.707+blue(pixels[PixLoc+1])*0.071)))/16;
//Shift the byte <<4 for the left pixel nibble
int PixShift1=Pix1<<4;
//Combine both nibbles to form a byte
int PixFin = PixShift1+Pix2;
byte PixByteFin=byte(PixFin);
//Assign this byte to the tempGrey array
tempGrey[counter] = char(PixByteFin);
}
}
sendSerial(tempGrey); //Send the image data through the Serial COM Port/
}


//This function will send the byte/Char array to the Freetronics
//Eleven or Arduino.
void sendSerial(char[] Data){
for(int i=0; i<4608; i++){
//Needs an offset to get picture to align to screen properly
//only needs to do this once.
if(startOffset==0){
i=i+6;
startOffset++;
}
//Send the picture data to the Freetronics Eleven / Arduino
comPort.write(Data[i]);
}
}


//This function will wait for a response from the Freetronics
//Eleven or Arduino before sending any further pictures.
void serialEvent (Serial myPort) {
// get the ASCII string:
String inString = myPort.readStringUntil('\n');
if (inString != null) {
println(inString);
toggleSend=true; // Allow the next picture to be sent
}
}


For more awesome projects, or more info on this project, check out ScottC's Arduino Basics Blog