JonDent - Explorations in Electronics, Electronic Music, Coffee, Sci Fi, Art & Travel (but mostly electronic music)
Sunday, 9 April 2017
Monday, 3 April 2017
Complier directives - Arduino
Complier directives are sometimes called Preprocessor directives.
They are commands that tell the complier how to behave & treat certain parts of code.
Note, they are not part of the code.
They aren't complied (converted into zeros and ones) and loaded into the arduino.
The preprocessor works by searching for lines that start with the hash sign (#) and have some text after it. This is called a preprocessor directive and it’s a sort of “command” for the preprocessor.
Examples are:
#include -
We use this when including a arduino library ... “adds” the library to the main sketch.
It tells the compiler to get the code from that library.
#define
eg
#define VALUE 3
Here we define a word as a number.
This tells the compiler, every time it sees the word "VALUE"
to change the word VALUE into a 3
#endif
#ifndef
This checks whether a library is included
#ifdef
a just shorthand for #if defined, which can be used to test multiple macros in a single condition. Note that every condition has to end with #endif directive, to specify which parts of the code are affected by the condition, and which ones are not.
#warning
#error
When preprocessor finds these directives, it will print the message into the Arduino IDE console. The difference between the two is that after #warning, compilation proceeds as normal, while #error stops the compilation altogether.
#ifdef DEBUG
#if DEBUG
#else
links
+ https://www.youtube.com/watch?v=kBTM0dLzNXk
Sunday, 2 April 2017
i2c LCD display with rotary encoder 1
My first test of trying a rotary encoder with a LCD display.
Many thanks to John Miller for his excellent video.
Project Source: https://github.com/jpsrmiller/rotary-encoder-i2c-lcd
I've had to adjust the code a bit along with the wiring of the encoder as I didn't have a ky-040 encoder
The KY-040 has a breakout board which adds a Vcc pin
The virgin encoder doesn't have this.
It has 5 pins:
1. CLK - Clock (Out B)
2. DT - data (Out A)
3. SW - switch (when we press the shaft, the switch connects to GND. Otherwise it is floating.)
4. GND
5. GND
You most often will find encoders without the breakout board.
They still have 5 pins.
Here there are two GNDs
There is no Vcc
The bare Rotary Encoder is connected to the following Arduino Uno pins
// o CLK (out B) --> Pin 2
// o DT (Out A) --> Pin 3
// o SW --> Pin 4
// o GND --> Pin 6 & GND on arduino
// o CLK (out B) --> Pin 2
// o DT (Out A) --> Pin 3
// o SW --> Pin 4
// o GND --> Pin 6 & GND on arduino
Here is my adapted code:
// ********************************************
// *************************************************************************************
// LCDRotaryTest16x2.ino - Test Program for Character LCD with I2C and KY-040 Rotary Encoder
// Author: John Miller
// Revision: 1.0.1
// Date: 5/25/2020
// Project Source: https://github.com/jpsrmiller/rotary-encoder-i2c-lcd
//
// This Arduino program provides an example for using a KY-040 Rotary Encoder and
// a 16x2 or 20x4 Character LCD with I2C interface
//
// The program may be freely copied, modified, and used for any Arduino projects
//
// The KY-040 Rotary Encoder is connected to the following Arduino Uno pins
// o CLK --> Pin 2
// o DT --> Pin 3
// o SW --> Pin 4
// o + --> Pin 5
// o GND --> Pin 6
//
// The LCD is connected to the following Arduino Uno pins
// o GND --> GND
// o VCC --> 5V
// o SDA --> Pin A4 (SDA)
// o SCL --> Pin A5 (SCL)
//
// The Rotary Encoder uses Arduino pins for the GND and +5V so that the remaining
// 5V and GND pins on the Arduino Uno can be used for other peripheral devices
// This works because the the Rotary Encoder draws less than the 40 mA
// maximum current allowed on the Arduino Uno I/O pins
//
// *** External Libraries Required ***
// The following libraries must be downloaded and copied into the Arduino "libraries"
// folder in order for the program to compile:
// o OneButton - https://github.com/mathertel/OneButton
// o LiquidCrystal_I2C - https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
//
// *********************************************************************************
#include <Arduino.h>
#include <Wire.h>
#include <OneButton.h>
#include <LiquidCrystal_I2C.h>
// Define the IO Pins Used
#define PIN_ROTARY_CLK 2 // Used for generating interrupts using CLK signal
#define PIN_ROTARY_DAT 3 // Used for reading DT signal
#define PIN_ROTARY_SW 4 // Used for the Rotary push button switch
#define PIN_ROTARY_5V 5 // Set to HIGH to be the 5V pin for the Rotary Encoder
#define PIN_ROTARY_GND 6 // Set to LOW to be the GND pin for the Rotary Encoder
// Most I2C LCD's have an I2C Address of either 0x27 or 0x3F
// If the LCD doesn't work with one address, try the other
//#define LCD_I2C_ADDRESS 0x27
//#define LCD_I2C_ADDRESS 0x3F
// Define the size of the LCD. Most LCD's are either 16x2 or 20x4
//#define LCD_ROW_COUNT 2 // Number of Rows
//#define LCD_COL_COUNT 16 // Number of Characters per Row
// OneButton class handles Debounce and detects button press
OneButton btnRot(PIN_ROTARY_SW, HIGH); // Rotary Select button
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(LCD_I2C_ADDRESS, LCD_COL_COUNT, LCD_ROW_COUNT);
// Used for the Rotary Encoder interrupt routines PinA() and PinB()
volatile int rotaryCount = 0;
// Disables the Rotary Encoder interrupts while the LCD is being updated
byte rotaryDisabled;
volatile byte aFlag = 0; // lets us know when we're expecting a rising edge on pinA
// to signal that the encoder has arrived at a detent
volatile byte bFlag = 0; // lets us know when we're expecting a rising edge on pinB
// to signal that the encoder has arrived at a detent
// (opposite direction to when aFlag is set)
volatile byte reading = 0; //somewhere to store the direct values we read from our interrupt
// pins before checking to see if we have moved a whole detent
// ****************************************************************************
// PinA() - Called by the Interrupt pin when the Rotary Encoder Turned
// Routine based on Simon Merrett - Improved Arduino Rotary Encoder Reading
// https://www.instructables.com/id/Improved-Arduino-Rotary-Encoder-Reading/
// ****************************************************************************
void PinA() {
if (rotaryDisabled) return;
cli(); //stop interrupts happening before we read pin values
// read all eight pin values then strip away all but pinA and pinB's values
reading = PIND & 0xC;
//check that both pins at detent (HIGH) and that we are expecting detent on this pin's rising edge
if (reading == B00001100 && aFlag) {
rotaryRight();
bFlag = 0; //reset flags for the next turn
aFlag = 0; //reset flags for the next turn
}
//signal that we're expecting pinB to signal the transition to detent from free rotation
else if (reading == B00000100) bFlag = 1;
sei(); //restart interrupts
}
// ****************************************************************************
// PinB() - Called by the Interrupt pin when the Rotary Encoder Turned
// Routine based on Simon Merrett - Improved Arduino Rotary Encoder Reading
// https://www.instructables.com/id/Improved-Arduino-Rotary-Encoder-Reading/
// ****************************************************************************
void PinB() {
if (rotaryDisabled) return;
cli(); //stop interrupts happening before we read pin values
//read all eight pin values then strip away all but pinA and pinB's values
reading = PIND & 0xC;
//check that both pins at detent (HIGH) and that we are expecting detent on this pin's rising edge
if (reading == B00001100 && bFlag) {
rotaryLeft();
bFlag = 0; //reset flags for the next turn
aFlag = 0; //reset flags for the next turn
}
//signal that we're expecting pinA to signal the transition to detent from free rotation
else if (reading == B00001000) aFlag = 1;
sei(); //restart interrupts
}
// ****************************************************************************
// rotaryRight() - Rotary Encoder is turned 1 detent to the Right (clockwise)
// Insert your own code here.
// ****************************************************************************
void rotaryRight()
{
rotaryCount++;
}
// **********************************************************************************
// rotaryLeft() - Rotary Encoder is turned 1 detent to the Left (counter-clockwise)
// Insert your own code here.
// **********************************************************************************
void rotaryLeft()
{
rotaryCount--;
}
// ****************************************************************************
// rotaryClick() - Rotary Encoder Select Switch is pressed
// Insert your own code here.
// ****************************************************************************
void rotaryClick()
{
rotaryCount += 100;
}
// ****************************************************************************
// rotaryLongPress() - Rotary Encoder Select Switch is Held Down (Long Press)
// Insert your own code here.
// ****************************************************************************
void rotaryLongPress()
{
rotaryCount = 0;
}
// ****************************************************************************
// initializeRotaryEncoder() - Initialize the pins and interrupt functions
// for the Rotary Encoder
// ****************************************************************************
void initializeRotaryEncoder()
{
// Set the Directions of the I/O Pins
pinMode(PIN_ROTARY_CLK, INPUT_PULLUP);
pinMode(PIN_ROTARY_DAT, INPUT_PULLUP);
pinMode(PIN_ROTARY_SW, INPUT_PULLUP);
pinMode(PIN_ROTARY_GND, OUTPUT);
pinMode(PIN_ROTARY_5V, OUTPUT);
// Set the 5V and GND pins for the Rotary Encoder
digitalWrite(PIN_ROTARY_GND, LOW);
digitalWrite(PIN_ROTARY_5V, HIGH);
// set an interrupt on PinA and PinB, looking for a rising edge signal and
// executing the "PinA" and "PinB" Interrupt Service Routines
attachInterrupt(0, PinA, RISING);
attachInterrupt(1, PinB, RISING);
// Define the functions for Rotary Encoder Click and Long Press
btnRot.attachClick(&rotaryClick);
btnRot.attachLongPressStart(&rotaryLongPress);
btnRot.setPressTicks(2000);
rotaryDisabled = 0;
}
// ****************************************************************************
// initializeLcd() - Initialize the LCD
// ****************************************************************************
void initializeLcd()
{
lcd.begin(16,2);
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(F("Test LCD & Rotry"));
}
// ****************************************************************************
// updateLcd() - Update the LCD with current Rotary Encoder detent count
// ****************************************************************************
void updateLcd()
{
rotaryDisabled = 1;
lcd.setCursor(0, 1);
lcd.print(F("Count = "));
lcd.print(rotaryCount);
lcd.print(F(" "));
rotaryDisabled = 0;
}
// ****************************************************************************
// setup() - Initialization Function
// ****************************************************************************
void setup()
{
initializeRotaryEncoder();
initializeLcd();
}
// ****************************************************************************
// loop() - Main Program Loop Function
// ****************************************************************************
void loop()
{
updateLcd();
btnRot.tick();
delay(50);
}
// LCDRotaryTest16x2.ino - Test Program for Character LCD with I2C and KY-040 Rotary Encoder
// Author: John Miller
// Revision: 1.0.1
// Date: 5/25/2020
// Project Source: https://github.com/jpsrmiller/rotary-encoder-i2c-lcd
//
// This Arduino program provides an example for using a KY-040 Rotary Encoder and
// a 16x2 or 20x4 Character LCD with I2C interface
//
// The program may be freely copied, modified, and used for any Arduino projects
//
// The KY-040 Rotary Encoder is connected to the following Arduino Uno pins
// o CLK --> Pin 2
// o DT --> Pin 3
// o SW --> Pin 4
// o + --> Pin 5
// o GND --> Pin 6
//
// The LCD is connected to the following Arduino Uno pins
// o GND --> GND
// o VCC --> 5V
// o SDA --> Pin A4 (SDA)
// o SCL --> Pin A5 (SCL)
//
// The Rotary Encoder uses Arduino pins for the GND and +5V so that the remaining
// 5V and GND pins on the Arduino Uno can be used for other peripheral devices
// This works because the the Rotary Encoder draws less than the 40 mA
// maximum current allowed on the Arduino Uno I/O pins
//
// *** External Libraries Required ***
// The following libraries must be downloaded and copied into the Arduino "libraries"
// folder in order for the program to compile:
// o OneButton - https://github.com/mathertel/OneButton
// o LiquidCrystal_I2C - https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library
//
// *********************************************************************************
#include <Arduino.h>
#include <Wire.h>
#include <OneButton.h>
#include <LiquidCrystal_I2C.h>
// Define the IO Pins Used
#define PIN_ROTARY_CLK 2 // Used for generating interrupts using CLK signal
#define PIN_ROTARY_DAT 3 // Used for reading DT signal
#define PIN_ROTARY_SW 4 // Used for the Rotary push button switch
#define PIN_ROTARY_5V 5 // Set to HIGH to be the 5V pin for the Rotary Encoder
#define PIN_ROTARY_GND 6 // Set to LOW to be the GND pin for the Rotary Encoder
// Most I2C LCD's have an I2C Address of either 0x27 or 0x3F
// If the LCD doesn't work with one address, try the other
//#define LCD_I2C_ADDRESS 0x27
//#define LCD_I2C_ADDRESS 0x3F
// Define the size of the LCD. Most LCD's are either 16x2 or 20x4
//#define LCD_ROW_COUNT 2 // Number of Rows
//#define LCD_COL_COUNT 16 // Number of Characters per Row
// OneButton class handles Debounce and detects button press
OneButton btnRot(PIN_ROTARY_SW, HIGH); // Rotary Select button
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// LiquidCrystal_I2C lcd(LCD_I2C_ADDRESS, LCD_COL_COUNT, LCD_ROW_COUNT);
// Used for the Rotary Encoder interrupt routines PinA() and PinB()
volatile int rotaryCount = 0;
// Disables the Rotary Encoder interrupts while the LCD is being updated
byte rotaryDisabled;
volatile byte aFlag = 0; // lets us know when we're expecting a rising edge on pinA
// to signal that the encoder has arrived at a detent
volatile byte bFlag = 0; // lets us know when we're expecting a rising edge on pinB
// to signal that the encoder has arrived at a detent
// (opposite direction to when aFlag is set)
volatile byte reading = 0; //somewhere to store the direct values we read from our interrupt
// pins before checking to see if we have moved a whole detent
// ****************************************************************************
// PinA() - Called by the Interrupt pin when the Rotary Encoder Turned
// Routine based on Simon Merrett - Improved Arduino Rotary Encoder Reading
// https://www.instructables.com/id/Improved-Arduino-Rotary-Encoder-Reading/
// ****************************************************************************
void PinA() {
if (rotaryDisabled) return;
cli(); //stop interrupts happening before we read pin values
// read all eight pin values then strip away all but pinA and pinB's values
reading = PIND & 0xC;
//check that both pins at detent (HIGH) and that we are expecting detent on this pin's rising edge
if (reading == B00001100 && aFlag) {
rotaryRight();
bFlag = 0; //reset flags for the next turn
aFlag = 0; //reset flags for the next turn
}
//signal that we're expecting pinB to signal the transition to detent from free rotation
else if (reading == B00000100) bFlag = 1;
sei(); //restart interrupts
}
// ****************************************************************************
// PinB() - Called by the Interrupt pin when the Rotary Encoder Turned
// Routine based on Simon Merrett - Improved Arduino Rotary Encoder Reading
// https://www.instructables.com/id/Improved-Arduino-Rotary-Encoder-Reading/
// ****************************************************************************
void PinB() {
if (rotaryDisabled) return;
cli(); //stop interrupts happening before we read pin values
//read all eight pin values then strip away all but pinA and pinB's values
reading = PIND & 0xC;
//check that both pins at detent (HIGH) and that we are expecting detent on this pin's rising edge
if (reading == B00001100 && bFlag) {
rotaryLeft();
bFlag = 0; //reset flags for the next turn
aFlag = 0; //reset flags for the next turn
}
//signal that we're expecting pinA to signal the transition to detent from free rotation
else if (reading == B00001000) aFlag = 1;
sei(); //restart interrupts
}
// ****************************************************************************
// rotaryRight() - Rotary Encoder is turned 1 detent to the Right (clockwise)
// Insert your own code here.
// ****************************************************************************
void rotaryRight()
{
rotaryCount++;
}
// **********************************************************************************
// rotaryLeft() - Rotary Encoder is turned 1 detent to the Left (counter-clockwise)
// Insert your own code here.
// **********************************************************************************
void rotaryLeft()
{
rotaryCount--;
}
// ****************************************************************************
// rotaryClick() - Rotary Encoder Select Switch is pressed
// Insert your own code here.
// ****************************************************************************
void rotaryClick()
{
rotaryCount += 100;
}
// ****************************************************************************
// rotaryLongPress() - Rotary Encoder Select Switch is Held Down (Long Press)
// Insert your own code here.
// ****************************************************************************
void rotaryLongPress()
{
rotaryCount = 0;
}
// ****************************************************************************
// initializeRotaryEncoder() - Initialize the pins and interrupt functions
// for the Rotary Encoder
// ****************************************************************************
void initializeRotaryEncoder()
{
// Set the Directions of the I/O Pins
pinMode(PIN_ROTARY_CLK, INPUT_PULLUP);
pinMode(PIN_ROTARY_DAT, INPUT_PULLUP);
pinMode(PIN_ROTARY_SW, INPUT_PULLUP);
pinMode(PIN_ROTARY_GND, OUTPUT);
pinMode(PIN_ROTARY_5V, OUTPUT);
// Set the 5V and GND pins for the Rotary Encoder
digitalWrite(PIN_ROTARY_GND, LOW);
digitalWrite(PIN_ROTARY_5V, HIGH);
// set an interrupt on PinA and PinB, looking for a rising edge signal and
// executing the "PinA" and "PinB" Interrupt Service Routines
attachInterrupt(0, PinA, RISING);
attachInterrupt(1, PinB, RISING);
// Define the functions for Rotary Encoder Click and Long Press
btnRot.attachClick(&rotaryClick);
btnRot.attachLongPressStart(&rotaryLongPress);
btnRot.setPressTicks(2000);
rotaryDisabled = 0;
}
// ****************************************************************************
// initializeLcd() - Initialize the LCD
// ****************************************************************************
void initializeLcd()
{
lcd.begin(16,2);
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(F("Test LCD & Rotry"));
}
// ****************************************************************************
// updateLcd() - Update the LCD with current Rotary Encoder detent count
// ****************************************************************************
void updateLcd()
{
rotaryDisabled = 1;
lcd.setCursor(0, 1);
lcd.print(F("Count = "));
lcd.print(rotaryCount);
lcd.print(F(" "));
rotaryDisabled = 0;
}
// ****************************************************************************
// setup() - Initialization Function
// ****************************************************************************
void setup()
{
initializeRotaryEncoder();
initializeLcd();
}
// ****************************************************************************
// loop() - Main Program Loop Function
// ****************************************************************************
void loop()
{
updateLcd();
btnRot.tick();
delay(50);
}
// ***********************************
Links
Saturday, 1 April 2017
I2C LCD display - arduino
This is not your usual LCD.
It's a 1602 16X2 LCD Display IIC/I2C/TWI/SPI Serial Interface Module For Arduino
It has a backlight and is ideal for displaying text characters... 32 ASCII in 2 rows.
There is room for 16 characters in each row.
Each character is made up of a tiny grid of 5x8 pixels.
There is also a 20 character by 4 lines version
The pin resources of many Arduinos are limited.
I'm using a Uno.
Sometimes the project may be not able to use a normal LCD
once it's connected with sensors, etc. Sometimes, you use up to 8 pins.
However, with this I2C interface LCD module, you can display data with only 2 wires..... I2C (and of course Vcc & Gnd)
The I2C is a type of serial bus
developed by Philips, which uses two bidirectional lines, called SDA
(Serial Data Line) and SCL (Serial Clock Line).
The supply voltage is 5V
Many adapters use a 8-bit PCF8574 chip from Texas Instruments which does the i2c data conversions.
Here is the datasheet:
This particular adapter is from NXP Semiconductors.
Here is their datasheet.
There are 4 connections
GND
Vcc - 5V
SDA - serial data (A4 on the Uno)
SCL - serial clock (A5 on the Uno)
The trimpot adjusts the LCD contrast.
Note the jumper on the left of the board. This supplies power to the backlight.
If you wish to
control the intensity of the backlight, remove the jumper and
apply a control voltage to the pin that is marked as ‘LED’.
Before you can use it you need to find the i2c address of the display
Here is a simple piece of code to upload to the IDE
scanner code
********************************************
Thanks to Nick Gammon.
- // --------------------------------------
- // i2c_scanner
- //
- // Version 1
- // This program (or code that looks like it)
- // can be found in many places.
- // For example on the Arduino.cc forum.
- // The original author is not know.
- // Version 2, Juni 2012, Using Arduino 1.0.1
- // Adapted to be as simple as possible by Arduino.cc user Krodal
- // Version 3, Feb 26 2013
- // V3 by louarnold
- // Version 4, March 3, 2013, Using Arduino 1.0.3
- // by Arduino.cc user Krodal.
- // Changes by louarnold removed.
- // Scanning addresses changed from 0...127 to 1...119,
- // according to the i2c scanner by Nick Gammon
- // https://www.gammon.com.au/forum/?id=10896
- // Version 5, March 28, 2013
- // As version 4, but address scans now to 127.
- // A sensor seems to use address 120.
- // Version 6, November 27, 2015.
- // Added waiting for the Leonardo serial communication.
- //
- //
- // This sketch tests the standard 7-bit addresses
- // Devices with higher bit address might not be seen properly.
- //
- #include <Wire.h>
- void setup()
- {
- Wire.begin();
- Serial.begin(9600);
- while (!Serial); // Leonardo: wait for serial monitor
- Serial.println("\nI2C Scanner");
- }
- void loop()
- {
- byte error, address;
- int nDevices;
- Serial.println("Scanning...");
- nDevices = 0;
- for(address = 1; address < 127; address++ )
- {
- // The i2c_scanner uses the return value of
- // the Write.endTransmisstion to see if
- // a device did acknowledge to the address.
- Wire.beginTransmission(address);
- error = Wire.endTransmission();
- if (error == 0)
- {
- Serial.print("I2C device found at address 0x");
- if (address<16)
- Serial.print("0");
- Serial.print(address,HEX);
- Serial.println(" !");
- nDevices++;
- }
- else if (error==4)
- {
- Serial.print("Unknown error at address 0x");
- if (address<16)
- Serial.print("0");
- Serial.println(address,HEX);
- }
- }
- if (nDevices == 0)
- Serial.println("No I2C devices found\n");
- else
- Serial.println("done\n");
- delay(5000); // wait 5 seconds for next scan
- }
// ************************************
Another option is to hardwire the address.
This is useful if you have multiple devices. You can set a different I2C address so that
it doesn't conflict with any other I2C devices.
The back of the module has these solder pads:
A0, A1, A2
Short these jumpers to set the address.
The jumpers take two inputs .. HIGH or LOW
We can create 8 (23) different combinations.
By default on Texas chips, all the 3 address inputs are pulled HIGH using onboard pullups, giving their PCF8574 a default I2C address of 0100111Binary or 0x27Hex.
Ther three address selection bits (A0, A1 and A2) are placed at the end of the 7-bit I2C address register.
X,X,X,X,A0,A1,A2
On a NXP chip,
all the 3 address inputs are pulled HIGH using onboard pullups, giving their PCF8574 a default I2C address of 0111111Binary or 0x3FHex.
***************************************
My LCD displays address was 0x3F
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// Change the 0x3F i2c address to your i2c
// Change the 0x3F i2c address to your i2c
// LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
You need this library:
The LiquidCrystal_I2C library works in combination with the Wire.h library which allows you to communicate with I2C devices.
// **********************************************************
//code 1..Hello World
// include the library code:
#include <LiquidCrystal_I2C.h>
#include <Wire.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// Change the 0x3F i2c address to your i2c
// LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
lcd.clear();
// Print a message to the LCD.
lcd.print("hello, world!");
}
void loop() {
}
// ****************************************************************
// Example 3
// hELLO synth nerds
// Moving text on the two lines:
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // set the LCD address to 0x3F for a 16 chars and 2 line display
void setup() {
lcd.begin(16, 2);
lcd.clear();
lcd.backlight(); // Make sure backlight is on
// Print a message on both lines of the LCD.
lcd.setCursor(2,0); //Set cursor to character 2 on line 0
lcd.print("Hello Synth");
lcd.setCursor(5,1); //Move cursor to character 5 on line 1
lcd.print("Nerds !");
}
void loop() {
}
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // set the LCD address to 0x3F for a 16 chars and 2 line display
void setup() {
lcd.begin(16, 2);
lcd.clear();
lcd.backlight(); // Make sure backlight is on
// Print a message on both lines of the LCD.
lcd.setCursor(2,0); //Set cursor to character 2 on line 0
lcd.print("Hello Synth");
lcd.setCursor(5,1); //Move cursor to character 5 on line 1
lcd.print("Nerds !");
}
void loop() {
}
// *****************************************
Example 4 - creating symbols
I love synthesizers 1
The heart symbol has been made with the online LCD symbol generator:
https://maxpromer.github.io/LCD-Character-Creator/
https://maxpromer.github.io/LCD-Character-Creator/
// *********************************
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
byte heart[] = {
0x00,
0x0A,
0x1F,
0x1F,
0x0E,
0x04,
0x00,
0x00
};
void setup() {
lcd.begin(16, 2);
lcd.backlight(); // turn backlight on
lcd.clear(); // clear the screen
lcd.createChar(1, heart); // define a symbol for memory position 1
lcd.setCursor(0, 1); // set the cursor to position 1, line 2
lcd.print("I "); // write on the screen
lcd.write(1); // write symbol from memory position 1
lcd.print(" Synthesizers"); // write on the screen
}
void loop() {}
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
byte heart[] = {
0x00,
0x0A,
0x1F,
0x1F,
0x0E,
0x04,
0x00,
0x00
};
void setup() {
lcd.begin(16, 2);
lcd.backlight(); // turn backlight on
lcd.clear(); // clear the screen
lcd.createChar(1, heart); // define a symbol for memory position 1
lcd.setCursor(0, 1); // set the cursor to position 1, line 2
lcd.print("I "); // write on the screen
lcd.write(1); // write symbol from memory position 1
lcd.print(" Synthesizers"); // write on the screen
}
void loop() {}
// ***********************************
I love synthesizers 2
The EQ symbol has been made with the online LCD symbol generator:
https://maxpromer.github.io/LCD-Character-Creator/
https://maxpromer.github.io/LCD-Character-Creator/
// *********************************
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// RS, E, D4, D5, D6, D7
byte customChar[] = {
0x00,
0x02,
0x02,
0x0A,
0x0B,
0x1B,
0x1F,
0x1F
};
void setup() {
lcd.begin(16, 2);
lcd.backlight(); // turn backlight on
lcd.clear(); // clear the screen
lcd.createChar(1, customChar); // define a symbol for memory position 1
lcd.setCursor(0, 1); // set the cursor to position 1, line 2
lcd.print("I "); // write on the screen
lcd.write(1); // write symbol from memory position 1
lcd.print(" Synthesizers"); // write on the screen
}
void loop() {}
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x3F, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);
// RS, E, D4, D5, D6, D7
byte customChar[] = {
0x00,
0x02,
0x02,
0x0A,
0x0B,
0x1B,
0x1F,
0x1F
};
void setup() {
lcd.begin(16, 2);
lcd.backlight(); // turn backlight on
lcd.clear(); // clear the screen
lcd.createChar(1, customChar); // define a symbol for memory position 1
lcd.setCursor(0, 1); // set the cursor to position 1, line 2
lcd.print("I "); // write on the screen
lcd.write(1); // write symbol from memory position 1
lcd.print(" Synthesizers"); // write on the screen
}
void loop() {}
Links
---------------------------------
------------------------------------- Micro Granny - Basl Instruments
Thanks Andrew for bringing this over
It's all 8-bit.
Uses a microcontroller / Arduino platform.
Its a monophonic granular sampler. It reads wav samples from microSD card and applies granular algorithms to them. You can also adjust start, end, sample rate (tuned or free run), crush and envelope (attack release).
It's all 8-bit.
Uses a microcontroller / Arduino platform.
Korg PS 3200
The lovely Sounds of the Korg Ps 3200
Andrew brought his Future Retro Zillion sequencer yesterday
so we decided to test it out on the Korg.
Andrew brought his Future Retro Zillion sequencer yesterday
so we decided to test it out on the Korg.
Subscribe to:
Posts (Atom)