Showing posts with label DIY. Show all posts
Showing posts with label DIY. Show all posts

Thursday, 18 May 2017

Data Types - Constants vs Variables

Data types are closely associated with memory
All data occupies memory 
Below is a list of many of the data types commonly seen in Arduino. 
The memory size of each is listed in parentheses after the type name.
 

 Constants

The value can't be changed. It's read only. 
 
+ Defining pin levels: HIGH  vs LOW 
   High: voltage greater than 3.0V is present at the pin (5V boards)
   LOW:  a voltage less than 1.5V is present at the pin (5V boards)
 
+ Defining pinModes:
   INPUT vs OUTPUT , INPUT_PULLUP

+ boolean Constants (8 bit) - simple logical true/false.
   false is defined as 0 (zero).
   Any integer which is non-zero is true, in a Boolean sense. 
   So -1, 2 and -200 are all defined as true, too, in a Boolean sense. 
 
+ Floating Point Constants
   eg : n = 0.007; // 0.007 is a floating point constant
          You can also express them in scientific notation.
          thus 2.34E5 = 234000
 
+ Integer Constants 
    eg   n = 345;
           Normally, we use decimal numbers, but other bases can be used like binary or hexadecimal.
 

VARIABLES

These are memory locations which can be changed as many times as you like.
Memory is measured in bits and bytes.
8 bit = 1 byte
Note: signed variables allow both positive and negative numbers, while unsigned variables allow only positive values. 

 
+ boolean (8 bit/1 byte) - simple logical true/false. 
+ byte (8 bit or 1 byte) - unsigned number from 0-255 
+ char (8 bit) - signed number from -128 to 127. 
    The compiler will attempt to interpret this data type as a character (like ‘a’ or ‘!’) 
    in some circumstances.
+  unsigned char (8 bit) - same as the 'byte' data type.
    The unsigned char datatype encodes numbers from 0 to 255. The byte data type is preferred.
+  word (16 bit or 2 bytes) - unsigned number from 0-65535
+  int (16 bit) - signed number from -32768 to 32767. 
    This is most commonly what you see used for general purpose variables in 
     Arduino example code provided with the IDE
 +  unsigned int (16 bit or 2 bytes)- They only store positive values.
    They thus yield a range of 0 to 65,535 ((2^16) - 1)
+  long (32 bit) - signed number from -2,147,483,648 to 2,147,483,647
+  unsigned long (32 bit or 4 bytes) - store positive numbers from 0 to 4,294,967,295. 
    The most common usage of this is to store the result of the millis() function, 
    which returns the number of milliseconds the current code has been running 
+  short (16 bit) - range of -32,768 to 32,767
+  float (32 bit) - signed number from -3.4028235E38 to 3.4028235E38. 
     Floating point on the Arduino is not native & the compiler has to do complicated math to make it work.
     Avoid if you can.
double (32 bit) - double-precision floating point number.
     can hold very large (or small) numbers. Some of the bits are used to tell 
     where the decimal place goes.  This leaves 6 to 7 digits of precision.
+ string - holds ASCII characters.. that is, it holds text .. 
      you might use this to send a message via a serial port. 
 

Arrays

 
+ Array - This is a list or collection of variables that can be accessed via an index number. 
      The word "array" isnt actually used. The symbols [] and {} do the job.
      eg: int myArray[] = {6,21,34,2,1,0,152}; 
      Here we declared an array with 7 values.  Arduino creates 7 places in memory for these values.
 
     We can also just tell the arduino to create 7 memory spots, and then enter the values later :
      int myArray[7];
 
To assign a value to the second spot we use a command like this:
myArray[1] = 21; 
This is the index number.
The first spot always has an index value of 0 (they are zero indexed).
 
 
 
 
Links:
 

 

 ---------------------------------
-------------------------------------

Friday, 28 April 2017

Functions - Arduino

 As your programs become more complicated we try to break up the code into
more easily managed blocks.
We break them up into "functions".
 
The arduino main reference page lists all the major functions:

The two essential functions in any sketch are
void setup (){}
and 
void loop (){}

 All functions must have these basic things:
1. unique name [alphanumeric characters (A to Z; a to z; 0 to 9) and the underscore (_).]
    You can't start the name with a number.
2. the name must be followed by ()
3. they must have a return type : eg void
4. The body of the function is enclosed in braces {}
 
-------------------------------------------------------------------------

Structure of functions.

This is an example of a function that was created to print the numbers 123456789. 
In this example the name "NumbersAcend()" is the function name.
In this example "void" is referred to as the return type

void NumbersAcend()
{
      Serial.println("123456789");
 }
 
 
 Links
+ https://www.youtube.com/watch?v=VHK69SB3lo4
 
 
 ---------------------------------
-------------------------------------

Friday, 21 April 2017

Serial Monitor - Reading numbers

This is all about how to read data from the serial monitor.
The serial monitor, allows you to capture and enter data in real time.
It is the 'tether' between the computer and your Arduino - it lets you send and receive text messages
which is handy for debugging and also controlling the Arduino from a keyboard! 
 
The Arduino IDE serial monitor looks like this:
 

 
Below is some code on entering data into the serial monitor.

The arduino will wait till you have entered a value.

This serial monitor is in TinkerCad. 

Example 1

// variables
int myNumber;
String msg="Please Enter Your Number:";
String msg2="Your Number is: ";

void setup()
{
  Serial.begin(9600);
}

void loop()
{
  // 3 things we do: ask wait read
  Serial.println(msg); //ask
  while (Serial.available()==0){
    // while there is no data
    //on the serial loop do nothing ..wait
   }
    //read
 
    myNumber=Serial.parseInt();
    Serial.print(msg2);

    Serial.println(myNumber);
 
  }

-----------------------------------------------------

Example 2
// we want the user to select how many times to blink the LED

// we want the user to select how many times to blink the LED

// variables
int numBlinks;
String msg="How many blinks do you want?:";
int j;
int bt=100;
int redPin=12;


void setup()
{
  Serial.begin(9600);
  pinMode(redPin,OUTPUT);
}

void loop()
{
  // 3 things we do: ask wait read
  Serial.println(msg); //ask
  while (Serial.available()==0){
    // while there is no data
    //on the serial loop do nothing ..wait
  }
    //read
    numBlinks=Serial.parseInt();
  for (j=1;j<=numBlinks;j=j+1){
    digitalWrite(redPin,HIGH);
    delay(bt);
    digitalWrite(redPin,LOW);
    delay(bt);
  }
      
   
 
}

-----------------------------------------------------------------------------------

Example 3
Not using the LED this time.

-------
// calculate the area of a circle

// variables

String msg="What is the radius of your circle ?:";
float radius;
float area;
String msg2="Your Circle Has an Area of : ";
float pi=3.14;

void setup()
{
  Serial.begin(9600);
 
}

void loop()
{
  // 3 things we do: ask wait read
  Serial.println(msg); //ask
  {
  while (Serial.available()==0);
    // while there is no data
    //on the serial loop do nothing ..wait
}
    //read
    radius=Serial.parseFloat(); // parseFloat  not parseInt
  area=pi*radius*radius;
  Serial.print(msg2);
  Serial.println(area);
 
      
   
 
}

 ----------------------------------------------

Links

 
 ---------------------------------
------------------------------------- 

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
 

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);
}

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

 
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.
 
  1. // --------------------------------------
  2. // i2c_scanner
  3. //
  4. // Version 1
  5. //    This program (or code that looks like it)
  6. //    can be found in many places.
  7. //    For example on the Arduino.cc forum.
  8. //    The original author is not know.
  9. // Version 2, Juni 2012, Using Arduino 1.0.1
  10. //     Adapted to be as simple as possible by Arduino.cc user Krodal
  11. // Version 3, Feb 26  2013
  12. //    V3 by louarnold
  13. // Version 4, March 3, 2013, Using Arduino 1.0.3
  14. //    by Arduino.cc user Krodal.
  15. //    Changes by louarnold removed.
  16. //    Scanning addresses changed from 0...127 to 1...119,
  17. //    according to the i2c scanner by Nick Gammon
  18. //    https://www.gammon.com.au/forum/?id=10896
  19. // Version 5, March 28, 2013
  20. //    As version 4, but address scans now to 127.
  21. //    A sensor seems to use address 120.
  22. // Version 6, November 27, 2015.
  23. //    Added waiting for the Leonardo serial communication.
  24. //
  25. //
  26. // This sketch tests the standard 7-bit addresses
  27. // Devices with higher bit address might not be seen properly.
  28. //
  29.  
  30. #include <Wire.h>
  31.  
  32.  
  33. void setup()
  34. {
  35.   Wire.begin();
  36.  
  37.   Serial.begin(9600);
  38.   while (!Serial);             // Leonardo: wait for serial monitor
  39.   Serial.println("\nI2C Scanner");
  40. }
  41.  
  42.  
  43. void loop()
  44. {
  45.   byte error, address;
  46.   int nDevices;
  47.  
  48.   Serial.println("Scanning...");
  49.  
  50.   nDevices = 0;
  51.   for(address = 1; address < 127; address++ )
  52.   {
  53.     // The i2c_scanner uses the return value of
  54.     // the Write.endTransmisstion to see if
  55.     // a device did acknowledge to the address.
  56.     Wire.beginTransmission(address);
  57.     error = Wire.endTransmission();
  58.  
  59.     if (error == 0)
  60.     {
  61.       Serial.print("I2C device found at address 0x");
  62.       if (address<16)
  63.         Serial.print("0");
  64.       Serial.print(address,HEX);
  65.       Serial.println("  !");
  66.  
  67.       nDevices++;
  68.     }
  69.     else if (error==4)
  70.     {
  71.       Serial.print("Unknown error at address 0x");
  72.       if (address<16)
  73.         Serial.print("0");
  74.       Serial.println(address,HEX);
  75.     }    
  76.   }
  77.   if (nDevices == 0)
  78.     Serial.println("No I2C devices found\n");
  79.   else
  80.     Serial.println("done\n");
  81.  
  82.   delay(5000);           // wait 5 seconds for next scan
  83. }
 
// ************************************
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 
// 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() {
}
// *****************************************


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/ 
 
// *********************************
 
#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() {}

// ***********************************
I love synthesizers 2
 The EQ symbol has been made with the online LCD symbol generator:
 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() {}



Links
 

 ---------------------------------
-------------------------------------

Wednesday, 29 March 2017

Buchla Preset card - DIY mixer for 208 easel

One of the best things about the Buchla Music Easel is its program card.
It's really not just for presets ... esp the original card invented by Don Buchla back in the 1970s.


I'm guessing he may have wanted us users to experiment with electronic circuits.
Why else would Don have placed a mini "breadboard" with +/- 15V rails on the program card?

The Buchla SILI-CON CELLO from 1978 is a good example of his use of breadboard circuits in a fully
functioning system. It's a shame the current BEMI program cards have removed this homage to the age of DIY electronics.

This is my latest use of the card: a DIY mixer.
(The 10U system doesn't have a dedicated mixer).

The circuit is very simple.
Just one dual op-amp (TL072)

It's a basic unity gain inverting configuration. In the first half the 4 inputs are mixed into the inverting input of a op-amp. Since the output signal from this op-amp is inverted, the 2nd op-amp  re-inverts it. 
Power goes to pins 4 & 8. The unmarked resistor on the right is 1K

Thanks to Ken Stone for the original circuit. and Justin from MetroModular for his advice.
Ken's schematics show the possibility for using this as a CV mixer & attenuverter.

Breadboarding the circuit. Just two inputs on the left without pots.
It works on +/-12V above and +/-15V below.

Might try building a mixer using the OPA2134.
It's pinout is the same as the TL072.

Saturday, 25 March 2017

Momentary push buttons - Turning a LED on with a button - arduino

Momentary push buttons
These are really common in arduino projects
 
  It's a basically 2 switches
 
The vertical leads are internally connected prior to pressing the button.
 
Pressing the button will close those switches at the top & bottom of the switch.
 
 
 
 
 
 

The circuit below, doesn't use any coding. The arduino board is simply a power supply.
 
 

 
 Code 1
This is a basic code using pulldown resistors and a switch.
It's a complicated way of turning a LED on.
The idea is to use software, rather than hardware to turn the switch on.
 
Black is ground.
Red is +5V
When the button is not pressed, the pin 2 is connected to ground (via the resistor).
Pin 2 thus reads LOW
When the button is pressed, Pin 2 is connected to +5V, and thus reads a HIGH.
 

Here is the code:
//----------------..........................................
/*
  Button

  Turns on and off a light emitting diode(LED) connected to digital pin 13,
  when pressing a pushbutton attached to pin 2.

  The circuit:
  - LED attached from pin 13 to ground
  - pushbutton attached to pin 2 from +5V
  - 10K resistor attached to pin 2 from ground

  - Note: on most Arduinos there is already an LED on the board
    attached to pin 13.

  created 2005
  by DojoDave <http://www.0j0.org>
  modified 30 Aug 2011
  by Tom Igoe

  This example code is in the public domain.

  http://www.arduino.cc/en/Tutorial/Button
*/

// constants won't change. They're used here to set pin numbers:
const int buttonPin = 2;     // the number of the pushbutton pin
const int ledPin =  13;      // the number of the LED pin

// variables will change:
int buttonState = 0;         // variable for reading the pushbutton status

void setup() {
  // initialize the LED pin as an output:
  pinMode(ledPin, OUTPUT);
  // initialize the pushbutton pin as an input:
  pinMode(buttonPin, INPUT);
}

void loop() {
  // read the state of the pushbutton value:
  buttonState = digitalRead(buttonPin);

  // check if the pushbutton is pressed. If it is, the buttonState is HIGH:
  if (buttonState == HIGH) {
    // turn LED on:
    digitalWrite(ledPin, HIGH);
  } else {
    // turn LED off:
    digitalWrite(ledPin, LOW);
  }
}

 // -----------



Basic program # 2
Slightly different way to do the same thing.
 
 

The pushbutton is part of the pulldown resistor detection system

pin 9 reads either a HIGH or LOW signal. 
Its the input
When the button is not pressed, pin 9 is connected to 5V through the resistor... Thus HIGH.
Digital pins are instructed to stay LOW and don't put out 5V to light the LEDs.

When the button is pressed, the opposite occurs.

Here is the code
// ---------------------------------------------------------

int buttonstate = 0;

void setup()
{
  pinMode(9, INPUT);
  pinMode(13, OUTPUT);
  pinMode(6, OUTPUT);
}

void loop()
{
  buttonstate = digitalRead(9);
  if (buttonstate == HIGH) {
    // when not pressed the pull up resistor is on
    digitalWrite(13, LOW);
    digitalWrite(6, LOW);
  } else {
    // helpful single-line comment here
    digitalWrite(13, HIGH);
    digitalWrite(6, HIGH);
  }
  delay(10); // Delay a little bit to improve simulation performance
}
// -------------------------------------------------------

Superbooth - Berlin - Aussie Manufacturers





Oscillosaurus
https://www.facebook.com/oscillosaurus/

Golt!
https://www.facebook.com/skewy?hc_ref=SEARCH&fref=nf 
https://www.youtube.com/watch?v=M1oTKRkTU0o

Amalgamod
https://www.facebook.com/amalgamod/

Metromodular
http://metro-modular.com/ 
https://www.facebook.com/Metro.Modular/

NonlinearCircuits
http://www.nonlinearcircuits.com/

Beast-Tek
http://www.beast-tek.com/
https://www.facebook.com/BeastTek/

Worng Electronics
https://www.facebook.com/worngelectronics/

Cat Full Of Ghosts
https://www.facebook.com/cfogElectronics/?hc_ref=SEARCH&fref=nf
http://www.catfullofghosts.com/


Wednesday, 22 March 2017

Critter and Guitari Cellular Automata



Links re Cellular A:
Muffs - code
Github - more code
GetLoFi - DIY kit
Critter and Guitari - website
Circuit bent CA synth
Wikipedia
Muffs 2 - Mr Coops
Muffs 3 - PCB buy

Critter & Guitari Cellular Automata Synthesizer from Critter & Guitari on Vimeo.

--------

...
 Critter and Guitari Cellular Automata Synthesizer by Owen Osborn

I'm building a DIY version kindly provided by "n167tx" (Muffs)

The parts list is on the right.
You need to download the eagle file and upload to this viewer:
http://3dbrdviewer.cytec.bg/board


Eagle has a free viewer.
Download here:
http://www.autodesk.com/products/eagle/overview

Microcontroller used:
The AtMEGA8
http://www.atmel.com/Images/Atmel-2486-8-bit-AVR-microcontroller-ATmega8_L_datasheet.pdf

The AtmelAVR ATmega8 is a low-power CMOS 8-bit microcontroller

Links re AVR programming.
1. PocketMagic
2. Instructables
3. Youtube
4. youtube 2