Posts with «processing» label

Glitch synthesizer

Glitch is a sound and graphic synthesizer, powered by Arduino, fitted in a Tupperware and using few electronic components.

The sounds are generated by Puredata, then sent via OSC protocol to Processing for the graphic display.

The physical inputs are managed by an Arduino board.

It has been developed by Thomas Meghe, and here you can find the project page.

Arduino Blog 15 May 07:15

arduino audio music processing puredata

Mouse Controlling Arduino LEDs

Use a mouse to control LEDs attached to an Arduino. This project uses the processing language to transmit the mouse coordinates to the Arduino, which then uses this information to turn on some LEDs. Please see the video below to see it in action.

Components Required for this project:

Arduino UNO
Breadboard
9 LEDs
9 x 330 ohm resistors
Wires to connect the circuit
USB connection cable: to connect the computer to the Arduino
A computer: to run the processing sketch, and to compile / upload the Arduino sketch
Processing Program installed on computer
Arduino Program installed on the computer

Arduino Sketch

This was made using Fritzing.

Arduino Code

You can download the Arduino IDE from this site.

/* This program was created by ScottC on 9/5/2012 to receive serial 
signals from a computer to turn on/off  1-9 LEDs */

void setup() {                
  // initialize the digital pins as an output.
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
// Turn the Serial Protocol ON
  Serial.begin(9600);
}

void loop() {
  byte byteRead;

   /*  check if data has been sent from the computer: */
  if (Serial.available()) {
  
    /* read the most recent byte */
    byteRead = Serial.read();
    //You have to subtract '0' from the read Byte to convert from text to a number.
    byteRead=byteRead-'0';
    
    //Turn off all LEDS
    for(int i=2; i<11; i++){
      digitalWrite(i, LOW);
    }
    
    if(byteRead>0){
      //Turn on the relevant LEDs
      for(int i=1; i<(byteRead+1); i++){
        digitalWrite(i+1, HIGH);
      }
    }
  }
}

The code above was formatted using this site.

Processing Code

You can download the Processing IDE from this site.

//Created by ScottC on 12/05/2012 to send mouse coordinates to Arduino

import processing.serial.*;

// Global variables
int new_sX, old_sX;
int nX, nY;
Serial myPort;

// Setup the Processing Canvas
void setup(){
  size( 800, 400 );
  strokeWeight( 10 );
 
  //Open the serial port for communication with the Arduino
  //Make sure the COM port is correct
  myPort = new Serial(this, "COM6", 9600);
  myPort.bufferUntil('\n'); 
}

// Draw the Window on the computer screen
void draw(){
  
  // Fill canvas grey
  background( 100 );
    
  // Set the stroke colour to white
  stroke(255); 
  
  // Draw a circle at the mouse location
  ellipse( nX, nY, 10, 10 );

  //Draw Line from the top of the page to the bottom of the page
  //in line with the mouse.
  line(nX,0,nX,height);  
}


// Get the new mouse location and send it to the arduino
void mouseMoved(){
  nX = mouseX;
  nY = mouseY; 
  
  //map the mouse x coordinates to the LEDs on the Arduino.
  new_sX=(int)map(nX,0,800,0,10);

  if(new_sX==old_sX){
    //do nothing
  } else {
    //only send values to the Arduino when the new X coordinates are different.
    old_sX = new_sX;
    myPort.write(""+new_sX);
  }
}

The code above was formatted using this site.

ScottC 12 May 09:25

arduino arduinobasics best arduino blog code communication control led light mouse processing project serial

Does Arduino dream of a playing tree?

With the help from Lindsey French, some houseplants in Chicago have enjoyed a concert generated by the vibrations of a cherry tree in western Massachusetts.

Attached to the cherry tree was a piezo sensor, which measured the tree’s vibrations. These were uploaded to the world wide web using an Ethernet Pro as a server, and a friend’s wireless router, configured to allow port forwarding. On the chicago end, a processing sketch gathered the data and wrote it to the serial port my laptop. An Arduino attached to the laptop output the data to transducers, which were attached to ceramic saucers (and later, a plywood shelf) as the medium for the vibrations. The Arduino and breadboard were housed in a custom laser-cut box, based off of a modified thingverse template.

Read here the full story.

Arduino Blog 11 May 16:05

actuators arduino art music processing sensors

Roster

Primary image

What does it do?

navigate around via infered

oooooo spooky image

this image was created by scanning a Sharpe ir distance sensor on tilt and pan servos controlled by an Arduino and rendered in Processing. the closer the object is the brighter the pixel is .the view is the same as my Egg bot assembly video, if you have had a look at that.

At this point you might be thinking , why is this posted as a robot?!

Cost to build

Embedded video

Finished project

Number

Time to build

1 hour

Type

URL to more information

Weight

Let's Make Robots 10 May 10:56

4 servos arduino arduino uno (atmega328) autonomous external lab power surply indoor processing servo sharp ir sharp sensor wii cam wii ir camera

MAKEmatics – Mathematics for Makers

Makers need to familiarize themselves with the core concepts and the theory involved in creating applications such as Motion Sensing and Face Tracking. As the technology is churning out new hardware day and night, DIYers need to work hard to keep up and always be in touch with the latest technology around them.

-->-->

For example, anyone working with Accelerometers/ Gyroscopes or Inertial Measurement Units needs to understand the theory of Vectors, Force, Gravity and be able to work out complex mathematical problems. They may easily get an Arduino Board and an Accelerometer Breakout or an IMU Board and use a library instead of writing their own code but to truly understand the theory behind it; how the device actually works, is not for the faint of heart.

One such problem is the Face Tracking Application. Unless you know the real theory behind how the Algorithm actually works, you can only wonder about that robot which follows its master. Greg Borenstein had an idea of creating a website dedicated to this issue. Makematics – Math for Makers.

In an introductory post, Greg writes:

” I hope to show that a normal programmer with no special academic training can grapple with these areas of research and find a way in to understanding them. And as I go I aim to create material that will help others do the same. If I can do it, there’s no reason you can’t.”

More and more people should step forward and create or compile a good amount of research data to help fellow makers and DIYers in solving complex mathematical problems.

Reading from a Text File and Sending to Arduino

The following tutorial will demonstrate how to Read values from a Text file (.txt, .csv) to blink 1 of 9 LEDs attached to an Arduino. It uses the combination of an Arduino and Processing program to process the file. The Processing program will read the text file in real time, only sending new information to the Arduino.

Components Required

Arduino UNO
Breadboard
9 LEDs
9 x 330 ohm resistors
Wires to connect the circuit
USB connection cable: to connect the computer to the Arduino
A computer: to run the processing sketch, and to compile / upload the Arduino sketch
Processing Program installed on computer
Arduino Program installed on the computer
A comma separated text file (*.txt).

Arduino Layout

The Text File

Open Notepad or equivalent text file editor, and paste the following data into it.

1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1

Save the file on your hard drive. In my case, I have chosen to save the file at this location.

D:/mySensorData.txt

It should look like the following screenshot

Additional notes regarding the Text file:

Just remember what you call it, and where you saved it, because we will be referring to this file later on in the Processing script.
Keep all values on the same line.
Separate each number with a comma.
The number 1 will blink the first LED which is attached to Pin 2 on the Arduino.
The number 9 will blink the last LED which is attached to Pin 10 on the Arduino.

Processing Code

You can download the Processing IDE from this site.


style="color: blue;">import processing.serial.*;

style="color: blue;">import java.io.*;

style="color: rgb(43, 145, 175);">int mySwitch=0;

style="color: rgb(43, 145, 175);">int counter=0;
String [] subtext;
Serial myPort;



style="color: rgb(43, 145, 175);">void setup(){
 
style="color: green;">//Create a switch that will control the frequency of text file reads.
 
style="color: green;">//When mySwitch=1, the program is setup to read the text file.
 
style="color: green;">//This is turned off when mySwitch = 0
 mySwitch=1;
 
 
style="color: green;">//Open the serial port for communication with the Arduino
 
style="color: green;">//Make sure the COM port is correct
 myPort = 
style="color: blue;">new Serial(this, 
style="color: rgb(163, 21, 21);">"COM6", 9600);
 myPort.bufferUntil(
style="color: rgb(163, 21, 21);">'\n');
}


style="color: rgb(43, 145, 175);">void draw() {
 
style="color: blue;">if (mySwitch>0){
 
style="color: green;">/*The readData function can be found later in the code.

style="color: green;"> This is the call to read a CSV file on the computer hard-drive. */
 readData(
style="color: rgb(163, 21, 21);">"D:/mySensorData.txt");
 
 
style="color: green;">/*The following switch prevents continuous reading of the text file, until

style="color: green;"> we are ready to read the file again. */
 mySwitch=0;
 }
 
style="color: green;">/*Only send new data. This IF statement will allow new data to be sent to

style="color: green;"> the arduino. */
 
style="color: blue;">if(counter<subtext.length){
 
style="color: green;">/* Write the next number to the Serial port and send it to the Arduino 

style="color: green;"> There will be a delay of half a second before the command is

style="color: green;"> sent to turn the LED off : myPort.write('0'); */
 myPort.write(subtext[counter]);
 delay(500);
 myPort.write(
style="color: rgb(163, 21, 21);">'0');
 delay(100);
 
style="color: green;">//Increment the counter so that the next number is sent to the arduino.
 counter++;
 } 
style="color: blue;">else{
 //If the text file has run out of numbers, then read the text file again in 5 seconds.
 delay(5000);
 mySwitch=1;
 }
} 



style="color: green;">/* The following function will read from a CSV or TXT file */

style="color: rgb(43, 145, 175);">void readData(String myFileName){
 
 File file=
style="color: blue;">new File(myFileName);
 BufferedReader br=
style="color: blue;">null;
 
 try{
 br=
style="color: blue;">new BufferedReader(
style="color: blue;">new FileReader(file));
 String text=
style="color: blue;">null;
 
 
style="color: green;">/* keep reading each line until you get to the end of the file */
 
style="color: blue;">while((text=br.readLine())!=
style="color: blue;">null){
 /* Spilt each line up into bits and pieces using a comma as a separator */
 subtext = splitTokens(text,
style="color: rgb(163, 21, 21);">",");
 }
 }
style="color: blue;">catch(FileNotFoundException e){
 e.printStackTrace();
 }
style="color: blue;">catch(IOException e){
 e.printStackTrace();
 }
style="color: blue;">finally{
 try {
 
style="color: blue;">if (br != null){
 br.close();
 }
 } 
style="color: blue;">catch (IOException e) {
 e.printStackTrace();
 }
 }
}

I used this site to highlight and format my code.

Once you have copied the text above into the Processing IDE, you can now start working on the Arduino code as seen below.

Arduino Code

You can download the Arduino IDE from this site.

Copy and paste the following code into the Arduino IDE.


style="color: green;">/* This program was created by ScottC on 8/5/2012 to receive serial 

style="color: green;">signals from a computer to turn on/off 1-9 LEDs */


style="color: rgb(43, 145, 175);">void setup() { 
 
style="color: green;">// initialize the digital pins as an output.
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(7, OUTPUT);
 pinMode(8, OUTPUT);
 pinMode(9, OUTPUT);
 pinMode(10, OUTPUT);

style="color: green;">// Turn the Serial Protocol ON
 Serial.begin(9600);
}


style="color: rgb(43, 145, 175);">void loop() {
 
style="color: rgb(43, 145, 175);">byte byteRead;

 
style="color: green;">/* check if data has been sent from the computer: */
 
style="color: blue;">if (Serial.available()) {
 
 
style="color: green;">/* read the most recent byte */
 byteRead = Serial.read();
 
style="color: green;">//You have to subtract '0' from the read Byte to convert from text to a number.
 byteRead=byteRead-
style="color: rgb(163, 21, 21);">'0';
 
 
style="color: green;">//Turn off all LEDs if the byte Read = 0
 
style="color: blue;">if(byteRead==0){
 
style="color: green;">//Turn off all LEDS
 digitalWrite(2, LOW);
 digitalWrite(3, LOW);
 digitalWrite(4, LOW);
 digitalWrite(5, LOW);
 digitalWrite(6, LOW);
 digitalWrite(7, LOW);
 digitalWrite(8, LOW);
 digitalWrite(9, LOW);
 digitalWrite(10, LOW);
 }
 
 
style="color: green;">//Turn LED ON depending on the byte Read.
 
style="color: blue;">if(byteRead>0){
 digitalWrite((byteRead+1), HIGH); 
style="color: green;">// set the LED on
 }
 }
 }

Additional Information:

The Arduino code will still work without the processing program. You can open the serial monitor window to send the commands to the Arduino manually. In fact, if you encounter any problems, I would suggest you do this. It will help to identify the root cause of the problem (ie Processing or Arduino Code, or physical connections).
If you choose to use the Serial Monitor feature of the Arduino IDE, you cannot use the Processing program at the same time.

Once you have assembled the Arduino with all the wires, LEDs, resistors etc, you should now be ready to put it all together and get this baby cranking!

Connecting it all together

Connect the USB cable from your computer to the Arduino, and upload the code.
Keep the USB cable connected between the Arduino and the computer, as this will become the physical connection needed by the Processing Program
Make sure that you have the text file in the correct location on your hard drive, and that it only contains numbers relevant to the code provided (separated by commas).
Run the Processing program and watch the LEDs blink in the sequence described by the text file.
You can add more numbers to the end of the line, however, the processing program will not be aware of them until you save the file. The text file does not have to be closed.

Other programs can be used to create text file, but you will need the processing program to read the file and send the values to the Arduino. The Arduino will receive each value and react appropriately.

SIMILAR PROJECT: Use a mouse to control the LEDs on your Arduino - see this post.

An alternative Processing Sketch

This Processing sketch uses the loadStrings()method instead of the FileReader method used in the first sketch. This sketch also provides better control over sending the values to the Arduino. When the sketch first loads, the application window will be red. By clicking your mouse inside the window, the background will turn green and the file will be imported and sent to the Arduino, with every value being sent at half second intervals. If you update the text file and save, only new values will be transmitted, however, if you want the entire file to transmit again, you can press the window once (to reset the counter), and then again to read the file and send the values again from the beginning of the file.
I personally like this updated version better than the first, plus I was inspired to update this blog posting due to the fact that some people were having problems with the FileReader method in the first sketch. But both sketches should work (they worked for me).


style="color: rgb(0, 128, 0);">/* TextFile Sender: Written by Scott C on 5th April 2013

style="color: rgb(0, 128, 0);"> using Processing Version 2.0b8 */

import processing.serial.*;

Serial comPort;

style="color: rgb(43, 145, 175);">int counter=0; 
style="color: rgb(0, 128, 0);">// Helps to keep track of values sent.

style="color: rgb(43, 145, 175);">int numItems=0; 
style="color: rgb(0, 128, 0);">//Keep track of the number of values in text file
boolean sendStrings=
style="color: rgb(0, 0, 255);">false; 
style="color: rgb(0, 128, 0);">//Turns sending on and off
StringLoader sLoader; 
style="color: rgb(0, 128, 0);">//Used to send values to Arduino


style="color: rgb(43, 145, 175);">void setup(){
 comPort = 
style="color: rgb(0, 0, 255);">new Serial(
style="color: rgb(0, 0, 255);">this, Serial.list()[0], 9600);
 background(255,0,0); 
style="color: rgb(0, 128, 0);">//Start with a Red background
}


style="color: rgb(43, 145, 175);">void draw(){
}



style="color: rgb(43, 145, 175);">void mousePressed() {
 
style="color: rgb(0, 128, 0);">//Toggle between sending values and not sending values
 sendStrings=!sendStrings;
 
 
style="color: rgb(0, 128, 0);">//If sendStrings is True - then send values to Arduino
 
style="color: rgb(0, 0, 255);">if(sendStrings){
 background(0,255,0); 
style="color: rgb(0, 128, 0);">//Change the background to green
 
 
style="color: rgb(0, 128, 0);">/*When the background is green, transmit

style="color: rgb(0, 128, 0);"> text file values to the Arduino */
 sLoader=
style="color: rgb(0, 0, 255);">new StringLoader();
 sLoader.start();
 }
style="color: rgb(0, 0, 255);">else{
 background(255,0,0); 
style="color: rgb(0, 128, 0);">//Change background to red
 
style="color: rgb(0, 128, 0);">//Reset the counter
 counter=0;
 }
}




style="color: rgb(0, 128, 0);">/*============================================================*/

style="color: rgb(0, 128, 0);">/* The StringLoader class imports data from a text file

style="color: rgb(0, 128, 0);"> on a new Thread and sends each value once every half second */

style="color: rgb(0, 0, 255);">public 
style="color: rgb(0, 0, 255);">class 
style="color: rgb(43, 145, 175);">StringLoader extends Thread{
 
 
style="color: rgb(0, 0, 255);">public StringLoader(){
 
style="color: rgb(0, 128, 0);">//default constructor
 }
 
 
style="color: rgb(0, 0, 255);">public 
style="color: rgb(43, 145, 175);">void run() {
 String textFileLines[]=loadStrings(
style="color: rgb(163, 21, 21);">"d:/mySensorData.txt");
 String lineItems[]=splitTokens(textFileLines[0], 
style="color: rgb(163, 21, 21);">",");
 numItems=lineItems.length;
 
style="color: rgb(0, 0, 255);">for(
style="color: rgb(43, 145, 175);">int i = counter; i<numItems; i++){
 comPort.write(lineItems[i]);
 delay(500);
 comPort.write(
style="color: rgb(163, 21, 21);">"0");
 }
 counter=numItems;
 }
}

ScottC 09 May 14:09

arduino arduinobasics best arduino blog blink code comma csv delimitted file led processing project read serial text values

Chess sequencer

The musical interfaces can sometimes be extremely curious. That’s the case of the chess sequencer.

The Chess Sequencer is a step matrix sequencer made from a chess board, where placing the pieces make music. The sequencer is connected to software synths on my Mac trough USB and a Processing patch to convert the serial data to internal midi.

The core here is an Arduino Mega. I was planing to use the Duemilanove but laziness caught me. The Mega has tons of IOs so I do not have to make a lot of multiplexing saving me hours of work.

Check here the full instructions to build your own!

Arduino Blog 03 May 13:56

arduino controller music processing

Poor Man's Colour Detector (Part 2) - The project

In this project we will be detecting the colour of 3 different Mega Blok colours (Red, Yellow and Green). We will be using an Arduino UNO connected to 2 LEDs (one Yellow and one Red LED) as light detectors, and an RGB LED to illuminate the subject. We will use a Photocell to account for varying ambient light levels.

The signals from the LED light sensors will be sent to a Processing.org program via a Serial command. The computer program will make use of my Neural Network to classify the pattern of results and hopefully provide the correct colour "answer". The program should change the colour of the computer screen background to coincide with the colour of the Mega Blok.

The Video

Parts Required:

Arduino UNO...........x1
Red LED .................x1
Yellow LED.............x1
330 Ohm resistors... x 5 (for the LEDs)
Photocell .................x1
10K Ohm resistor....x1 (for the Photocell)
Around 11 wires and a Breadboard (or two) to put it all together

Here is the Fritzing Sketch: (made with Fritzing)

The Arduino Code

Load the following code into the Arduino.

arduino code Arduino: Colour Detector

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

/* Define the pin for the PhotoResistor */
#define PhotoR_Pin 0

/* Define the pins for the Red LED Sensor */
#define Red_LED_Sensor_POS 4
#define Red_LED_Sensor_NEG 5

/* Define the pins for the Yellow LED Sensor */
#define Yellow_LED_Sensor_POS 7
#define Yellow_LED_Sensor_NEG 8

/* Define the pin for the RGB LED torch */
#define RGB_LED_RedPin 11
#define RGB_LED_GreenPin 10
#define RGB_LED_BluePin 9

/* Controls the brightness of the RGB LED */
int intensity=255;


/* Define the maximum cycles/time allowed for each LED to capture light */
long max_darkness=80000;


void setup(){
  /* Setup the RED LED Sensor */
  pinMode(Red_LED_Sensor_POS,OUTPUT);
  digitalWrite(Red_LED_Sensor_POS,LOW);
  
  /* Setup the YELLOW LED Sensor */
  pinMode(Yellow_LED_Sensor_POS,OUTPUT);
  digitalWrite(Yellow_LED_Sensor_POS,LOW);
  
  /* No need to setup the RGB LED Pins */
    
  /* Turn on Serial Protocol */
  Serial.begin(9600);
}

void loop()
{      
  byte byteRead;

   /*  check if data has been sent from the computer: */
  if (Serial.available()) {

    /* read the most recent byte (which will be from 0 to 255): */
    byteRead = Serial.read();
    
    if(byteRead==0){

      /* Turn off if the byte Read was 0 */
      set_RGB_LED(0,0,0,false);

    }else{

      /* set the brightness of the LED and then take readings: */
      set_RGB_LED(0,0,0,false);
      photoR_Read();
      set_RGB_LED(0,0,0,true);
      set_RGB_LED(intensity,0,0,true);
      set_RGB_LED(0,intensity,0,true);
      set_RGB_LED(0,0,intensity,true);
    }
  }
}

void photoR_Read(){
  int ambiLight = analogRead(PhotoR_Pin); 
  ambiLight = map(ambiLight, 0, 900, 0, 50); 
  ambiLight = constrain(ambiLight, 0, 50);
  
   /* Print the Ambient light level to the serial port */
  Serial.println(ambiLight);
}

void set_RGB_LED(int redInt, int greenInt, int blueInt, boolean takeReadings ){
  /* set the brightness and colour of the RGB LED: */
    analogWrite(RGB_LED_RedPin, redInt);
    analogWrite(RGB_LED_GreenPin, greenInt);
    analogWrite(RGB_LED_BluePin, blueInt);
  
  /* If takeReadings is true - then take Readings. */
  if(takeReadings){

    /* Read the amount of Yellow light */
    read_LED('Y', Yellow_LED_Sensor_NEG);
  
    /* Read the amount of Red light */
    read_LED('R', Red_LED_Sensor_NEG);
  }
}

void read_LED(char LED_Colour, int LED_Pin){

  /* Charge the LED by applying voltage in the opposite direction */
  pinMode(LED_Pin,OUTPUT);
  digitalWrite(LED_Pin,HIGH);
  
  /* Read the amount of Light coming into the LED sensor */
  long darkness=0;
  int lightLevel=0;
  pinMode(LED_Pin,INPUT);
  digitalWrite(LED_Pin,LOW);
  
  while((digitalRead(LED_Pin)!=0) && darkness < max_darkness){
     darkness++;
  }
  
  lightLevel=((max_darkness-darkness)+1)/80;
  
  /* Print the light level to the serial port */
  Serial.println(lightLevel);
}

code formatter

The Processing Code:

The processing code is very long:
Please visit this link to copy and paste the code into your Processing sketch.
http://www.openprocessing.org/visuals/?visualID=34210

Make sure to select "Source Code" when you get there: (as displayed below)

If you have any problems with accessing the code - please let me know in the comments section of this blog.

This sketch utilises a simple feed forward Neural Network (that I developed from scratch). For more detailed information about this neural network please navigate through my previous blog postings.

Neural Network

So there you go, a simple idea, a simple outcome, and a lot of "stuff" happening in the background.
I am sorry. This project is not basic, but hopefully someone out there will get some use out of it.

Have fun !

ScottC

ScottC 19 Aug 15:11

arduino arduinobasics best arduino blog code color colour led as sensor mega bloks neural network photocell processing project uno

Neural Network (Part 7) : Cut and Paste Code

Ok - so you don't like tutorials, and would rather just cut and paste some code.
This is for you.
http://www.openprocessing.org/visuals/?visualID=33991

Make sure to select "Source code" when you get there, otherwise it will be quite boring.
Here is an animated gif which shows the program in action.

See BELOW for the WHOLE screenshot so that you don't have to speed read.

If you want to know how it works, then you will have to go back and read part 1 to 6.

Neural Network

But as you can see from the example above:
Before the neural network is trained, the outputs are not even close to the expected outputs. After training, the neural network produces the desired results (or very close to it).

Please note, this neural network also allows more than one output neuron, so you are not limited to single yes no decisions. You can use this neural network to make classifications. You will soon see this with my LED colour sensor.

Feel free to use this Neural Network in your own projects, but please let me know if you do, just for curiosity sake.

Update: See below for the Processing Sketch (much easier than going to the open processing site). It is a bit long - but saves you from having to navigate to another site.

Processing sketch

/*Neural Network created by ScottC on 15th Aug 2011
 
Please visit my blog for a detailed explanation of my Neural Network
http://arduinobasics.blogspot.com/p/arduinoprojects.html
 
*/
   
   
 
void setup(){
  ArrayList myTrainingInputs = new ArrayList();
  ArrayList myTrainingOutputs = new ArrayList();
   
  float[] myInputsA={0,0};
  float[] myInputsB={0,1};
  float[] myInputsC={1,0};
  float[] myInputsD={1,1};
  float[] myOutputsA={1};
  float[] myOutputsB={0};
   
   
  println("TRAINING DATA");
  println("--------------------------------------------");
  myTrainingInputs.add(myInputsA);
  myTrainingOutputs.add(myOutputsA);
  println("INPUTS= " + myInputsA[0] + ", " + myInputsA[1] + "; Expected output = " + myOutputsA[0]);
  myTrainingInputs.add(myInputsB);
  myTrainingOutputs.add(myOutputsB);
  println("INPUTS= " + myInputsB[0] + ", " + myInputsB[1] + "; Expected output = " + myOutputsB[0]);
  myTrainingInputs.add(myInputsC);
  myTrainingOutputs.add(myOutputsB);
  println("INPUTS= " + myInputsC[0] + ", " + myInputsC[1] + "; Expected output = " + myOutputsB[0]);
  myTrainingInputs.add(myInputsD);
  myTrainingOutputs.add(myOutputsA);
  println("INPUTS= " + myInputsD[0] + ", " + myInputsD[1] + "; Expected output = " + myOutputsA[0]);
  println("--------------------------------------------");
  
  NeuralNetwork NN = new NeuralNetwork();
  NN.addLayer(2,2);
  NN.addLayer(2,1);
  
  println("Before Training");
  float[] myInputDataA1={0,0};
  NN.processInputsToOutputs(myInputDataA1);
  float[] myOutputDataA1={};
  myOutputDataA1=NN.getOutputs();
  println("Feed Forward:  INPUT = 0,0; OUTPUT=" + myOutputDataA1[0]);
   
  float[] myInputDataB1={0,1};
  NN.processInputsToOutputs(myInputDataB1);
  float[] myOutputDataB1={};
  myOutputDataB1=NN.getOutputs();
  println("Feed Forward:  INPUT = 0,1; OUTPUT=" + myOutputDataB1[0]);
   
  float[] myInputDataC1={1,0};
  NN.processInputsToOutputs(myInputDataC1);
  float[] myOutputDataC1={};
  myOutputDataC1=NN.getOutputs();
  println("Feed Forward:  INPUT = 1,0; OUTPUT=" + myOutputDataC1[0]);
   
  float[] myInputDataD1={1,1};
  NN.processInputsToOutputs(myInputDataD1);
  float[] myOutputDataD1={};
  myOutputDataD1=NN.getOutputs();
  println("Feed Forward:  INPUT = 1,1; OUTPUT=" + myOutputDataD1[0]);
 
  println("");
  println("--------------------------------------------");
   
  println("Begin Training");
  NN.autoTrainNetwork(myTrainingInputs,myTrainingOutputs,0.0001,500000);
  println("");
  println("End Training");
  println("");
  println("--------------------------------------------");
  println("Test the neural network");
  float[] myInputDataA2={0,0};
  NN.processInputsToOutputs(myInputDataA2);
  float[] myOutputDataA2={};
  myOutputDataA2=NN.getOutputs();
  println("Feed Forward:  INPUT = 0,0; OUTPUT=" + myOutputDataA2[0]);
   
  float[] myInputDataB2={0,1};
  NN.processInputsToOutputs(myInputDataB2);
  float[] myOutputDataB2={};
  myOutputDataB2=NN.getOutputs();
  println("Feed Forward:  INPUT = 0,1; OUTPUT=" + myOutputDataB2[0]);
   
  float[] myInputDataC2={1,0};
  NN.processInputsToOutputs(myInputDataC2);
  float[] myOutputDataC2={};
  myOutputDataC2=NN.getOutputs();
  println("Feed Forward:  INPUT = 1,0; OUTPUT=" + myOutputDataC2[0]);
   
  float[] myInputDataD2={1,1};
  NN.processInputsToOutputs(myInputDataD2);
  float[] myOutputDataD2={};
  myOutputDataD2=NN.getOutputs();
  println("Feed Forward:  INPUT = 1,1; OUTPUT=" + myOutputDataD2[0]);
  
   
}
 
 
/* ---------------------------------------------------------------------
A connection determines how much of a signal is passed through to the neuron.
--------------------------------------------------------------------  */
 
class Connection{
  float connEntry;
  float weight;
  float connExit;
   
  //This is the default constructor for an Connection
  Connection(){
    randomiseWeight();
  }
   
  //A custom weight for this Connection constructor
  Connection(float tempWeight){
    setWeight(tempWeight);
  }
   
  //Function to set the weight of this connection
  void setWeight(float tempWeight){
    weight=tempWeight;
  }
   
  //Function to randomise the weight of this connection
  void randomiseWeight(){
    setWeight(random(2)-1);
  }
   
  //Function to calculate and store the output of this Connection
  float calcConnExit(float tempInput){
    connEntry = tempInput;
    connExit = connEntry * weight;
    return connExit;
  }
}
 
 
/* -----------------------------------------------------------------
   A neuron does all the processing and calculation to convert an input into an output
--------------------------------------------------------------------- */
 
class Neuron{
  Connection[] connections={};
  float bias;
  float neuronInputValue;
  float neuronOutputValue;
  float deltaError;
   
  //The default constructor for a Neuron
  Neuron(){
  }
   
  /*The typical constructor of a Neuron - with random Bias and Connection weights */
  Neuron(int numOfConnections){
    randomiseBias();
    for(int i=0; i<numOfConnections; i++){
      Connection conn = new Connection();
      addConnection(conn);
    }
  }
   
  //Function to add a Connection to this neuron
  void addConnection(Connection conn){
      connections = (Connection[]) append(connections, conn);
  }
   
  /* Function to return the number of connections associated with this neuron.*/
  int getConnectionCount(){
      return connections.length;
  }
   
  //Function to set the bias of this Neron
  void setBias(float tempBias){
    bias = tempBias;
  }
   
  //Function to randomise the bias of this Neuron
  void randomiseBias(){
    setBias(random(1));
  }
   
  /*Function to convert the inputValue to an outputValue
  Make sure that the number of connEntryValues matches the number of connections */
   
  float getNeuronOutput(float[] connEntryValues){
    if(connEntryValues.length!=getConnectionCount()){
      println("Neuron Error: getNeuronOutput() : Wrong number of connEntryValues");
      exit();
    }
     
    neuronInputValue=0;
     
    /* First SUM all of the weighted connection values (connExit) attached to this neuron. This becomes the neuronInputValue. */
    for(int i=0; i<getConnectionCount(); i++){
      neuronInputValue+=connections[i].calcConnExit(connEntryValues[i]);
    }
     
    //Add the bias to the Neuron's inputValue
    neuronInputValue+=bias;
     
    /* Send the inputValue through the activation function to produce the Neuron's outputValue */
    neuronOutputValue=Activation(neuronInputValue);
     
    //Return the outputValue
    return neuronOutputValue;
  }
   
  //Activation function
  float Activation(float x){
    float activatedValue = 1 / (1 + exp(-1 * x));
    return activatedValue;
  }
   
}
 
class Layer{
  Neuron[] neurons = {};
  float[] layerINPUTs={};
  float[] actualOUTPUTs={};
  float[] expectedOUTPUTs={};
  float layerError;
  float learningRate;
   
   
  /* This is the default constructor for the Layer */
  Layer(int numberConnections, int numberNeurons){
    /* Add all the neurons and actualOUTPUTs to the layer */
    for(int i=0; i<numberNeurons; i++){
      Neuron tempNeuron = new Neuron(numberConnections);
      addNeuron(tempNeuron);
      addActualOUTPUT();
    }
  }
     
   
  /* Function to add an input or output Neuron to this Layer */
  void addNeuron(Neuron xNeuron){
        neurons = (Neuron[]) append(neurons, xNeuron);
  }
   
   
  /* Function to get the number of neurons in this layer */
  int getNeuronCount(){
    return neurons.length;
  }
   
   
  /* Function to increment the size of the actualOUTPUTs array by one. */
  void addActualOUTPUT(){
      actualOUTPUTs = (float[]) expand(actualOUTPUTs,(actualOUTPUTs.length+1));
  }
   
   
  /* Function to set the ENTIRE expectedOUTPUTs array in one go. */
  void setExpectedOUTPUTs(float[] tempExpectedOUTPUTs){
    expectedOUTPUTs=tempExpectedOUTPUTs;
  }
   
   
  /* Function to clear ALL values from the expectedOUTPUTs array */
  void clearExpectedOUTPUT(){
       expectedOUTPUTs = (float[]) expand(expectedOUTPUTs, 0);
  }
   
   
  /* Function to set the learning rate of the layer */
  void setLearningRate(float tempLearningRate){
    learningRate=tempLearningRate;
  }
   
   
  /* Function to set the inputs of this layer */
  void setInputs(float[] tempInputs){
    layerINPUTs=tempInputs;
  }
   
   
   
  /* Function to convert ALL the Neuron input values into Neuron output values in this layer, through a special activation function. */
  void processInputsToOutputs(){
     
    /* neuronCount is used a couple of times in this function. */
    int neuronCount = getNeuronCount();
     
    /* Check to make sure that there are neurons in this layer to process the inputs */
    if(neuronCount>0) {
      /* Check to make sure that the number of inputs matches the number of Neuron Connections. */
      if(layerINPUTs.length!=neurons[0].getConnectionCount()){
        println("Error in Layer: processInputsToOutputs: The number of inputs do NOT match the number of Neuron connections in this layer");
        exit();
      } else {
        /* The number of inputs are fine : continue
           Calculate the actualOUTPUT of each neuron in this layer,
           based on their layerINPUTs (which were previously calculated).
           Add the value to the layer's actualOUTPUTs array. */
        for(int i=0; i<neuronCount;i++){
          actualOUTPUTs[i]=neurons[i].getNeuronOutput(layerINPUTs);
        }
      }
    }else{
      println("Error in Layer: processInputsToOutputs: There are no Neurons in this layer");
      exit();
    }
  }
   
   
  /* Function to get the error of this layer */
  float getLayerError(){
    return layerError;
  }
   
   
  /* Function to set the error of this layer */
  void setLayerError(float tempLayerError){
    layerError=tempLayerError;
  }
   
   
  /* Function to increase the layerError by a certain amount */
  void increaseLayerErrorBy(float tempLayerError){
    layerError+=tempLayerError;
  }
   
   
  /* Function to calculate and set the deltaError of each neuron in the layer */
  void setDeltaError(float[] expectedOutputData){
    setExpectedOUTPUTs(expectedOutputData);
    int neuronCount = getNeuronCount();
    /* Reset the layer error to 0 before cycling through each neuron */
    setLayerError(0);
     for(int i=0; i<neuronCount;i++){
       neurons[i].deltaError = actualOUTPUTs[i]*(1-actualOUTPUTs[i])*(expectedOUTPUTs[i]-actualOUTPUTs[i]);
        
       /* Increase the layer Error by the absolute difference between the calculated value (actualOUTPUT) and the expected value (expectedOUTPUT). */
       increaseLayerErrorBy(abs(expectedOUTPUTs[i]-actualOUTPUTs[i]));
     }
  }
   
   
  /* Function to train the layer : which uses a training set to adjust the connection weights and biases of the neurons in this layer */
  void trainLayer(float tempLearningRate){
    setLearningRate(tempLearningRate);
     
    int neuronCount = getNeuronCount();
     
    for(int i=0; i<neuronCount;i++){
      /* update the bias for neuron[i] */
      neurons[i].bias += (learningRate * 1 * neurons[i].deltaError);
       
      /* update the weight of each connection for this neuron[i] */
      for(int j=0; j<neurons[i].getConnectionCount(); j++){
          neurons[i].connections[j].weight += (learningRate * neurons[i].connections[j].connEntry * neurons[i].deltaError);
      }  
    }
  }
}
 
/* -------------------------------------------------------------
   The Neural Network class is a container to hold and manage all the layers
   ---------------------------------------------------------------- */
 
class NeuralNetwork{
  Layer[] layers = {};
  float[] arrayOfInputs={};
  float[] arrayOfOutputs={};
  float learningRate;
  float networkError;
  float trainingError;
  int retrainChances=0;
   
  NeuralNetwork(){
    /* the default learning rate of a neural network is set to 0.1, which can changed by the setLearningRate(lR) function. */
    learningRate=0.1;
  }
   
   
   
  /* Function to add a Layer to the Neural Network */
  void addLayer(int numConnections, int numNeurons){
    layers = (Layer[]) append(layers, new Layer(numConnections,numNeurons));
  }
 
 
 
  /* Function to return the number of layers in the neural network */
  int getLayerCount(){
      return layers.length;
  }
   
   
   
  /* Function to set the learningRate of the Neural Network */
  void setLearningRate(float tempLearningRate){
    learningRate=tempLearningRate;
  }
   
   
   
  /* Function to set the inputs of the neural network */
  void setInputs(float[] tempInputs){
    arrayOfInputs=tempInputs;
  }
   
   
   
  /* Function to set the inputs of a specified layer */
  void setLayerInputs(float[] tempInputs, int layerIndex){
    if(layerIndex>getLayerCount()-1){
      println("NN Error: setLayerInputs: layerIndex=" + layerIndex + " exceeded limits= " + (getLayerCount()-1));
    } else {
      layers[layerIndex].setInputs(tempInputs);
    }
  }
   
   
   
  /* Function to set the outputs of the neural network */
  void setOutputs(float[] tempOutputs){
    arrayOfOutputs=tempOutputs;
  }
   
   
   
  /* Function to return the outputs of the Neural Network */
  float[] getOutputs(){
    return arrayOfOutputs;
  }
   
   
   
  /* Function to process the Neural Network's input values and convert them to an output pattern using ALL layers in the network */
  void processInputsToOutputs(float[] tempInputs){
    setInputs(tempInputs);
     
    /* Check to make sure that the number of NeuralNetwork inputs matches the Neuron Connection Count in the first layer. */
    if(getLayerCount()>0){
      if(arrayOfInputs.length!=layers[0].neurons[0].getConnectionCount()){
        println("NN Error: processInputsToOutputs: The number of inputs do NOT match the NN");
        exit();
      } else {
        /* The number of inputs are fine : continue */
        for(int i=0; i<getLayerCount(); i++){
           
          /*Set the INPUTs for each layer: The first layer gets it's input data from the NN, whereas the 2nd and subsequent layers get their input data from the previous layer's actual output. */
          if(i==0){
            setLayerInputs(arrayOfInputs,i);
          } else {
            setLayerInputs(layers[i-1].actualOUTPUTs, i);
          }
           
          /* Now that the layer has had it's input values set, it can now process this data, and convert them into an output using the layer's neurons. The outputs will be used as inputs in the next layer (if available). */
          layers[i].processInputsToOutputs();
        }
        /* Once all the data has filtered through to the end of network, we can grab the actualOUTPUTs of the LAST layer
           These values become or will be set to the NN output values (arrayOfOutputs), through the setOutputs function call. */
        setOutputs(layers[getLayerCount()-1].actualOUTPUTs);
      }
    }else{
      println("Error: There are no layers in this Neural Network");
      exit();
    }
  }
   
   
   
   
  /* Function to train the entire network using an array. */
  void trainNetwork(float[] inputData, float[] expectedOutputData){
    /* Populate the ENTIRE network by processing the inputData. */
    processInputsToOutputs(inputData);
     
    /* train each layer - from back to front (back propagation) */
    for(int i=getLayerCount()-1; i>-1; i--){
      if(i==getLayerCount()-1){
        layers[i].setDeltaError(expectedOutputData);
        layers[i].trainLayer(learningRate);
        networkError=layers[i].getLayerError();
      } else {
        /* Calculate the expected value for each neuron in this layer (eg. HIDDEN LAYER) */
        for(int j=0; j<layers[i].getNeuronCount(); j++){
          /* Reset the delta error of this neuron to zero. */
          layers[i].neurons[j].deltaError=0;
          /* The delta error of a hidden layer neuron is equal to the SUM of [the PRODUCT of the connection.weight and error of the neurons in the next layer(eg OUTPUT Layer)]. */
          /* Connection#1 of each neuron in the output layer connect with Neuron#1 in the hidden layer */
          for(int k=0; k<layers[i+1].getNeuronCount(); k++){
            layers[i].neurons[j].deltaError += (layers[i+1].neurons[k].connections[j].weight * layers[i+1].neurons[k].deltaError);
          }
          /* Now that we have the sum of Errors x weights attached to this neuron. We must multiply it by the derivative of the activation function. */
          layers[i].neurons[j].deltaError *= (layers[i].neurons[j].neuronOutputValue * (1-layers[i].neurons[j].neuronOutputValue));
        }
        /* Now that you have all the necessary fields populated, you can now Train this hidden layer and then clear the Expected outputs, ready for the next round. */
        layers[i].trainLayer(learningRate);
        layers[i].clearExpectedOUTPUT();
      }
    }
  }
   
   
   
   
   
  /* Function to train the entire network, using an array of input and expected data within an ArrayList */
  void trainingCycle(ArrayList trainingInputData, ArrayList trainingExpectedData, Boolean trainRandomly){
      int dataIndex;
       
      /* re-initialise the training Error with every cycle */
      trainingError=0;
       
      /* Cycle through the training data either randomly or sequentially */
      for(int i=0; i<trainingInputData.size(); i++){
        if(trainRandomly){
          dataIndex=(int) (random(trainingInputData.size()));
        } else {
          dataIndex=i;
        }
  
        trainNetwork((float[]) trainingInputData.get(dataIndex),(float[]) trainingExpectedData.get(dataIndex));
         
        /* Use the networkError variable which is calculated at the end of each individual training session to calculate the entire trainingError. */
        trainingError+=abs(networkError);
      }
  }
   
   
   
   
   
  /* Function to train the network until the Error is below a specific threshold */
  void autoTrainNetwork(ArrayList trainingInputData, ArrayList trainingExpectedData, float trainingErrorTarget, int cycleLimit){
    trainingError=9999;
    int trainingCounter=0;
     
     
    /* cycle through the training data until the trainingError gets below trainingErrorTarget (eg. 0.0005) or the training cycles have exceeded the cycleLimit
 
variable (eg. 10000). */
    while(trainingError>trainingErrorTarget && trainingCounter<cycleLimit){
       
      /* re-initialise the training Error with every cycle */
      trainingError=0;
       
      /* Cycle through the training data randomly */
      trainingCycle(trainingInputData, trainingExpectedData, true);
       
      /* increment the training counter to prevent endless loop */
      trainingCounter++;
    }
     
    /* Due to the random nature in which this neural network is trained. There may be occasions when the training error may drop below the threshold
       To check if this is the case, we will go through one more cycle (but sequentially this time), and check the trainingError for that cycle
       If the training error is still below the trainingErrorTarget, then we will end the training session.
       If the training error is above the trainingErrorTarget, we will continue to train. It will do this check a  Maximum of 9 times. */
    if(trainingCounter<cycleLimit){
       trainingCycle(trainingInputData, trainingExpectedData, false);
       trainingCounter++;
       
       if(trainingError>trainingErrorTarget){
         if (retrainChances<10){
           retrainChances++;
           autoTrainNetwork(trainingInputData, trainingExpectedData,trainingErrorTarget, cycleLimit);
         }
       }
        
    } else {
      println("CycleLimit has been reached. Has been retrained " + retrainChances + " times.  Error is = " + trainingError);
    }  
  }
}

The above code was formatted using hilite.me

ScottC 15 Aug 14:06

arduinobasics back propagation best arduino blog code example neural network processing processing.org project tutorial

< Later Posts 41—49 from 49

ArduinoMania

Updates

Search

Add blog

Tags

Posts with «processing» label

Glitch synthesizer

Mouse Controlling Arduino LEDs

Components Required for this project:

Arduino Sketch

Arduino Code

Processing Code

Does Arduino dream of a playing tree?

Roster

Primary image

What does it do?

Cost to build

Embedded video

Finished project

Number

Time to build

Type

URL to more information

Weight

MAKEmatics – Mathematics for Makers

Reading from a Text File and Sending to Arduino

Components Required

Arduino Layout

The Text File

Processing Code

Arduino Code

Connecting it all together

An alternative Processing Sketch

Chess sequencer

Poor Man's Colour Detector (Part 2) - The project

arduino code Arduino: Colour Detector

Neural Network (Part 7) : Cut and Paste Code

Processing sketch