Tag Archives: OLED

In this video lesson we show how to build a portable Arduino Weather Station. The station is powered by a battery bank, and data is displayed on the SSD1306 OLED display. The station included the BMP180 pressure sensor for barometric pressure, the DHT 11 for temperature and humidity, and a push button to toggle between modes. The schematic of the circuit is shown below.

The code developed in the video is included for your convenience below:

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Adafruit_BMP085.h>

//**********************************************
#include <DHT.h>
#define DHTPIN 11
#define DHTTYPE DHT11
DHT dht(DHTPIN,DHTTYPE);

int butPin=2;
int butVal=0;
int butValOld=0;
int butCount=0;
int butRem=0;

float tempF;
float tempC;
float hum=50;
int hReadTime=0;
int hReadInt=2000;

float humRaw[128];
float normHum[128];
float tempRaw[128];
float normTemp[128];

int lastUpdate = 0;
int updateInterval = 600;

float rawXdata[128];
int normXdata[128];

float rawYdataP[128];
int normYdataP[128];
float rawYdataH[128];
int normYdataH[128];
float rawYdataT[128];
int normYdataT[128];

float xMin = 0;       //************************************
float xMax = 127;

float yMinP = 28;
float yMaxP = 31;
float yMinH=30;
float yMaxH=90;
float yMinT=60;
float yMaxT=90;

float Pt = 14;
float Pb = 63;

float Pl = 0;
float Pr = 127;

int numPoints = 128;

Adafruit_BMP085 BP;
bool BMPconnected = false;

float BarPress = 30;
float BarPressNow = 30;
float alt = 1127;    //****************************

int screenWidth = 128;
int screenHeight = 64;
int oledReset = -1;
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 oled(screenWidth, screenHeight, &Wire, oledReset);

void setup() {
  // put your setup code here, to run once:
  pinMode(butPin,INPUT_PULLUP); //*********************
  Serial.begin(9600);
  BMPconnected = BP.begin();
  if (BMPconnected == true) {
    Serial.println("BMP180 found and Connected");
  }
  if (BMPconnected == false) {
    Serial.println("BMP180 not found, Check Connections");
  }
  oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  oled.clearDisplay();
  oled.display();
  for (int i = 0; i < numPoints; i= i + 1) {
    rawXdata[i] = i;
  }
  dht.begin();
  delay(2000);
}

void loop() {
  // put your main code here, to run repeatedly:
  BarPressNow = normPress(alt);
  BarPress = .95 * BarPress + .05 * BarPressNow;  
  tempC=BP.readTemperature();         //***********************
  tempF=tempC*9/5 +32;
  if (millis()-hReadTime>hReadInt){
    hum=dht.readHumidity();
    Serial.println(hum);
    hReadTime=millis();
  }

  if (millis() - lastUpdate >= updateInterval) {
    for (int i = 0; i < numPoints - 1; i = i + 1) {
      rawYdataP[i] = rawYdataP[i + 1];
      rawYdataT[i] = rawYdataT[i + 1];
      rawYdataH[i] = rawYdataH[i + 1];
    }
    lastUpdate=millis();
    rawYdataP[numPoints-1]=BarPress;
    rawYdataT[numPoints-1]=tempF;
    rawYdataH[numPoints-1]=hum;
    //normData();
    //oled.clearDisplay();
    //plotGraph();
  }
  butVal=digitalRead(butPin);
  if (butVal==0 && butValOld==1){
    butCount=butCount+1;
    butRem=butCount%4;
  }
  butValOld=butVal;
  if (butRem==0){
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.setTextColor(WHITE);
  oled.setTextSize(2);
  oled.print(tempF);
  oled.println(" F");
  oled.print(hum);
  oled.println(" %Hum");
  oled.print(BarPress);
  oled.println(" InHG");
  oled.display();
  }
  if (butRem==1){
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.setTextColor(WHITE);
  oled.setTextSize(2);
  oled.print(BarPress);
  oled.setTextSize(1);
  oled.println(" InHG");
  normDataP();             //***********************
  plotPress();           //***********************
  oled.display();
  delay(.1);
  }
  if (butRem==2){
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.setTextColor(WHITE);
  oled.setTextSize(2);
  oled.print(tempF);
  oled.setTextSize(1);
  oled.println(" F");
  normDataT();             //***********************
  plotTemp();           //***********************
  oled.display();
  delay(.1);
  }
  if (butRem==3){
  oled.clearDisplay();
  oled.setCursor(0, 0);
  oled.setTextColor(WHITE);
  oled.setTextSize(2);
  oled.print(hum);
  oled.setTextSize(1);
  oled.println(" %HUM");
  normDataH();             //***********************
  plotHum();           //***********************
  oled.display();
  delay(.1);
  }
}

float normPress(float elev) {
  float BPRaw;
  float BPNorm;
  float T0 = 288.15;
  float L = .0065;
  float R = 8.3144598;
  float M = .0289644;
  float g = 9.8;
  float c = M * g / (R * L);
  BPRaw = BP.readPressure() * .0002953;
  BPNorm = BPRaw / pow(1 - L * elev / T0, c);
  return BPNorm;
}
void normDataP() {
  for (int i = 0; i < numPoints; i = i + 1) {
    normYdataP[i] = (Pb - Pt) / (yMinP - yMaxP) * (rawYdataP[i] - yMaxP) + Pt;
    normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;
  }
}
  void normDataT() {
  for (int i = 0; i < numPoints; i = i + 1) {
    normYdataT[i] = (Pb - Pt) / (yMinT - yMaxT) * (rawYdataT[i] - yMaxT) + Pt;
    normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;
  }
  }
  void normDataH() {
  for (int i = 0; i < numPoints; i = i + 1) {
    normYdataH[i] = (Pb - Pt) / (yMinH - yMaxH) * (rawYdataH[i] - yMaxH) + Pt;
    normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;
  }
}
void plotPress() {                    //plot Pressure
  oled.drawLine(Pl, Pt, Pl, Pb, WHITE);
  oled.drawLine(Pl, Pb, Pr, Pb, WHITE);
  int MID = (Pb - Pt) / (yMinP - yMaxP) * (29.92 - yMaxP) + Pt;    //********** 
  oled.drawLine(Pl, MID, Pr, MID, WHITE);
  for (int i = 0; i < numPoints - 1; i = i + 1) {
    oled.drawLine(normXdata[i], normYdataP[i], normXdata[i + 1], normYdataP[i + 1], WHITE); //***********
  }
}
void plotTemp() {                    //plot Pressure
  oled.drawLine(Pl, Pt, Pl, Pb, WHITE);
  oled.drawLine(Pl, Pb, Pr, Pb, WHITE);
  //int MID = (Pb - Pt) / (yMinP - yMaxP) * (29.92 - yMaxP) + Pt;    //********** 
  //oled.drawLine(Pl, MID, Pr, MID, WHITE);
  for (int i = 0; i < numPoints - 1; i = i + 1) {
    oled.drawLine(normXdata[i], normYdataT[i], normXdata[i + 1], normYdataT[i + 1], WHITE); //***********
  }
}
void plotHum() {                    //plot Pressure
  oled.drawLine(Pl, Pt, Pl, Pb, WHITE);
  oled.drawLine(Pl, Pb, Pr, Pb, WHITE);
  //int MID = (Pb - Pt) / (yMinP - yMaxP) * (29.92 - yMaxP) + Pt;    //********** 
  //oled.drawLine(Pl, MID, Pr, MID, WHITE);
  for (int i = 0; i < numPoints - 1; i = i + 1) {
    oled.drawLine(normXdata[i], normYdataH[i], normXdata[i + 1], normYdataH[i + 1], WHITE); //***********
  }
}

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

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

#include <Adafruit_BMP085.h>

//**********************************************

#include <DHT.h>

#define DHTPIN 11

#define DHTTYPE DHT11

DHT dht(DHTPIN,DHTTYPE);

int butPin=2;

int butVal=0;

int butValOld=0;

int butCount=0;

int butRem=0;

float tempF;

float tempC;

float hum=50;

int hReadTime=0;

int hReadInt=2000;

float humRaw[128];

float normHum[128];

float tempRaw[128];

float normTemp[128];

int lastUpdate = 0;

int updateInterval = 600;

float rawXdata[128];

int normXdata[128];

float rawYdataP[128];

int normYdataP[128];

float rawYdataH[128];

int normYdataH[128];

float rawYdataT[128];

int normYdataT[128];

float xMin = 0; //************************************

float xMax = 127;

float yMinP = 28;

float yMaxP = 31;

float yMinH=30;

float yMaxH=90;

float yMinT=60;

float yMaxT=90;

float Pt = 14;

float Pb = 63;

float Pl = 0;

float Pr = 127;

int numPoints = 128;

Adafruit_BMP085 BP;

bool BMPconnected = false;

float BarPress = 30;

float BarPressNow = 30;

float alt = 1127; //****************************

int screenWidth = 128;

int screenHeight = 64;

int oledReset = -1;

#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 oled(screenWidth, screenHeight, &Wire, oledReset);

void setup() {

// put your setup code here, to run once:

pinMode(butPin,INPUT_PULLUP); //*********************

Serial.begin(9600);

BMPconnected = BP.begin();

if (BMPconnected == true) {

Serial.println("BMP180 found and Connected");

}

if (BMPconnected == false) {

Serial.println("BMP180 not found, Check Connections");

}

oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);

oled.clearDisplay();

oled.display();

for (int i = 0; i < numPoints; i= i + 1) {

rawXdata[i] = i;

}

dht.begin();

delay(2000);

}

void loop() {

// put your main code here, to run repeatedly:

BarPressNow = normPress(alt);

BarPress = .95 * BarPress + .05 * BarPressNow;

tempC=BP.readTemperature(); //***********************

tempF=tempC*9/5 +32;

if (millis()-hReadTime>hReadInt){

hum=dht.readHumidity();

Serial.println(hum);

hReadTime=millis();

}

if (millis() - lastUpdate >= updateInterval) {

for (int i = 0; i < numPoints - 1; i = i + 1) {

rawYdataP[i] = rawYdataP[i + 1];

rawYdataT[i] = rawYdataT[i + 1];

rawYdataH[i] = rawYdataH[i + 1];

}

lastUpdate=millis();

rawYdataP[numPoints-1]=BarPress;

rawYdataT[numPoints-1]=tempF;

rawYdataH[numPoints-1]=hum;

//normData();

//oled.clearDisplay();

//plotGraph();

}

butVal=digitalRead(butPin);

if (butVal==0 && butValOld==1){

butCount=butCount+1;

butRem=butCount%4;

}

butValOld=butVal;

if (butRem==0){

oled.clearDisplay();

oled.setCursor(0, 0);

oled.setTextColor(WHITE);

oled.setTextSize(2);

oled.print(tempF);

oled.println(" F");

oled.print(hum);

oled.println(" %Hum");

oled.print(BarPress);

oled.println(" InHG");

oled.display();

}

if (butRem==1){

oled.clearDisplay();

oled.setCursor(0, 0);

oled.setTextColor(WHITE);

oled.setTextSize(2);

oled.print(BarPress);

oled.setTextSize(1);

oled.println(" InHG");

normDataP(); //***********************

plotPress(); //***********************

oled.display();

delay(.1);

}

if (butRem==2){

oled.clearDisplay();

oled.setCursor(0, 0);

oled.setTextColor(WHITE);

oled.setTextSize(2);

oled.print(tempF);

oled.setTextSize(1);

oled.println(" F");

normDataT(); //***********************

plotTemp(); //***********************

oled.display();

delay(.1);

}

if (butRem==3){

oled.clearDisplay();

oled.setCursor(0, 0);

oled.setTextColor(WHITE);

oled.setTextSize(2);

oled.print(hum);

oled.setTextSize(1);

oled.println(" %HUM");

normDataH(); //***********************

plotHum(); //***********************

oled.display();

delay(.1);

}

float normPress(float elev) {

float BPRaw;

float BPNorm;

float T0 = 288.15;

float L = .0065;

float R = 8.3144598;

float M = .0289644;

float g = 9.8;

float c = M * g / (R * L);

BPRaw = BP.readPressure() * .0002953;

BPNorm = BPRaw / pow(1 - L * elev / T0, c);

return BPNorm;

}

void normDataP() {

for (int i = 0; i < numPoints; i = i + 1) {

normYdataP[i] = (Pb - Pt) / (yMinP - yMaxP) * (rawYdataP[i] - yMaxP) + Pt;

normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;

}

void normDataT() {

for (int i = 0; i < numPoints; i = i + 1) {

normYdataT[i] = (Pb - Pt) / (yMinT - yMaxT) * (rawYdataT[i] - yMaxT) + Pt;

normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;

}

void normDataH() {

for (int i = 0; i < numPoints; i = i + 1) {

normYdataH[i] = (Pb - Pt) / (yMinH - yMaxH) * (rawYdataH[i] - yMaxH) + Pt;

normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;

}

void plotPress() { //plot Pressure

oled.drawLine(Pl, Pt, Pl, Pb, WHITE);

oled.drawLine(Pl, Pb, Pr, Pb, WHITE);

int MID = (Pb - Pt) / (yMinP - yMaxP) * (29.92 - yMaxP) + Pt; //**********

oled.drawLine(Pl, MID, Pr, MID, WHITE);

for (int i = 0; i < numPoints - 1; i = i + 1) {

oled.drawLine(normXdata[i], normYdataP[i], normXdata[i + 1], normYdataP[i + 1], WHITE); //***********

}

void plotTemp() { //plot Pressure

oled.drawLine(Pl, Pt, Pl, Pb, WHITE);

oled.drawLine(Pl, Pb, Pr, Pb, WHITE);

//int MID = (Pb - Pt) / (yMinP - yMaxP) * (29.92 - yMaxP) + Pt; //**********

//oled.drawLine(Pl, MID, Pr, MID, WHITE);

for (int i = 0; i < numPoints - 1; i = i + 1) {

oled.drawLine(normXdata[i], normYdataT[i], normXdata[i + 1], normYdataT[i + 1], WHITE); //***********

}

void plotHum() { //plot Pressure

oled.drawLine(Pl, Pt, Pl, Pb, WHITE);

oled.drawLine(Pl, Pb, Pr, Pb, WHITE);

//int MID = (Pb - Pt) / (yMinP - yMaxP) * (29.92 - yMaxP) + Pt; //**********

//oled.drawLine(Pl, MID, Pr, MID, WHITE);

for (int i = 0; i < numPoints - 1; i = i + 1) {

oled.drawLine(normXdata[i], normYdataH[i], normXdata[i + 1], normYdataH[i + 1], WHITE); //***********

}

Arduino

Plot any Data or Graph on any OLED

March 6, 2025 admin

In this video I show you how you can easily plot any graph or data onto any OLED display. We create a mathematical function which will map the raw data onto the screen. We demonstrate the function with a sin wave, but the function will work with any equation or data. This is the code which we developed in the video.

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

float rawXdata[128];
int normXdata[128];

float rawYdata[128];
int normYdata[128];

float xMin = 0;
float xMax = 2 * 3.1415;

float yMin = -1;
float yMax = 1;

float Pt = 0;
float Pb = 63;

float Pl = 0;
float Pr = 127;

float pi = 3.14159265;

int numPoints = 128;

int screenWidth = 128;
int screenHeight = 64;
int oledReset = -1;
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 oled(screenWidth, screenHeight, &Wire, oledReset);

int j=0;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  oled.clearDisplay();
  oled.display();
}
void loop() {
  // put your main code here, to run repeatedly:

  for (int i = 0; i < numPoints; i = i + 1) {
    rawXdata[i] = i * (2 * pi / 127);
    rawYdata[i] = sin(rawXdata[i]);
    Serial.println(rawYdata[i]);
    delay(100);
  }
normData();
plotGraph();
oled.display();
}

void normData() {
  for (int i = 0; i < numPoints; i = i + 1) {
    normYdata[i] = (Pb - Pt) / (yMin - yMax) * (rawYdata[i] - yMax) + Pt;
    normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;
  }
}
void plotGraph(){
    oled.drawLine(Pl,Pt,Pl,Pb,WHITE);
    oled.drawLine(Pl,Pb,Pr,Pb,WHITE);
  for (int i=0;i<numPoints-1;i=i+1){
  oled.drawLine(normXdata[i],normYdata[i],normXdata[i+1],normYdata[i+1],WHITE);
  }
}

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

float rawXdata[128];

int normXdata[128];

float rawYdata[128];

int normYdata[128];

float xMin = 0;

float xMax = 2 * 3.1415;

float yMin = -1;

float yMax = 1;

float Pt = 0;

float Pb = 63;

float Pl = 0;

float Pr = 127;

float pi = 3.14159265;

int numPoints = 128;

int screenWidth = 128;

int screenHeight = 64;

int oledReset = -1;

#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 oled(screenWidth, screenHeight, &Wire, oledReset);

int j=0;

void setup() {

// put your setup code here, to run once:

Serial.begin(115200);

oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);

oled.clearDisplay();

oled.display();

}

void loop() {

// put your main code here, to run repeatedly:

for (int i = 0; i < numPoints; i = i + 1) {

rawXdata[i] = i * (2 * pi / 127);

rawYdata[i] = sin(rawXdata[i]);

Serial.println(rawYdata[i]);

delay(100);

}

normData();

plotGraph();

oled.display();

}

void normData() {

for (int i = 0; i < numPoints; i = i + 1) {

normYdata[i] = (Pb - Pt) / (yMin - yMax) * (rawYdata[i] - yMax) + Pt;

normXdata[i] = (Pr - Pl) / (xMax - xMin) * (rawXdata[i] - xMin) + Pl;

}

void plotGraph(){

oled.drawLine(Pl,Pt,Pl,Pb,WHITE);

oled.drawLine(Pl,Pb,Pr,Pb,WHITE);

for (int i=0;i<numPoints-1;i=i+1){

oled.drawLine(normXdata[i],normYdata[i],normXdata[i+1],normYdata[i+1],WHITE);

}

Raspberry Pi Pico

Portable Distance Measurement Project With HC-SR04 Ultrasonic Sensor

February 11, 2025 admin

In this video lesson we explore creating a portable distance measurement widget using the Raspberry Pi Pico W, the HC-SR04 Ultrasonic Sensor, and the SSD1306 OLED display.

The schematic we use for this project is as follows:

In this work, we use the State Machines on the Pi Pico to ensure precise timing. Below, we include the code developed in the lesson above:

import rp2
from machine import Pin,I2C  #***************
import time
from ssd1306 import SSD1306_I2C  #**************

i2c2=I2C(1,sda=Pin(2), scl=Pin(3), freq=400000)
dsp=SSD1306_I2C(128,64,i2c2)

@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)
def pulse_program():
    wrap_target()
    pull(block)
    mov(x,osr)
    set(pins,1)[31-1]
    set(pins,0)
    wait(1,pin,0)
    label("land")
    in_(pins,1) # 1 Cycle
    mov(y,isr)  # 1 Cycle
    jmp(not_y,"moveOn") # 1 Cycle
    jmp(x_dec,"land")  # 1 Cycle
    label("moveOn")
    mov(isr,invert(x))
    push()
    wrap()
triggerPin = Pin(18,Pin.OUT)
echoPin = Pin(19, Pin.IN)
sm=rp2.StateMachine(0,pulse_program, freq=1000000, set_base=triggerPin,in_base=echoPin)
sm.active(1)
while True:
    sm.put(0xFFFFFFFF)
    print("Pulse Launched")
    clockCycles=(sm.get())*4/2
    distance=clockCycles*.0342
    print("Distance to Target: ",distance)
    dsp.text("Distance: "+str(distance),0,16)
    dsp.show()
    dsp.fill(0)
    time.sleep(.25)

import rp2

from machine import Pin,I2C #***************

import time

from ssd1306 import SSD1306_I2C #**************

i2c2=I2C(1,sda=Pin(2), scl=Pin(3), freq=400000)

dsp=SSD1306_I2C(128,64,i2c2)

@rp2.asm_pio(set_init=rp2.PIO.OUT_LOW)

def pulse_program():

wrap_target()

pull(block)

mov(x,osr)

set(pins,1)[31-1]

set(pins,0)

wait(1,pin,0)

label("land")

in_(pins,1) # 1 Cycle

mov(y,isr) # 1 Cycle

jmp(not_y,"moveOn") # 1 Cycle

jmp(x_dec,"land") # 1 Cycle

label("moveOn")

mov(isr,invert(x))

push()

wrap()

triggerPin = Pin(18,Pin.OUT)

echoPin = Pin(19, Pin.IN)

sm=rp2.StateMachine(0,pulse_program, freq=1000000, set_base=triggerPin,in_base=echoPin)

sm.active(1)

while True:

sm.put(0xFFFFFFFF)

print("Pulse Launched")

clockCycles=(sm.get())*4/2

distance=clockCycles*.0342

print("Distance to Target: ",distance)

dsp.text("Distance: "+str(distance),0,16)

dsp.show()

dsp.fill(0)

time.sleep(.25)

Arduino

Arduino Project for a Portable Ultrasonic Distance Sensor

January 30, 2025 admin

In this video lesson we create a portable distance measuring prototype, using an Arduino Uno R4 WiFi. This project incorporates a HC-SR04 Ultrasonic Sensor, a ‘Go’ button, and the SSD1306 OLED Display. The project is powered by the Sunfounder Breadboard power bank. The arduino is powered by the power bank as well, so the project can operate totally portable. When the device is turned on, the OLED prompts the user to position the device. When the ‘Go’ button is pushed, the device measures the distance to the target, then displays the distance on the OLED display.

The video above gives all the details of the project, with step-by-step instructions.

Portable Distance Sensor with HC-SR04 and SSD1306 OLED Display

For your convenience, the code developed in the video is presented below. Enjoy!

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

int butPin = 2;
int butVal = 1;
int butValOld = 1;

int trigPin = 4;
int echoPin = 3;
int pingTime;
float targDist;
int ft;
float in;

int screenWidth = 128;
int screenHeight = 64;
int oledReset = -1;
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 oled(screenWidth, screenHeight, &Wire, oledReset);

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  pinMode(butPin, INPUT_PULLUP);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
  oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
  oled.clearDisplay();
  oled.display();
}
void loop() {
  // put your main code here, to run repeatedly:
  oled.setCursor(0, 12);
  oled.setTextColor(WHITE);
  oled.setTextSize(1);
  oled.println("Point the ");
  oled.println("DistoMatic at");
  oled.println("Target and Press");
  oled.println("Go");
  oled.display();
  butVal = digitalRead(butPin);
  if (butValOld == 0 && butVal == 1) {
    targDist = findDistance();
    ft = targDist/12;
    in = targDist - ft*12;
    oled.clearDisplay();
    oled.setCursor(0, 0);
    oled.setTextColor(WHITE);
    oled.setTextSize(2);
    Serial.println(targDist);
    Serial.println(ft);
    Serial.println(in);
    oled.println(String(ft)+" Ft.");
    oled.println(String(in)+" In.");
    oled.display();
    delay(5000);
    oled.clearDisplay();
    oled.display();
  }
  butValOld = butVal;
}

float findDistance() {
  float d;
  digitalWrite(trigPin, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  d = pulseIn(echoPin, HIGH) / 2. * .0135;
  return d;
}

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

int butPin = 2;

int butVal = 1;

int butValOld = 1;

int trigPin = 4;

int echoPin = 3;

int pingTime;

float targDist;

int ft;

float in;

int screenWidth = 128;

int screenHeight = 64;

int oledReset = -1;

#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 oled(screenWidth, screenHeight, &Wire, oledReset);

void setup() {

// put your setup code here, to run once:

Serial.begin(9600);

pinMode(butPin, INPUT_PULLUP);

pinMode(trigPin, OUTPUT);

pinMode(echoPin, INPUT);

oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);

oled.clearDisplay();

oled.display();

}

void loop() {

// put your main code here, to run repeatedly:

oled.setCursor(0, 12);

oled.setTextColor(WHITE);

oled.setTextSize(1);

oled.println("Point the ");

oled.println("DistoMatic at");

oled.println("Target and Press");

oled.println("Go");

oled.display();

butVal = digitalRead(butPin);

if (butValOld == 0 && butVal == 1) {

targDist = findDistance();

ft = targDist/12;

in = targDist - ft*12;

oled.clearDisplay();

oled.setCursor(0, 0);

oled.setTextColor(WHITE);

oled.setTextSize(2);

Serial.println(targDist);

Serial.println(ft);

Serial.println(in);

oled.println(String(ft)+" Ft.");

oled.println(String(in)+" In.");

oled.display();

delay(5000);

oled.clearDisplay();

oled.display();

}

butValOld = butVal;

}

float findDistance() {

float d;

digitalWrite(trigPin, LOW);

delayMicroseconds(2);

digitalWrite(trigPin, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin, LOW);

d = pulseIn(echoPin, HIGH) / 2. * .0135;

return d;

}

Arduino

Using the SSD1306 OLED With an Arduino

January 23, 2025 admin

In this Video Tutorial we show you how to incorporate the SSD1306 OLED into your Arduino project. This is a versatile, low power display that makes it easy for you to incorporate a nice display into your Arduino projects. For this project, we connect the OLED via I2C. The schematic for our project is presented below:

Our physical build looked like this:

The video above shows in depth description of the code development, but for your convenience, we include the code below.

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

int screenWidth = 128;
int screenHeight = 64;
int oledReset = -1;
#define SCREEN_ADDRESS 0x3C
Adafruit_SSD1306 oled(screenWidth,screenHeight,&Wire,oledReset);

void setup() {
  // put your setup code here, to run once:
Serial.begin(9600);
oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);
}

void loop() {
  // put your main code here, to run repeatedly:
oled.clearDisplay();
oled.display();
oled.setCursor(0,12);
oled.setTextColor(WHITE);
oled.setTextSize(3);
oled.println(" Hello");
oled.println(" World!");
oled.display();
delay(1000);
oled.invertDisplay(1);
delay(1000);
oled.invertDisplay(0);
delay(1000);

oled.clearDisplay();
oled.drawPixel(64,32,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawLine(0,0,127,63,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawLine(0,32,127,32,WHITE);
oled.drawLine(64,0,64,63,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawRect(0,0,128,64,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.fillRect(0,0,128,64,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.fillRect(0,0,128,64,WHITE);
oled.fillRect(5,5,118,54,BLACK);
oled.display();
delay(1000);

oled.clearDisplay();
oled.drawCircle(64,32,31,WHITE);
oled.display();
delay(1000);

oled.clearDisplay();
oled.fillCircle(64,32,31,WHITE);
oled.fillCircle(64,32,24,BLACK);
oled.display();
delay(1000);

}

#include <SPI.h>

#include <Wire.h>

#include <Adafruit_GFX.h>

#include <Adafruit_SSD1306.h>

int screenWidth = 128;

int screenHeight = 64;

int oledReset = -1;

#define SCREEN_ADDRESS 0x3C

Adafruit_SSD1306 oled(screenWidth,screenHeight,&Wire,oledReset);

void setup() {

// put your setup code here, to run once:

Serial.begin(9600);

oled.begin(SSD1306_SWITCHCAPVCC, SCREEN_ADDRESS);

}

void loop() {

// put your main code here, to run repeatedly:

oled.clearDisplay();

oled.display();

oled.setCursor(0,12);

oled.setTextColor(WHITE);

oled.setTextSize(3);

oled.println(" Hello");

oled.println(" World!");

oled.display();

delay(1000);

oled.invertDisplay(1);

delay(1000);

oled.invertDisplay(0);

delay(1000);

oled.clearDisplay();

oled.drawPixel(64,32,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawLine(0,0,127,63,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawLine(0,32,127,32,WHITE);

oled.drawLine(64,0,64,63,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawRect(0,0,128,64,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.fillRect(0,0,128,64,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.fillRect(0,0,128,64,WHITE);

oled.fillRect(5,5,118,54,BLACK);

oled.display();

delay(1000);

oled.clearDisplay();

oled.drawCircle(64,32,31,WHITE);

oled.display();

delay(1000);

oled.clearDisplay();

oled.fillCircle(64,32,31,WHITE);

oled.fillCircle(64,32,24,BLACK);

oled.display();

delay(1000);

}

Technology Tutorials

Tag Archives: OLED

Portable Arduino Weather Station Project

Plot any Data or Graph on any OLED

Portable Distance Measurement Project With HC-SR04 Ultrasonic Sensor

Arduino Project for a Portable Ultrasonic Distance Sensor

Using the SSD1306 OLED With an Arduino

Making The World a Better Place One High Tech Project at a Time. Enjoy!