Tag Archives: Arduino Uno R4 WiFi

In this video lesson we continue to improve our Arduino IMU project incorporating the GY-87 9-axis sensor module. In last weeks lesson, we had added tilt compensation to the project, so the IMU reports accurate Heading values, even if the sensor is tilted. This creates a tilt compensated digital compass. We are now getting ready to begin building graphical displays on the SSD1306 OLED display. In order to do that, we must clean up a few things on the project. First, our compass presently reports headings between +/- 180 degrees. For standard compasses, North is a heading of 0 degrees, and rotating clockwise reports increasing number, up to 359. Then the compass returns to North, as it has been rotated all the way around. The other issue we clean up in todays lesson is associated with the so called wrap around glitch. That is, if we move only two degrees, from 1 degree to 359 degrees, it is a very small physical change, but the complimentary filter sees it as a large change, and it filters that change. The practical implication of this is that the needle on the compass will take the long way around the dial when making this transition, and it creates a very awkward glitch in the display. We will show you how to solve the wrap around glitch.

This is the schematic we have been using for this project:

MPU6050 — Schematic for connecting the GY-87 module to the Arduino

This is the code we developed in today’s lesson. Understand, you must calibrate your sensor module, as we taught in THIS LESSON. Then you need to put those calibration values into the code below for it to work accurately for your sensor module.

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
#include <QMC5883LCompass.h>
float AxRaw,AyRaw,AzRaw,GxRaw,GyRaw,GzRaw,MxRaw,MyRaw,MzRaw;
float AxCal,AyCal,AzCal,GxCal,GyCal,GzCal,MxCal,MyCal,MzCal;
float rollA,pitchA,yawM,rollC,pitchC,yawC;
float rollG = 0;
float pitchG =0 ;
float yawG = 0;
float deltaRoll = 0;
float deltaPitch = 0;
float deltaYaw = 0;
float alpha = .1;
float rollCrad;
float pitchCrad;

float MxCalH; 
float MyCalH;
int tStart =millis();
Adafruit_MPU6050 mpu;
QMC5883LCompass compass;

void setup() {
  // put your setup code here, to run once:
Serial.begin(115200);
mpu.begin();
mpu.setI2CBypass(true);
compass.init();
mpu.setGyroRange(MPU6050_RANGE_1000_DEG);
delay(100);
}

void calibrateSensors() {
    const float axOffset = 0.45407887789180545;
    const float ayOffset = 0.09432915233553185;
    const float azOffset = -0.4614157209191969;
    const float axScale = 0.10141341897341144;
    const float ayScale = 0.10141341897341144;
    const float azScale = 0.10141341897341144;
    const float gxOffset = -2.277507235645022;
    const float gyOffset = 0.8794902155258137;
    const float gzOffset = -0.5729577951308232;
    const float mxOffset = -103.48885017294003;
    const float myOffset = -96.80085481152321;
    const float mzOffset = 923.8042898128733;
    const float mxScale = 0.001156333898601669;
    const float myScale = 0.001012882116988885;
    const float mzScale = 0.0009400860982065997;
 
    AxCal = (AxRaw - axOffset) * axScale;
    AyCal = (AyRaw - ayOffset) * ayScale;
    AzCal = (AzRaw - azOffset) * azScale;
    GxCal = GxRaw*180/PI - gxOffset;
    GyCal = GyRaw*180/PI - gyOffset;
    GzCal = GzRaw*180/PI - gzOffset;
    MxCal = (MxRaw - mxOffset) * mxScale;
    MyCal = (MyRaw - myOffset) * myScale;
    MzCal = (MzRaw - mzOffset) * mzScale;
}

void loop() {
  // put your main code here, to run repeatedly:
compass.read();
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);

AxRaw = a.acceleration.x;
AyRaw = a.acceleration.y;
AzRaw = a.acceleration.z;

GxRaw = g.gyro.x;
GyRaw = g.gyro.y;
GzRaw = g.gyro.z;

MxRaw= compass.getX();
MyRaw= compass.getY();
MzRaw= compass.getZ();

calibrateSensors();

rollA = atan2(AyCal,sqrt(AzCal*AzCal + AxCal*AxCal))*180/PI;
pitchA = atan2(AxCal,sqrt(AzCal*AzCal + AyCal*AyCal))*180/PI;

deltaRoll = GxCal*(millis()-tStart)/1000.;
deltaPitch = -GyCal*(millis()-tStart)/1000.;
deltaYaw = -GzCal*(millis()-tStart)/1000.;
tStart = millis();

rollG = rollG + deltaRoll;
pitchG = pitchG + deltaPitch;
yawG = yawG + deltaYaw;

rollC = alpha*(rollA) + (1-alpha)*(rollC+deltaRoll);
pitchC = alpha*(pitchA) + (1-alpha)*(pitchC+deltaPitch);

rollCrad = rollC*PI/180;
pitchCrad = pitchC*PI/180;

MxCalH = MxCal*cos(pitchCrad) -MyCal*sin(rollCrad)*sin(pitchCrad)-MzCal*cos(rollCrad)*sin(pitchCrad);
MyCalH = MyCal*cos(rollCrad) - MzCal*sin(rollCrad);

yawM = atan2(MyCalH,MxCalH)*180./PI;
yawM=int(yawM +360)%360;
if (abs(yawM-yawC)>300){
  yawC=yawM;
}
if (abs(yawM-yawC)<=300){
yawC = alpha*(yawM) + (1-alpha)*(yawC + deltaYaw);
}

// Serial.print("yawC:");Serial.print(yawC);Serial.print(',');
// Serial.print("yawM:");Serial.print(yawM);Serial.print(',');
// Serial.print("yawG:");Serial.print(yawG);Serial.print(',');
// Serial.print("LL:");Serial.print(-90);Serial.print(',');
// Serial.print("UL:");Serial.println(90);

Serial.print("rollC:");Serial.print(rollC);Serial.print(',');
Serial.print("pitchC:");Serial.print(pitchC);Serial.print(',');
Serial.print("yawC:");Serial.print(yawC);Serial.print(',');
Serial.print("LL:");Serial.print(-90);Serial.print(',');
Serial.print("UL:");Serial.println(90);

delay(100);
}

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

#include <Adafruit_MPU6050.h>

#include <Adafruit_Sensor.h>

#include <Wire.h>

#include <QMC5883LCompass.h>

float AxRaw,AyRaw,AzRaw,GxRaw,GyRaw,GzRaw,MxRaw,MyRaw,MzRaw;

float AxCal,AyCal,AzCal,GxCal,GyCal,GzCal,MxCal,MyCal,MzCal;

float rollA,pitchA,yawM,rollC,pitchC,yawC;

float rollG = 0;

float pitchG =0 ;

float yawG = 0;

float deltaRoll = 0;

float deltaPitch = 0;

float deltaYaw = 0;

float alpha = .1;

float rollCrad;

float pitchCrad;

float MxCalH;

float MyCalH;

int tStart =millis();

Adafruit_MPU6050 mpu;

QMC5883LCompass compass;

void setup() {

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

Serial.begin(115200);

mpu.begin();

mpu.setI2CBypass(true);

compass.init();

mpu.setGyroRange(MPU6050_RANGE_1000_DEG);

delay(100);

}

void calibrateSensors() {

const float axOffset = 0.45407887789180545;

const float ayOffset = 0.09432915233553185;

const float azOffset = -0.4614157209191969;

const float axScale = 0.10141341897341144;

const float ayScale = 0.10141341897341144;

const float azScale = 0.10141341897341144;

const float gxOffset = -2.277507235645022;

const float gyOffset = 0.8794902155258137;

const float gzOffset = -0.5729577951308232;

const float mxOffset = -103.48885017294003;

const float myOffset = -96.80085481152321;

const float mzOffset = 923.8042898128733;

const float mxScale = 0.001156333898601669;

const float myScale = 0.001012882116988885;

const float mzScale = 0.0009400860982065997;

AxCal = (AxRaw - axOffset) * axScale;

AyCal = (AyRaw - ayOffset) * ayScale;

AzCal = (AzRaw - azOffset) * azScale;

GxCal = GxRaw*180/PI - gxOffset;

GyCal = GyRaw*180/PI - gyOffset;

GzCal = GzRaw*180/PI - gzOffset;

MxCal = (MxRaw - mxOffset) * mxScale;

MyCal = (MyRaw - myOffset) * myScale;

MzCal = (MzRaw - mzOffset) * mzScale;

}

void loop() {

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

compass.read();

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

AxRaw = a.acceleration.x;

AyRaw = a.acceleration.y;

AzRaw = a.acceleration.z;

GxRaw = g.gyro.x;

GyRaw = g.gyro.y;

GzRaw = g.gyro.z;

MxRaw= compass.getX();

MyRaw= compass.getY();

MzRaw= compass.getZ();

calibrateSensors();

rollA = atan2(AyCal,sqrt(AzCal*AzCal + AxCal*AxCal))*180/PI;

pitchA = atan2(AxCal,sqrt(AzCal*AzCal + AyCal*AyCal))*180/PI;

deltaRoll = GxCal*(millis()-tStart)/1000.;

deltaPitch = -GyCal*(millis()-tStart)/1000.;

deltaYaw = -GzCal*(millis()-tStart)/1000.;

tStart = millis();

rollG = rollG + deltaRoll;

pitchG = pitchG + deltaPitch;

yawG = yawG + deltaYaw;

rollC = alpha*(rollA) + (1-alpha)*(rollC+deltaRoll);

pitchC = alpha*(pitchA) + (1-alpha)*(pitchC+deltaPitch);

rollCrad = rollC*PI/180;

pitchCrad = pitchC*PI/180;

MxCalH = MxCal*cos(pitchCrad) -MyCal*sin(rollCrad)*sin(pitchCrad)-MzCal*cos(rollCrad)*sin(pitchCrad);

MyCalH = MyCal*cos(rollCrad) - MzCal*sin(rollCrad);

yawM = atan2(MyCalH,MxCalH)*180./PI;

yawM=int(yawM +360)%360;

if (abs(yawM-yawC)>300){

yawC=yawM;

}

if (abs(yawM-yawC)<=300){

yawC = alpha*(yawM) + (1-alpha)*(yawC + deltaYaw);

}

// Serial.print("yawC:");Serial.print(yawC);Serial.print(',');

// Serial.print("yawM:");Serial.print(yawM);Serial.print(',');

// Serial.print("yawG:");Serial.print(yawG);Serial.print(',');

// Serial.print("LL:");Serial.print(-90);Serial.print(',');

// Serial.print("UL:");Serial.println(90);

Serial.print("rollC:");Serial.print(rollC);Serial.print(',');

Serial.print("pitchC:");Serial.print(pitchC);Serial.print(',');

Serial.print("yawC:");Serial.print(yawC);Serial.print(',');

Serial.print("LL:");Serial.print(-90);Serial.print(',');

Serial.print("UL:");Serial.println(90);

delay(100);

}

Arduino, Arduino 9-Axis IMU Totorials, Tutorial

Tilt Compensated Digital Compass

November 14, 2025 admin

In this video lesson we show how to create a tilt compensated digital compass. Calculating heading based simply on the measured magnetometer values in the X and Y directions only works accurately when the compass is sitting flat, or horizontal with the earth’s surface. If we introduce a tilt, either by applying pitch or roll to the system, calculated heading, or yaw will no longer be accurate. In the video above, we show you how to mathematically ‘un-tilt’ the sensor to get accurate heading readings when the device is not perfectly flat.

We are working with a GY-87 9-axis IMU, and an Arduino Uno R4 WiFi. Below is the schematic we are using in this project:

For your convenience, the code developed in this video lesson is included below. Please notice that the calibration constants in the code below are for my GY-87 module. You need to calibrate your own module, as my numbers below would likely be different from your numbers. We showed how to do the calibration in THIS LESSON.

#include <Adafruit_MPU6050.h>
#include <Adafruit_Sensor.h>
#include <Wire.h>
#include <QMC5883LCompass.h>
float AxRaw,AyRaw,AzRaw,GxRaw,GyRaw,GzRaw,MxRaw,MyRaw,MzRaw;
float AxCal,AyCal,AzCal,GxCal,GyCal,GzCal,MxCal,MyCal,MzCal;
float rollA,pitchA,yawM,rollC,pitchC,yawC;
float rollG = 0;
float pitchG =0 ;
float yawG = 0;
float deltaRoll = 0;
float deltaPitch = 0;
float deltaYaw = 0;
float alpha = .1;
float rollCrad;
float pitchCrad;

float MxCalH; 
float MyCalH;
int tStart =millis();
Adafruit_MPU6050 mpu;
QMC5883LCompass compass;

void setup() {
  // put your setup code here, to run once:
Serial.begin(115200);
mpu.begin();
mpu.setI2CBypass(true);
compass.init();
mpu.setGyroRange(MPU6050_RANGE_1000_DEG);
delay(100);
}

void calibrateSensors() {
    const float axOffset = 0.45407887789180545;
    const float ayOffset = 0.09432915233553185;
    const float azOffset = -0.4614157209191969;
    const float axScale = 0.10141341897341144;
    const float ayScale = 0.10141341897341144;
    const float azScale = 0.10141341897341144;
    const float gxOffset = -2.277507235645022;
    const float gyOffset = 0.8794902155258137;
    const float gzOffset = -0.5729577951308232;
    const float mxOffset = -103.48885017294003;
    const float myOffset = -96.80085481152321;
    const float mzOffset = 923.8042898128733;
    const float mxScale = 0.001156333898601669;
    const float myScale = 0.001012882116988885;
    const float mzScale = 0.0009400860982065997;
 
    AxCal = (AxRaw - axOffset) * axScale;
    AyCal = (AyRaw - ayOffset) * ayScale;
    AzCal = (AzRaw - azOffset) * azScale;
    GxCal = GxRaw*180/PI - gxOffset;
    GyCal = GyRaw*180/PI - gyOffset;
    GzCal = GzRaw*180/PI - gzOffset;
    MxCal = (MxRaw - mxOffset) * mxScale;
    MyCal = (MyRaw - myOffset) * myScale;
    MzCal = (MzRaw - mzOffset) * mzScale;
}

void loop() {
  // put your main code here, to run repeatedly:
compass.read();
sensors_event_t a, g, temp;
mpu.getEvent(&a, &g, &temp);

AxRaw = a.acceleration.x;
AyRaw = a.acceleration.y;
AzRaw = a.acceleration.z;

GxRaw = g.gyro.x;
GyRaw = g.gyro.y;
GzRaw = g.gyro.z;

MxRaw= compass.getX();
MyRaw= compass.getY();
MzRaw= compass.getZ();

calibrateSensors();

rollA = atan2(AyCal,sqrt(AzCal*AzCal + AxCal*AxCal))*180/PI;
pitchA = atan2(AxCal,sqrt(AzCal*AzCal + AyCal*AyCal))*180/PI;

deltaRoll = GxCal*(millis()-tStart)/1000.;
deltaPitch = -GyCal*(millis()-tStart)/1000.;
deltaYaw = -GzCal*(millis()-tStart)/1000.;
tStart = millis();

rollG = rollG + deltaRoll;
pitchG = pitchG + deltaPitch;
yawG = yawG + deltaYaw;

rollC = alpha*(rollA) + (1-alpha)*(rollC+deltaRoll);
pitchC = alpha*(pitchA) + (1-alpha)*(pitchC+deltaPitch);

rollCrad = rollC*PI/180;
pitchCrad = pitchC*PI/180;

MxCalH = MxCal*cos(pitchCrad) -MyCal*sin(rollCrad)*sin(pitchCrad)-MzCal*cos(rollCrad)*sin(pitchCrad);
MyCalH = MyCal*cos(rollCrad) - MzCal*sin(rollCrad);

yawM = atan2(MyCalH,MxCalH)*180./PI;
yawC = alpha*(yawM) + (1-alpha)*(yawC + deltaYaw);

// Serial.print("yawC:");Serial.print(yawC);Serial.print(',');
// Serial.print("yawM:");Serial.print(yawM);Serial.print(',');
// Serial.print("yawG:");Serial.print(yawG);Serial.print(',');
// Serial.print("LL:");Serial.print(-90);Serial.print(',');
// Serial.print("UL:");Serial.println(90);

Serial.print("rollC:");Serial.print(rollC);Serial.print(',');
Serial.print("pitchC:");Serial.print(pitchC);Serial.print(',');
Serial.print("yawC:");Serial.print(yawC);Serial.print(',');
Serial.print("LL:");Serial.print(-90);Serial.print(',');
Serial.print("UL:");Serial.println(90);

delay(100);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

#include <Adafruit_MPU6050.h>

#include <Adafruit_Sensor.h>

#include <Wire.h>

#include <QMC5883LCompass.h>

float AxRaw,AyRaw,AzRaw,GxRaw,GyRaw,GzRaw,MxRaw,MyRaw,MzRaw;

float AxCal,AyCal,AzCal,GxCal,GyCal,GzCal,MxCal,MyCal,MzCal;

float rollA,pitchA,yawM,rollC,pitchC,yawC;

float rollG = 0;

float pitchG =0 ;

float yawG = 0;

float deltaRoll = 0;

float deltaPitch = 0;

float deltaYaw = 0;

float alpha = .1;

float rollCrad;

float pitchCrad;

float MxCalH;

float MyCalH;

int tStart =millis();

Adafruit_MPU6050 mpu;

QMC5883LCompass compass;

void setup() {

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

Serial.begin(115200);

mpu.begin();

mpu.setI2CBypass(true);

compass.init();

mpu.setGyroRange(MPU6050_RANGE_1000_DEG);

delay(100);

}

void calibrateSensors() {

const float axOffset = 0.45407887789180545;

const float ayOffset = 0.09432915233553185;

const float azOffset = -0.4614157209191969;

const float axScale = 0.10141341897341144;

const float ayScale = 0.10141341897341144;

const float azScale = 0.10141341897341144;

const float gxOffset = -2.277507235645022;

const float gyOffset = 0.8794902155258137;

const float gzOffset = -0.5729577951308232;

const float mxOffset = -103.48885017294003;

const float myOffset = -96.80085481152321;

const float mzOffset = 923.8042898128733;

const float mxScale = 0.001156333898601669;

const float myScale = 0.001012882116988885;

const float mzScale = 0.0009400860982065997;

AxCal = (AxRaw - axOffset) * axScale;

AyCal = (AyRaw - ayOffset) * ayScale;

AzCal = (AzRaw - azOffset) * azScale;

GxCal = GxRaw*180/PI - gxOffset;

GyCal = GyRaw*180/PI - gyOffset;

GzCal = GzRaw*180/PI - gzOffset;

MxCal = (MxRaw - mxOffset) * mxScale;

MyCal = (MyRaw - myOffset) * myScale;

MzCal = (MzRaw - mzOffset) * mzScale;

}

void loop() {

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

compass.read();

sensors_event_t a, g, temp;

mpu.getEvent(&a, &g, &temp);

AxRaw = a.acceleration.x;

AyRaw = a.acceleration.y;

AzRaw = a.acceleration.z;

GxRaw = g.gyro.x;

GyRaw = g.gyro.y;

GzRaw = g.gyro.z;

MxRaw= compass.getX();

MyRaw= compass.getY();

MzRaw= compass.getZ();

calibrateSensors();

rollA = atan2(AyCal,sqrt(AzCal*AzCal + AxCal*AxCal))*180/PI;

pitchA = atan2(AxCal,sqrt(AzCal*AzCal + AyCal*AyCal))*180/PI;

deltaRoll = GxCal*(millis()-tStart)/1000.;

deltaPitch = -GyCal*(millis()-tStart)/1000.;

deltaYaw = -GzCal*(millis()-tStart)/1000.;

tStart = millis();

rollG = rollG + deltaRoll;

pitchG = pitchG + deltaPitch;

yawG = yawG + deltaYaw;

rollC = alpha*(rollA) + (1-alpha)*(rollC+deltaRoll);

pitchC = alpha*(pitchA) + (1-alpha)*(pitchC+deltaPitch);

rollCrad = rollC*PI/180;

pitchCrad = pitchC*PI/180;

MxCalH = MxCal*cos(pitchCrad) -MyCal*sin(rollCrad)*sin(pitchCrad)-MzCal*cos(rollCrad)*sin(pitchCrad);

MyCalH = MyCal*cos(rollCrad) - MzCal*sin(rollCrad);

yawM = atan2(MyCalH,MxCalH)*180./PI;

yawC = alpha*(yawM) + (1-alpha)*(yawC + deltaYaw);

// Serial.print("yawC:");Serial.print(yawC);Serial.print(',');

// Serial.print("yawM:");Serial.print(yawM);Serial.print(',');

// Serial.print("yawG:");Serial.print(yawG);Serial.print(',');

// Serial.print("LL:");Serial.print(-90);Serial.print(',');

// Serial.print("UL:");Serial.println(90);

Serial.print("rollC:");Serial.print(rollC);Serial.print(',');

Serial.print("pitchC:");Serial.print(pitchC);Serial.print(',');

Serial.print("yawC:");Serial.print(yawC);Serial.print(',');

Serial.print("LL:");Serial.print(-90);Serial.print(',');

Serial.print("UL:");Serial.println(90);

delay(100);

}

Arduino, Python

Parsing Comma Delimited Data Strings in Arduino

May 1, 2025 admin

In this lesson we are working on a client server connection. The Arduino is the server, and a python program on a desktop PC is the client. The objective is to control the color of an RGB LED from the client. The client will send data to the server as comma delimited string, like 255,0,255 for RGB. The challenge on the server side is to parse this data so we get integer values of:

R=255

G=0

B=255

In this video lesson we start by simply controlling two LED, a red and green one, from the python client. We then show how we can control an RGB LED by sending the data string from the client, and parsing it on the server side. For your convenience, we include the code here:

Server Side code for the Arduino:

#include <WiFiS3.h>
#include "secrets.h"
WiFiUDP udp;
int PORT = 12345;
char myPacket[255];
int dataLen;
String color;
String response;
int redPin = 8;
int greenPin = 9;
int R;
int G;
int B;
int firstComma;
int secondComma;
void setup() {
  Serial.begin(9600);
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  Serial.print("Connecting to ");
  Serial.println(SSID);
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
    Serial.print(".");
  }
  Serial.println("\nConnected to WiFi");
  Serial.println(WiFi.localIP());
  udp.begin(PORT);
  Serial.print("UDP Server started on port ");
  Serial.print(PORT);
  // put your setup code here, to run once:
}

void loop() {
  // put your main code here, to run repeatedly:
  if (udp.parsePacket()) {
    dataLen = udp.available();
    Serial.println(dataLen);
    udp.read(myPacket, 255);
    Serial.println(myPacket);
    myPacket[dataLen] = 0;
    Serial.println(myPacket);
    color = String(myPacket);
    color.trim();
    Serial.println("Received color: " + color);
    firstComma=color.indexOf(',',0);
    secondComma=color.indexOf(',',firstComma+1);
    R=color.substring(0,firstComma).toInt();
    G=color.substring(firstComma+1,secondComma).toInt();
    B=color.substring(secondComma+1).toInt();
    Serial.println(R);
    Serial.println(G);
    Serial.println(B);
    udp.beginPacket(udp.remoteIP(), udp.remotePort());
    udp.print(response);
    udp.endPacket();
    Serial.println("SENT: " + response);
  }
}

#include <WiFiS3.h>

#include "secrets.h"

WiFiUDP udp;

int PORT = 12345;

char myPacket[255];

int dataLen;

String color;

String response;

int redPin = 8;

int greenPin = 9;

int R;

int G;

int B;

int firstComma;

int secondComma;

void setup() {

Serial.begin(9600);

pinMode(redPin, OUTPUT);

pinMode(greenPin, OUTPUT);

Serial.print("Connecting to ");

Serial.println(SSID);

WiFi.begin(SSID, PASS);

while (WiFi.status() != WL_CONNECTED) {

delay(100);

Serial.print(".");

}

Serial.println("\nConnected to WiFi");

Serial.println(WiFi.localIP());

udp.begin(PORT);

Serial.print("UDP Server started on port ");

Serial.print(PORT);

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

}

void loop() {

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

if (udp.parsePacket()) {

dataLen = udp.available();

Serial.println(dataLen);

udp.read(myPacket, 255);

Serial.println(myPacket);

myPacket[dataLen] = 0;

Serial.println(myPacket);

color = String(myPacket);

color.trim();

Serial.println("Received color: " + color);

firstComma=color.indexOf(',',0);

secondComma=color.indexOf(',',firstComma+1);

R=color.substring(0,firstComma).toInt();

G=color.substring(firstComma+1,secondComma).toInt();

B=color.substring(secondComma+1).toInt();

Serial.println(R);

Serial.println(G);

Serial.println(B);

udp.beginPacket(udp.remoteIP(), udp.remotePort());

udp.print(response);

udp.endPacket();

Serial.println("SENT: " + response);

}

The code above needs a ‘secrets.h’ file which includes your WiFi name and password. This is created in the IDE by choosing ‘Add Tab’. Call the new tab ‘secrets.h’, and edit the code below to include your WiFi name and passwords inside the quotes:

#define SSID "Your WiFi Name"
#define PASS "Your WiFi Password"

1 2	#define SSID "Your WiFi Name" #define PASS "Your WiFi Password"

Now, on the client side, this is our standard Python client:

import socket

# Arduino’s IP address (from Arduino Serial Monitor)
HOST = "192.168.88.77"  # Use Your Arduino's IP. It will print when
                        #You Run the Arduino Server Program
PORT = 12345            # Must match Arduino’s UDP port

# Create a UDP socket
mySocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
mySocket.settimeout(5.0)  # 5 seconds timeout for responses

print("UDP Client started. Enter a color (or 'quit' to exit).")

while True:
    # Prompt for a color
    #color = input("Enter a color: ").strip()  # Remove whitespace
    color = input("Enter a color: ") 
    if color.lower() == 'quit':  # Exit condition
        break

    # Send the color to the server
    sendColor=color.encode()
    mySocket.sendto(sendColor, (HOST, PORT))
    print('Sent '+color+' to HOST',HOST,PORT)

    # Try to get a response, skip on timeout
    try:
        response, server_address = mySocket.recvfrom(1024)
        print("Server response:", response.decode())
    except socket.timeout:
        print("No response received from server within 5 seconds")

# Close the socket
mySocket.close()
print("Socket closed")

import socket

# Arduino’s IP address (from Arduino Serial Monitor)

HOST = "192.168.88.77" # Use Your Arduino's IP. It will print when

#You Run the Arduino Server Program

PORT = 12345 # Must match Arduino’s UDP port

# Create a UDP socket

mySocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

mySocket.settimeout(5.0) # 5 seconds timeout for responses

print("UDP Client started. Enter a color (or 'quit' to exit).")

while True:

# Prompt for a color

#color = input("Enter a color: ").strip() # Remove whitespace

color = input("Enter a color: ")

if color.lower() == 'quit': # Exit condition

break

# Send the color to the server

sendColor=color.encode()

mySocket.sendto(sendColor, (HOST, PORT))

print('Sent '+color+' to HOST',HOST,PORT)

# Try to get a response, skip on timeout

try:

response, server_address = mySocket.recvfrom(1024)

print("Server response:", response.decode())

except socket.timeout:

print("No response received from server within 5 seconds")

# Close the socket

mySocket.close()

print("Socket closed")

With this code for creating a client and server, and then parsing comma delimited text, you can easily add the code needed to control the RGB LED color to the arduino program.

Arduino, Python

Create a Simple Client Server Connection Over WiFi to Connect Arduino to Python on the PC

April 24, 2025 admin

In this video lesson, we show how to create a simple Client/Server connection over WiFi. We connect the Arduino Uno R4 WiFi to Python running on the PC. The arduino is the server, and the PC Python program is the client. We show how to pass data from the PC to the Arduino, and then how to pass data from the Arduino back to the PC. With this simple framework, we can control Arduino projects from our desktop PC, and we can use the PC to display data being taken from the Arduino.

In this lesson we develop code for Arduino, and the code in Python. For your convenience, we present the code below.

On the Arduino Side, this is the code to create the ‘Server’.

#include <WiFiS3.h>
#include "secrets.h"
WiFiUDP udp;
int PORT = 12345;
char myPacket[255];
int dataLen;
String color;
String response;
void setup() {
  Serial.begin(9600);
  Serial.print("Connecting to ");
  Serial.println(SSID);
  WiFi.begin(SSID, PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
    Serial.print(".");
  }
  Serial.println("\nConnected to WiFi");
  Serial.println(WiFi.localIP());
  udp.begin(PORT);
  Serial.print("UDP Server started on port ");
  Serial.print(PORT);
  // put your setup code here, to run once:
}

void loop() {
  // put your main code here, to run repeatedly:
  if (udp.parsePacket()) {
    dataLen = udp.available();
    Serial.println(dataLen);
  udp.read(myPacket,255);
  Serial.println(myPacket);
  myPacket[dataLen]=0;
  Serial.println(myPacket);
  color=String(myPacket);
  color.trim();
  Serial.println("Received color: "+color);
  response ="Here is your "+color+" Marble";  
 udp.beginPacket(udp.remoteIP(), udp.remotePort());
 udp.print(response);
 udp.endPacket();
  Serial.println("SENT: "+response);
  }
}

#include <WiFiS3.h>

#include "secrets.h"

WiFiUDP udp;

int PORT = 12345;

char myPacket[255];

int dataLen;

String color;

String response;

void setup() {

Serial.begin(9600);

Serial.print("Connecting to ");

Serial.println(SSID);

WiFi.begin(SSID, PASS);

while (WiFi.status() != WL_CONNECTED) {

delay(100);

Serial.print(".");

}

Serial.println("\nConnected to WiFi");

Serial.println(WiFi.localIP());

udp.begin(PORT);

Serial.print("UDP Server started on port ");

Serial.print(PORT);

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

}

void loop() {

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

if (udp.parsePacket()) {

dataLen = udp.available();

Serial.println(dataLen);

udp.read(myPacket,255);

Serial.println(myPacket);

myPacket[dataLen]=0;

Serial.println(myPacket);

color=String(myPacket);

color.trim();

Serial.println("Received color: "+color);

response ="Here is your "+color+" Marble";

udp.beginPacket(udp.remoteIP(), udp.remotePort());

udp.print(response);

udp.endPacket();

Serial.println("SENT: "+response);

}

You also need to add a tab to your program using the ‘Add Tab’ feature of the IDE. The program in the tab should be named secrets.h

Your secrets.h file should look like this:

#define SSID "Your WiFi Name"
#define PASS "your Wifi Password"

1 2	#define SSID "Your WiFi Name" #define PASS "your Wifi Password"

You can run the program above, and it should connect to your WiFi, and should print out the Arduino’s IP address. Make note of the IP address as it will be needed in the Client program below. On the PC side, this is the python code to create the client:

import socket

# Arduino’s IP address (from Arduino Serial Monitor)
HOST = "192.168.88.77"  # Use Your Arduino's IP. It will print when
                        #You Run the Arduino Server Program
PORT = 12345            # Must match Arduino’s UDP port

# Create a UDP socket
mySocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
mySocket.settimeout(5.0)  # 5 seconds timeout for responses

print("UDP Client started. Enter a color (or 'quit' to exit).")

while True:
    # Prompt for a color
    #color = input("Enter a color: ").strip()  # Remove whitespace
    color = input("Enter a color: ") 
    if color.lower() == 'quit':  # Exit condition
        break

    # Send the color to the server
    sendColor=color.encode()
    mySocket.sendto(sendColor, (HOST, PORT))
    print('Sent '+color+' to HOST',HOST,PORT)

    # Try to get a response, skip on timeout
    try:
        response, server_address = mySocket.recvfrom(1024)
        print("Server response:", response.decode())
    except socket.timeout:
        print("No response received from server within 5 seconds")

# Close the socket
mySocket.close()
print("Socket closed")

import socket

# Arduino’s IP address (from Arduino Serial Monitor)

HOST = "192.168.88.77" # Use Your Arduino's IP. It will print when

#You Run the Arduino Server Program

PORT = 12345 # Must match Arduino’s UDP port

# Create a UDP socket

mySocket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

mySocket.settimeout(5.0) # 5 seconds timeout for responses

print("UDP Client started. Enter a color (or 'quit' to exit).")

while True:

# Prompt for a color

#color = input("Enter a color: ").strip() # Remove whitespace

color = input("Enter a color: ")

if color.lower() == 'quit': # Exit condition

break

# Send the color to the server

sendColor=color.encode()

mySocket.sendto(sendColor, (HOST, PORT))

print('Sent '+color+' to HOST',HOST,PORT)

# Try to get a response, skip on timeout

try:

response, server_address = mySocket.recvfrom(1024)

print("Server response:", response.decode())

except socket.timeout:

print("No response received from server within 5 seconds")

# Close the socket

mySocket.close()

print("Socket closed")

Arduino

Portable Arduino Weather Station Project

March 20, 2025 admin

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.

When using the breadvolt, or any battery power supply on a breadboard project, do not turn the power supply on while the Arduino is connected to USB, as you could generate voltage conflicts. It is an either or. If the USB is connected, the power supply should be OFF. Or if you are going to connect the USB, first turn off the power supply.

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); //***********

}

Technology Tutorials

Tag Archives: Arduino Uno R4 WiFi

Removing Digital Compass Glitches and Wrap Around Issues

Tilt Compensated Digital Compass

Parsing Comma Delimited Data Strings in Arduino

Create a Simple Client Server Connection Over WiFi to Connect Arduino to Python on the PC

Portable Arduino Weather Station Project

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