Member Avatar for Dietrich_3

The Arduino micro controller is a great interface that allows your computer to do things with the world around it. It can measure and record things like temperature, humidity, light (also infrared signals), sound, motion, distance, magnetism and color. It can blink and buzz, run motors, water your plants and sniff trails to follow and whatever else you want to do to enjoy.

The UNO model is about $10, and a kit with a fist full of sensors goes for as little as 40 bucks. It uses C++ to program. Once programmed you can disconnect it, it will work on its own. Don't be afraid of C++, it is as simple as Python with a lot of semicolons to trip over.

A computer without an Arduino is only half there!

Edited by Dietrich_3
  • 4 Contributors
  • 39 Replies
  • 273 Views
  • 4 Weeks Discussion Span
  • Latest Post Latest Post by Dietrich_3

Recommended Answers

All 39 Replies

Member Avatar for Dietrich_3

Here is a typical example for an analog input, setup() and loop() are are boiler plate function names:

/*
  Analog Input.io

  Demonstrates analog input by reading an analog sensor on analog pin 0 and
  turning on and off a light emitting diode(LED) connected to digital pin 13.
  The amount of time the LED will be on and off depends on the value obtained
  by analogRead().

  The circuit:
  - potentiometer
    center pin of the potentiometer to the analog input 0
    one side pin (either one) to ground
    the other side pin to +5V
  - LED
    anode (long leg) attached to digital output 13 through 220 ohm resistor
    cathode (short leg) attached to ground

  - Note: because most Arduinos have a built-in LED attached to pin 13 on the
    board, the LED is optional.

  created by David Cuartielles
  modified 30 Aug 2011
  By Tom Igoe

  This example code is in the public domain.

  https://docs.arduino.cc/built-in-examples/analog/AnalogInput/
*/

int sensorPin = A0;   // select the input pin for the potentiometer
int ledPin = 13;      // select the pin for the LED
int sensorValue = 0;  // variable to store the value coming from the sensor

void setup() {
  // declare the ledPin as an OUTPUT:
  pinMode(ledPin, OUTPUT);
}

void loop() {
  // read the value from the sensor:
  sensorValue = analogRead(sensorPin);
  // turn the ledPin on
  digitalWrite(ledPin, HIGH);
  // stop the program for <sensorValue> milliseconds:
  delay(sensorValue);
  // turn the ledPin off:
  digitalWrite(ledPin, LOW);
  // stop the program for <sensorValue> milliseconds:
  delay(sensorValue);
}
Edited by Dietrich_3
Member Avatar for Dietrich_3

Sorry,
this Arduino sample code has a bit more power:

/*
  Smoothing.txt

  Reads repeatedly from an analog input, calculating a running average and
  printing it to the computer. Keeps ten readings in an array and continually
  averages them.

  The circuit:
  - analog sensor (potentiometer will do) attached to analog input 0

  created 22 Apr 2007
  by David A. Mellis  <dam@mellis.org>
  modified 9 Apr 2012
  by Tom Igoe

  This example code is in the public domain.

  https://docs.arduino.cc/built-in-examples/analog/Smoothing/
*/

// Define the number of samples to keep track of. The higher the number, the
// more the readings will be smoothed, but the slower the output will respond to
// the input. Using a constant rather than a normal variable lets us use this
// value to determine the size of the readings array.
const int numReadings = 10;

int readings[numReadings];  // the readings from the analog input
int readIndex = 0;          // the index of the current reading
int total = 0;              // the running total
int average = 0;            // the average

int inputPin = A0;

void setup() {
  // initialize serial communication with computer:
  Serial.begin(9600);
  // initialize all the readings to 0:
  for (int thisReading = 0; thisReading < numReadings; thisReading++) {
    readings[thisReading] = 0;
  }
}

void loop() {
  // subtract the last reading:
  total = total - readings[readIndex];
  // read from the sensor:
  readings[readIndex] = analogRead(inputPin);
  // add the reading to the total:
  total = total + readings[readIndex];
  // advance to the next position in the array:
  readIndex = readIndex + 1;

  // if we're at the end of the array...
  if (readIndex >= numReadings) {
    // ...wrap around to the beginning:
    readIndex = 0;
  }

  // calculate the average:
  average = total / numReadings;
  // send it to the computer as ASCII digits
  Serial.println(average);
  delay(1);  // delay in between reads for stability
}
Edited by Dietrich_3
Member Avatar for Dietrich_3

My introduction to this topic is not A.I.Slop! It is written from years of my actual experience with the device.

commented: I've asked that be removed. ChatGPT writes like that so you are the one that was ripped off. +0
Member Avatar for Dietrich_3

Ruining someones reputation seems too be the thing to do! At that rate I will be negative soon!

Member Avatar for Dani

I've asked that be removed. ChatGPT writes like that so you are the one that was ripped off.

I've removed the downvote.

Member Avatar for Dietrich_3

There are ongoing efforts within the Arduino community to look at MicroPython as a language for programming the various controllers. I personally am very fond of C++ and could live with it. Of course I am a Pythonista too! Any opinions?

The 'Artificial' in A.I. might be okay, but it does mean 'not real' or 'fake' remembering the hard times after WW2.

Hey, my reputation is now almost zero! I must be stepping on someones foot!

Edited by Dietrich_3
commented: Apologies. ChatGPT ripped off your style. +16
Member Avatar for Reverend Jim

Hey, my reputation is now almost zero!

What do you mean? I see you have 27 upvotes and zero downvotes. You have +5 rep and you've only been posting since August 12.

Member Avatar for Dietrich_3

Thanks Jim,
there was a short couple of days were I was down to 5 points! Hopefully fixed now! I called back my goon-squad!

Member Avatar for Dietrich_3

My old Windows11 laptop is being used again. I am using it because it has an extra USB port free that I have connected to an Arduino UNO now. I promptly ran into a problem with an old UNO "compatible" unit made by "Miuzei". The newer Arduino IDE refuses to talk to the cheap imposter. I have no problem with any other brands I have. Playing around with various color LEDs and use them to generate voltage with light, that I measure with one of the six analog inputs. The result goes to the computer to be plotted/evaluated with a Python program.

Member Avatar for Dietrich_3

Could not find the box of sensors and indicators for the Arduino, so I ordered an assortment from Walmart (ca. $20) that should arrive tomorrow. Then it's time to program the thing. Will be using C++ and Python.

Member Avatar for Dietrich_3

Well, the assortment came, a nice fishing tag box with each item in a small zip-lock bag. A number of LEDs, some for infra-red, RedGreenBlue, 2 color RedGreen for mixing, and a cute 7 color flasher, all very tiny with pins for a standard breadboard. The sensor with the microphone has opportunities One of those 'clapper' gadgets that can turn things on or off should be easy. Have the computer analyze the sound and close the window when it thunders? The sound of breaking class setting of a warning! The height of automation for a few bucks.

Member Avatar for Dietrich_3

Another headsup, the Arduino UNO R4 version is much improved over the R3 version, a bit more expensive ca. $30 or less.
The specs are impressive: https://docs.arduino.cc/tutorials/uno-r4-minima/cheat-sheet/
I just went ahead and ordered one from Walmart, should be here in about a week.

Right now I am exploring the OLED display, works great for showing results without the use of the computer.

Edited by Dietrich_3
Member Avatar for Dietrich_3

An Arduino IDE code example of the OLED display (also from Walmart online) used with an UNO R3:
Some helpful notes are attached to the end of the code.

/* OLED_milli_time.ino

Arduino + OLED display combo is one of the cleanest ways to show text, sensor data, or
graphics on your projects. The most common module is the 0.96" 12864 SSD1306 I2C OLED,
which uses only four wires and works on both 3.3V and 5V.

 Has 4 pins (l to r):
  1 GND
  2 VCC  +5V
  3 SCL  I2C clock line to UNO pin A5
  4 SDA  I2C data line  to UNO pin A4

careful...
sometimes GND and +5V are reversed, should be marked
Typical I2C address: 0x3C (rarely 0x3D)

millis() uses unsigned long values
0 to 4,294,967,295 (2^32 - 1) or about 50 days in millisec

Install via Arduino IDE  Library Manager:
Adafruit SSD1306
Adafruit GFX        (for graphics)

If port is not found unplug/replug USB
*/

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

#define SCREEN_WIDTH 128
#define SCREEN_HEIGHT 64

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);

void setup() {
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);  // I2C address
  display.clearDisplay();
  // needed
  display.setTextColor(WHITE);
  // displays 10 characters per text-line for TextSize(2)
  // total 4 text_lines/display panel each 16 pixels heigh
  display.setTextSize(2); 
}

void loop() {
  //unsigned long currentMillis = millis();
  display.setCursor(0, 0);  // ULC  column, row in pixels
  unsigned long millisec = millis();
  unsigned long sec = millisec/1000;
  unsigned long min = sec/60;
  unsigned long hr = min/60;

  display.print(millisec);
  display.setCursor(0, 16);
  display.print(sec);

  display.setCursor(0, 16*2);
  display.print(min);
  display.print(" minutes");

  display.setCursor(0, 16*3);
  display.print(hr);
  display.print(" hours");  

  display.display();
  delay(1000);  // in milliseconds
  display.clearDisplay();
}

/*
  // displays 21 characters per text-line for TextSize(1)
  // total 8 text-lines/diplay panel each 8 pixels heigh
  // displays 10 characters per text-line for TextSize(2)
  // total 4 text_lines/display panel each 16 pixels heigh
  // excess text will wrap into next text-line
  display.setTextSize(2);
  display.setTextColor(WHITE);
  // top left setCursor(0, 0) column, row in pixels
  display.setCursor(0, 0);
  display.println("Hello OLED");

  display.setCursor(0, 18);
  display.println("Hello OLED");

  display.setTextSize(1);
  display.setCursor(0, 18*2);
  display.println("now use text size 1");

  float cost = 123.4567;
  display.setCursor(0, 18*2+10);
  // no new line char
  display.print("Cost = $");
  // round to 2 decimal
  display.println(cost, 2);

  display.display();

*/
Edited by Dietrich_3
Member Avatar for Dietrich_3

Sorry, on the 'OLED_milli_time.ino' example you need to change to a smaller text size like
display.setTextSize(1);
After the millisecond count reaches 6_000_000 the minute line would otherwise overflow into the next line.

Member Avatar for Dietrich_3

Here is a LED color flipper based on the millisecond stream using even/odd values. A little different.

/* UNO_dekasecond_blink.ino

unsigned long millisec = millis();
unsigned long sec = millisec/1000;  // 1 second
unsigned long dekasec = millisec/10000;  // 10 seconds
could make 
unsigned long halfdekasec = millisec/5000;  // 5 seconds
an even number is any integer where n % 2 == 0
LED colors flip every ten seconds

The two color LED red/green came with a sensor assortment, 
as current limiting resistors already on a small 3 pin board.

VegasEat  11sep2026
*/

int green = 9;       // the IO pin the green LED is attached to
int red = 10;        // the IO pin the red LED is attached to

// the setup routine runs once when you press reset:
void setup() {
  // initialize serial communication at 9600 bits per second
  // use it for testing
  Serial.begin(9600);
  pinMode(green, OUTPUT);
  pinMode(red, OUTPUT);

}

// the loop routine runs over and over again forever:
void loop() {

  unsigned long millisec = millis();
  //unsigned long sec = millisec/1000;
  unsigned long dekasec = millisec/10000;  // 10 seconds

  //Serial.println(dekasec);  // testing...

  // flip LED every 10 mseconds
  // green LED is on when dekasecond value is even
  if (dekasec % 2 == 0) {
    digitalWrite(green, HIGH);
    digitalWrite(red, LOW);
  }
  else {
    digitalWrite(green, LOW);
    digitalWrite(red, HIGH);
  }
           
}
Member Avatar for Dietrich_3

I am thinking about a temperature sensor using the Arduino UNO that will transmit its data to the computer for evaluation with a Python program. Got the Arduino part going.

/* NTC_thermistor_module.ino

I am using the typical KY-028 temperature sensor module that 
comes with the Arduino Kuman37 sensor kit.

The KY-028 is a digital temperature sensor module for Arduino, 
built around an NTC thermistor and an LM393 comparator. This 
temperature sensor module measures from 55 C to 125 C and 
provides two outputs.  A digital output that flips when the 
temperature crosses a threshold set by the onboard potentiometer, 
and an analog output for relative temperature readings that 
can be calculated by the 'Steinhart and Hart' equation.

Adjust the onboard trimpot till the green LED comes on, it sets
the trip point for the digital output only.

I used a 470 nF capacitor to limit the RF picked up by the wire
to the Arduino analog input.

The board has 4 pins (left to r.ight):
A-out, GND, +5V, D-out

https://arduinomodules.info/ky-028-digital-temperature-sensor-module/

The analog value goes down when the temperature goes up.

Generally, the NTC thermistor MF52 is in series with a 10k ohm resistor 
to form a voltage divider. 

VegasEat  12sep2026
*/

// nominal thermistor resistance 50K at 25 degC
// Beta B is a constant
int Ro = 50;
int B = 3950;
// series resistor 10K
int Rseries = 10;
// nominal temperature 25 degC = 298.15 degK
float To = 298.15;

// melting ice water should be close to 0 degC = 32 degF
// human body temperature averages 37 degC = 98 degF
// adjustment to correct any error (degC)
// might have to play with this value just a little
float adjust = 38.9;


int led = 13;          // onboard LED pin
int digitalPin = 2;    // KY-028 digital output (D0)
int analogPin = A4;    // KY-028 analog output (A0)
int digitalVal;        // digital reading (threshold state)
int analogVal;         // analog reading (relative temperature)

void setup()
{
  pinMode(led, OUTPUT);
  pinMode(digitalPin, INPUT);
  pinMode(analogPin, INPUT);
  Serial.begin(9600);
}

void loop()
{
  // Read the digital output (HIGH when the temperature crosses the threshold)
  digitalVal = digitalRead(digitalPin);
  if (digitalVal == HIGH)
  {
    digitalWrite(led, HIGH); // threshold reached -> LED on
  }
  else
  {
    digitalWrite(led, LOW);  // below threshold -> LED off
  }

  // read the voltage across the thermistor 
  // and convert the 10 bit value range (0 to 1023) to voltage (0 to 5.0)
  float Vi = analogRead(A4) * (5.0 / 1023.0);
  // convert voltage measured to resistance value
  // all resistance values are in kilo ohms
  float R = (Vi * Rseries) / (5 - Vi);
  // use R value in Steinhart and Hart equation
  // to calculate the temperature value in Kelvin
  float T = 1 / ((1 / To) + ((log(R / Ro)) / B));
  // converting Kelvin to Celsius
  // adjust is the error correction
  float Tc = T - 273.15 - adjust; 
  // converting Celsius to Fahrenheit
  float Tf = Tc * 9.0 / 5.0 + 32.0; 

  // this data string will be transmitted to the computer
  // to be used by a Python program via module serial (pyserial)
  // round to 1 decimal point
  Serial.print(Tc, 1);
  Serial.print(" C  ");
  Serial.print(Tf. 1);
  Serial.print(" F");
  Serial.println();  // flush the line

  // measure 1000 ms = 1 sec apart
  delay(1000);
}
Member Avatar for Dietrich_3

I just received an 'Arduino R4 WiFi' in the mail. Same size as the R3 version, but much improved capabilities, cost less than $30. Looks high quality, assembled in Italy. Plug it in with a USB cable, I used a shielded cable with a USB-2 plug on the computer side, and a USB-C plug on the UNO R4 side. Or just use the 6-24 VDC barrel plug to start the little precoded LED matrix show.

It needs the newer version of the Arduino IDE. Here is an initial summary of the things I could find out:

Sorry, it looks like DaniWeb does not like my table with 4+ spaces!!!!
My attempt to post it as a Python file also failed misserably!!
Let me sleep over this grab!

All other pins are the same 14 DIO, 6 AI, 6 PWM, UART, I2C, SPI, +5V ~200mA

Extras on the R4 WiFi:
12×8 red LED matrix, Qwiic connector, Real Time Clock, access to onboard OPAmp,
RGB LED access, WiFi + Bluetooth, true analog audio/signal generation (DAC),
CAN‑bus automotive/industrial communication, faster math (math processor)

Since I use my old Windows11 Laptop I called on 'Copilot' for some helpfull info and found it charming.

The pins are marked very readable. I also ran a short code (C++) on it as an example:

/* UNO_R4_text_scroll.ino

Using the Arduino UNO R4 WiFi board the first time...
connect it to the computer with a cable that has a normal 
USB-2 plug on one end and a USB-C plug on the other end.
The Arduino IDE version 2.3.10 will show the board name
and COM port number.

To get the 2 needed header .h files installed ...
1. Open Arduino IDE  Tools  Board Manager
2. Search for:
Code
UNO R4
3. Install or update:
Arduino UNO R4 Boards (latest version)
...
This package includes:
Arduino_LED_Matrix.h
ArduinoGraphics.h  support and
all builtin frames & animations

After installing, restart the IDE.

VegasEat  12sep2026
*/

// include ArduinoGraphics.h before Arduino_LED_Matrix.h
#include "ArduinoGraphics.h"
#include "Arduino_LED_Matrix.h"

// create the instance/object
ArduinoLEDMatrix matrix;

void setup() {
  //Serial.begin(115200);
  matrix.begin();

  matrix.beginDraw();

  // set color 0xRRGGBB, the LEDs are only red here
  matrix.stroke(0xFFFFFF);
  // add some static text
  // will only show "MIA"
  // not enough space on the display
  // longer text needs to scroll!
  const char text[] = "MIA";
  matrix.textFont(Font_4x6);
  // x, y, color implies full red
  matrix.beginText(0, 1, 0xFFFFFF);
  matrix.println(text);
  matrix.endText();
  // default is NO_SCROLL
  matrix.endDraw();
  // wait 3000 ms = 3 seconds to read
  delay(3000);
}

void loop() {

  // scroll longer text in loop
  matrix.beginDraw();
  // set color, as of now the LEDs are only red
  matrix.stroke(0xFFFFFFFF);
  // low number like 30 is fast
  // higher like 200 number gets slower
  // play with it
  matrix.textScrollSpeed(160);
  // convert any numeric result to a char array
  // add the text
  const char text[] = "  Hello World!  ";
  matrix.textFont(Font_5x7);
  // x, y, color
  matrix.beginText(0, 1, 0xFFFFFF);
  matrix.println(text);
  // set scroll direction
  matrix.endText(SCROLL_LEFT);

  matrix.endDraw();
}
UNO_R4_WiFi =
'''
UNO R3                               UNO R4
ATmega328P, 8bit, 16MHz            Renesas RA4M1 CortexM4, 32bit, 48MHz
32KB Flash, 2KB SRAM, 1KB EEPROM  256KB Flash, 32KB SRAM, 8 KB EEPROM 
No WiFi/Bluetooth                    ESP32S3 onboard  WiFi + Bluetooth LE 
712VDC input                       624VDC input
10 bit analog in                     10 or 14 bit analog in
no true analog out                   12 bit true analog out on 1 pin
no CAN bus                           has CAN bus specs
'''
Edited by Dietrich_3
Member Avatar for Dietrich_3

A peek at the ill tempered table missing from the last diatribe .........

UNO R3 processor = ATmega328P, 8‑bit, 16 MHz
UNO R4 processor = Renesas RA4M1 Cortex‑M4, 32‑bit, 48 MHz

UNO R3 memory = 32 KB Flash, 2 KB SRAM, 1 KB EEPROM
UNO R4 memory = 256 KB Flash, 32 KB SRAM, 8 KB EEPROM

Aghhhh! Himmel, Tod und Teufel! I give up!

# -*- coding: utf-8 -*-
""" UNO_R4_WiFi.py
Created on Sun Sep 13 00:17:37 2026

the ill tempered table

@author: vegas
"""

UNO_R4_WiFi =\
"""
UNO R3                               UNO R4
ATmega328P, 8bit, 16MHz            Renesas RA4M1 CortexM4, 32bit, 48MHz
32KB Flash, 2KB SRAM, 1KB EEPROM  256KB Flash, 32KB SRAM, 8 KB EEPROM 
No WiFi/Bluetooth                    ESP32S3 onboard  WiFi + Bluetooth LE 
7 to 12VDC input                    6 to 24VDC input
10 bit analog in                     10 or 14 bit analog in
no true analog out                   12 bit true analog out on 1 pin
no CAN bus
"""
# -*- coding: utf-8 -*-
""" UNO_R4_WiFi.py
Created on Sun Sep 13 00:17:37 2026

the ill tempered table

@author: vegas
"""

UNO_R4_WiFi =\
"""
UNO R3                               UNO R4
ATmega328P, 8bit, 16MHz            Renesas RA4M1 CortexM4, 32bit, 48MHz
32KB Flash, 2KB SRAM, 1KB EEPROM  256KB Flash, 32KB SRAM, 8 KB EEPROM 
No WiFi/Bluetooth                    ESP32S3 onboard  WiFi + Bluetooth LE 
7 to 12VDC input                    6 to 24VDC input
10 bit analog in                     10 or 14 bit analog in
no true analog out                   12 bit true analog out on 1 pin
no CAN bus
"""
Edited by Dietrich_3
Member Avatar for Dietrich_3

Here it goes one more time.........
Should not even try to post Python code on a C++ forum. The spaces get screwed up.

# -*- coding: utf-8 -*-
""" UNO_R4_WiFi.py
Created on Sun Sep 13 00:17:37 2026

the ill tempered table

@author: vegas
"""

UNO_R4_WiFi =\
"""
UNO R3                               UNO R4
ATmega328P, 8bit, 16MHz            Renesas RA4M1 CortexM4, 32bit, 48MHz
32KB Flash, 2KB SRAM, 1KB EEPROM  256KB Flash, 32KB SRAM, 8 KB EEPROM 
No WiFi/Bluetooth                    ESP32S3 onboard  WiFi + Bluetooth LE 
7 to 12VDC input                    6 to 24VDC input
10 bit analog in                     10 or 14 bit analog in
no true analog out                   12 bit true analog out on 1 pin
no CAN bus
"""
Edited by Dietrich_3
Member Avatar for Dietrich_3

Ahh! Python to the rescue:
Still, the result does not match what shows on my Spyder IDE!
Must be the font that Dani uses!

# -*- coding: utf-8 -*-
""" UNO_R4_WiFi.py
Created on Sun Sep 13 00:17:37 2026

the ill tempered table part 2

@author: vegas
"""

UNO_R4_WiFi =\
"""
UNO R3                               UNO R4
ATmega328P, 8bit, 16MHz            Renesas RA4M1 CortexM4, 32bit, 48MHz
32KB Flash, 2KB SRAM, 1KB EEPROM  256KB Flash, 32KB SRAM, 8 KB EEPROM 
No WiFi/Bluetooth                    ESP32S3 onboard  WiFi + Bluetooth LE 
7 to 12VDC input                    6 to 24VDC input
10 bit analog in                     10 or 14 bit analog in
no true analog out                   12 bit true analog out on 1 pin
no CAN bus                           has CAN bus specs
"""

s = UNO_R4_WiFi

s2 = s.replace(' ', '_', -1)
print("UNO_R4_WiFi")
print(s2)

'''
UNO_R4_WiFi

UNO_R3_______________________________UNO_R4
ATmega328P,_8bit,_16MHz____________Renesas_RA4M1_CortexM4,_32bit,_48MHz
32KB_Flash,_2KB_SRAM,_1KB_EEPROM__256KB_Flash,_32KB_SRAM,_8_KB_EEPROM_
No_WiFi/Bluetooth____________________ESP32S3_onboard__WiFi_+_Bluetooth_LE_
7_to_12VDC_input____________________6_to_24VDC_input
10_bit_analog_in_____________________10_or_14_bit_analog_in
no_true_analog_out___________________12_bit_true_analog_out_on_1_pin
no_CAN_bus___________________________has_CAN_bus_specs
'''
Edited by Dietrich_3
Member Avatar for Dietrich_3

I finally got a hold of the 16x2 Liquid Crystal Display that has the I2C connection.
The normal non I2C version is most frequently included in Arduino Kits and requires
a rat's nest of wires to connect (counted 14), for an example see:
https://www.circuito.io/app?components=512,11021,341099
The I2C version requires 4 wires, 2 for power and 2 for the I2C protocol, see:
https://www.circuito.io/app?components=512,11021,417986

To make it work you have to install the 'LiquidCrystal_I2C' library on your Arduino IDE.
Got mine set up with a regular Arduino UNO to count seconds. One important note,
adjust the little trim-pot on the backside of the I2C version for proper contrast,
so the characters show up.

/* LiquidCrystal_I2C_counter.ino

 using a LCD 16x2 (I2C) Liquid Crystal display
 (MCP23008 based)

compiles, characters don't show until the contrast potentiometer on
the backside is properly adjusted!  Lucky hint from Copilot!

https://docs.arduino.cc/libraries/liquidcrystal/

 the display has 4 pins on the left section
 (top to bottom)
 1 ground
 2 +5V
 3 signal SDA to arduino pin SDA or A4
 4 signal SCL to arduino pin SCL or A5

  // all the official commands...
  lcd.init();
  lcd.begin(16, 2);   // width, height in characters
  lcd.clear();
  lcd.home();         // default is col=0, row=0  (ULC)
  lcd.backlight();    // needs to be on, so call it  
  lcd.cursor();
  lcd.noCursor();
  lcd.blink();        // cursor position blinks
  lcd.noBlink();
  lcd.setCursor(col, row)  // zero based
  lcd.autoscroll(); 
  lcd.noAutoscroll();
  lcd.leftToRight();    // default
  lcd.rightToLeft();
  lcd.print("UNO R4 WiFi!");
  lcd.write(123);       // ascii value of one character to show
  lcd.scrollDisplayLeft();  // whole display 1 space (loop it)
  lcd.scrollDisplayRight(); // dito
  lcd.display();
  lcd.createChar(index, byteArray[]) // form custom character

If you get a "can't find port error", simply unplug and replug USB

VegasEat  14sep2026
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);  // 0x27 or maybe 0x3F

unsigned long int seconds = 0;

void setup() {
  lcd.init();
  // must turn on backlight
  lcd.backlight();
  // show some text
  // column = 0, row = 0 by default
  lcd.print("count seconds:");
}

void loop() {
  // column = 0, row = 1
  lcd.setCursor(0, 1);
  lcd.print(seconds);
  delay(1000);  // delay 1000 ms or 1 second
  seconds += 1;
}
Edited by Dietrich_3
Member Avatar for Dietrich_3

In the previous Arduino example we counted down seconds to test an LCD display. Just for the curious, how long can C++ 'unsigned long int' go in seconds? Its late in the day, so I used Python to show it:
(Sorry for the print("unsigned lomg in C++ is 8 bytes") 'lomg' should be 'long')

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
''' CPP_unsigned_long.py

assume size of unsigned long in C++ is 8 bytes

used...
https://www.onlinegdb.com/online_c++_compiler

VegasEat  15sep2026
'''

print("unsigned lomg in C++ is 8 bytes")
# easier to show with hexadecimal strings 
# 1 byte
byte1 = "F"
# 8 bytes
byte8 = "FFFFFFFF"
# convert hexadecimal string to decimal number
dec8 = int(byte8, 16)
print(f"{byte8 = } hexdecimal, \n{dec8 = :_} decimal")

print("="*30)

print("milliseconds to days:")
ms = 4_294_967_295
s = ms // 1000
m = s // 60
h = m // 60
d = h // 24
# split long syntax line into 2 lines
print(f"{ms = :_} ms, \n{s = :_} sec, \n{m = :_} minutes")
print(f"{h = :_} hours, \n{d = } days")

''' result...
unsigned lomg in C++ is 8 bytes
byte8 = 'FFFFFFFF' hexdecimal, 
dec8 = 4_294_967_295 decimal
==============================
milliseconds to days:
ms = 4_294_967_295 ms, 
s = 4_294_967 sec, 
m = 71_582 minutes
h = 1_193 hours, 
d = 49 days
'''
Edited by Dietrich_3
Member Avatar for Dietrich_3

An example that uses the Arduino UNO to measure voltages and display them on a LCD. Also shows the limitations you need to observe.

/* LCD_Display_I2C_voltages.ino

 Measure the voltage with 2 analog inputs and show
 the result on 2 separate rows of an LCD display.
 Use a LCD 16x2 (I2C) Liquid Crystal Display
 (MCP23008 based)

 The display has 4 pins on the left section
 (top to bottom)
 1 ground
 2 +5V
 3 signal SDA to arduino pin SDA or A4
 4 signal SCL to arduino pin SCL or A5

 The voltage source is 3.3V with two 10k ohm resistors
 connected in series between - and + forming a divider.
 One voltage is read from +3.3V, the other from the 
 center of the voltage divider, should be +1.65V.
 The resistors used are +- 5%

 On the UNO max voltage on the analog inputs is +5.5V
 On the NanoESP32 don't exceed +3.3V
 For higher DC volages apply an appropriate voltage divider
 and correct the value in the code.

 // all the official commands...
  lcd.init();
  lcd.begin(16, 2);   // width, height in characters
  lcd.clear();
  lcd.home();         // default is col=0, row=0  (ULC)
  lcd.backlight();    // needs to be on, so call it  
  lcd.cursor();
  lcd.noCursor();
  lcd.blink();        // cursor position blinks
  lcd.noBlink();
  lcd.setCursor(col, row)  // zero based
  lcd.autoscroll(); 
  lcd.noAutoscroll();
  lcd.leftToRight();    // default
  lcd.rightToLeft();
  lcd.print("UNO R4 WiFi!");
  lcd.write(123);       // ascii value of one character to show
  lcd.scrollDisplayLeft();  // whole display 1 space (loop it)
  lcd.scrollDisplayRight(); // dito
  lcd.display();
  lcd.createChar(index, byteArray[]) // form custom character

If you get a "can't find port error", simply unplug and replug USB

VegasEat  16sep2026
*/

// install 'LiquidCrystal_I2C' on the Arduino IDE
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);  // 0x27 or maybe 0x3F

int voltPin1 = A0;
int voltPin2 = A1;

void setup() {
  lcd.init();
  // must turn on backlight
  lcd.backlight();
  pinMode(voltPin1, INPUT);
  pinMode(voltPin2, INPUT);
}

void loop() {
  // read the input on the specified Arduino analog pin
  int sensorValue1 = analogRead(voltPin1);
  int sensorValue2 = analogRead(voltPin2);
  // convert the 10bit analog reading which goes
  // from 0 to 1023 to a voltage 0 to 5V)
  float voltage1 = sensorValue1 * (5.0 / 1023.0);
  float voltage2 = sensorValue2 * (5.0 / 1023.0);

  // first row
  // set the cursor to (column=0, row=0):
  lcd.setCursor(0, 0);
  lcd.print(voltage1);
  lcd.print(" volts");
  // second row
  lcd.setCursor(0, 1);
  lcd.print(voltage2);
  lcd.print(" volts");
  delay(3000);

  // clear screen for the next loop
  lcd.clear();
}
Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.