For receiving of data on the Arduino I’ll choose the Messenger library. It has some nice simple functions and gives you the opportunity to check if a string is fully received (a ‘carriage return’ is send by Flash at the end of a serial message in the SerialPort class) by Arduino. Of course you can write your own serial protocol. You can find some thoughts about it at the Todbot blog : Arduino serial protocol design patterns.

You can send data to the serial port with the Serial.print() and Serial.println() commands.

Included is the SerialPort class for Flash that makes it easy to send and receive serial data from/to the Arduino. I’ve modified the original (from tinker.it) so it supports start and stop characters. As a stop character ‘carriage return’ is used (‘\r’, or char(13)) that is send when you do Serial.println(); from Arduino.

I advise using a start character (not used in the example below) as well, because sometimes (especially when sending on a high datarate) characters at the beginning if the string can get lost.

The download contains SerialPort.as and example_messenger.fla (CS3).

Download : flash-arduino-as3-messenger

Step by step guide for Messenger library communication

• Download the Messenger library and install it in your Arduino/libraries/ folder ( you can find it by default in your documents folder ). Restart Arduino if it was running.
• Go to File > Examples > Messenger > basic_communication.
• Change

  1	Serial.begin(115200);

  to

  1	Serial.begin(57600);

  if you use my Serialproxy setup instructions from my tutorial ( see Arduino – Flash communication AS3 – AS3Glue bundle ).

• Change

  1	unsigned long interval = 20;

  to

  1	unsigned long interval = 40;

  for more stability

• Upload the Sketch to the Arduino.
• Configure Serialproxy for your Arduino board and run it.
• Open example_messenger.fla and run it.
• If everything went fine you’ll see the led on pin 13 blinking and 6 balls, controlled by the analog inputs, moving on the screen.

Example_messenger code

1
2
3
4
5
6
7
8
9
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
var receivedValues:Array = new Array();



// Arduino connection



/* SerialPort(localhost, netport, start character, stop character)

   for more stability use a startcharacter so you can check if a message is complete

   default stop character is carriage return '\r' 

   A carriage return is send by the Arduino command Serial.println();

*/



var arduino:SerialPort = new SerialPort("127.0.0.1", 5331);

arduino.addEventListener(DataEvent.DATA, onArduinoData );

arduino.connect();



// Setup a timer to send data to the Arduino

// The timer object calls the timerEvent function 20 times a second (every 50ms)

var timer = new Timer(500);

timer.addEventListener("timer", timerEvent);

timer.start();



// toggle variable that is switched by the timer from true to false and back

var toggle:Boolean= true;



function timerEvent(event:Event):void 

{   

    // change toggle boolean to the opposite

    toggle = !toggle;

    

    if(toggle == true)

    { // make ledPin 13 HIGH - onboard led on 

      //arduino.send("on"); // For Messenger checkString example

      arduino.send("13 1"); // For Messenger basic_communication example

    }

    else

    { // make ledPin 13 LOW - onboard led off

      //arduino.send("off"); // For Messenger checkString example

      arduino.send("13 0");  // For Messenger basic_communication example

    }

    

    /*

    When you have a certain amount of values it will be smart to keep them

    in an array (so you only modify the array indexes that change.

    

    You can convert an array to a character seperated string (space character for 

    Messenger library) with the join function.

    

    Example :

    var sendValues:Array = new Array(2,4,8,16,32,64,128);

    arduino.send(sendValues.join(" "));

    

    */

}



// add some balls to the stage to display incoming analog values

var ballArray = new Array();



for(var i:int = 0;i<6;i++)

{   

    var ball:MovieClip = new Ball();

    ballArray[i] = ball;

    ball.width = ball.height = 50;

    ball.y = 10;

    ball.x = 10+(i*60);

    addChild(ball);

}



// Called when data is received from the Arduino

function onArduinoData( event:DataEvent ):void

{   

    trace("received string : ", event.data );



    /* The values from Arduino Messenger are space seperated values. We will 

       store each value in the receivedValues array.    

    */

    receivedValues = event.data.split(" "); 

    

    // change the y position of the balls on stage 

    for(var i:int = 0;i<6;i++)

    { var mc = ballArray[i];

      mc.y = receivedValues[i] * 350/1023;  

    }   

}

Related posts:

1. Arduino Flash communication AS2
2. Arduino Flash communication AS3 – As3Glue bundle

Project: unity-arduino with serial connection

This project uses Unity (which uses C# and JavaScript scripting), the Arduino and/or SerialProxy to connect the Arduino to Unity. Thus allowing custom hardware to be linked to Unity (in real-time).

The link is established in Windows using the Mono implementation of System.IO.Ports.

For Mac/OSX users, I’ve made an implementation that uses SerialProxy because direct serial connection doesn’t work on the mac. The problem is, though, that the SerialProxy implementation doesn’t seem to work either.

Links:

• Unity-Arduino serial-connection on Google code
• Unity : Game Development Tool
• Arduino

Related posts:

1. Arduino Flash communication AS3 – As3Glue bundle
2. Arduino Flash communication AS3 – Messenger

I’ve created a Flash monitor application with As3Glue to make it easier to start with Flash Arduino communication.

Glue is an ActionScript 3.0 library that enables communication between Flash and Arduino boards with Firmata. Since Flash cannot interface the serial port directly we’ll use Serialproxy in between. Serialproxy converts incoming serial data the XMLsocket data.

The monitor is useful to check if all the connections are working good. You can monitor directly all the sensors and actuators connected to your Arduino board.

The example code file is a start point to program your own things controlled by Arduino.

Included files :

• AS3Glue files ( .net.eriksjodin.arduino )
• Tinkerproxy osx ( renamed to serproxy )
• Serialproxy windows ( renamed to serproxy )
• as3glue_standalone_monitor.fla
• as3glue_program-example.fla

The Firmata library is included with Arduino itself. Make sure you use Arduino 018, because the Firmata library included in version 017 is not stable.

Update (12-05-10, v1.3): I’ve updated the code for the support of two servo motors (pin 9 and pin 10).

Download the zip-file : arduino_as3glue_bundle_v1.4

Related posts:

1. Arduino Flash communication AS2
2. Arduino Flash communication AS3 – Messenger

Download the “Arduino programming notebook” by Brian Evans at lulu.com : Arduino programming notebook

Download de “Arduino programmeer manual” Nederlandse vertaling door A. Companje van arduino.nu : Arduino programmeer manual

The Arduino website has good information to help you get started. See Getting started with Arduino.

Next to that watch use the code examples in the Arduino IDE and use the Arduino reference. The Arduino playground has more advanced information and the Arduino playground at arduino.cc.

General programming tips :

1. Learn by doing
2. Make simple things
3. Combine simple things to make complex things
4. Print code for a better overview

Related posts:

1. Arduino Programming – Map and smooth values
2. Arduino Programming – Interval

Level : beginner with Arduino. ( Basic knowledge of programming principles like if/else and variables ).

Download the Arduino ( .pde ) files : arduino_HSB_to_RGB.zip

HSB_to_RGB.pde :

1
2
3
4
5
6
7
8
9
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/*  

  Control a RGB led with Hue, Saturation and Brightness (HSB / HSV )



  Hue is change by an analog input. 

  Brightness is changed by a fading function. 

  Saturation stays constant at 255



  getRGB() function based on <http://www.codeproject.com/miscctrl/CPicker.asp>  

  dim_curve idea by Jims



  created 05-01-2010 by kasperkamperman.com

*/



/* 

  dim_curve 'lookup table' to compensate for the nonlinearity of human vision.

  Used in the getRGB function on saturation and brightness to make 'dimming' look more natural. 

  Exponential function used to create values below : 

  x from 0 - 255 : y = round(pow( 2.0, x+64/40.0) - 1)   

*/



const byte dim_curve[] = {

    0,   1,   1,   2,   2,   2,   2,   2,   2,   3,   3,   3,   3,   3,   3,   3,

    3,   3,   3,   3,   3,   3,   3,   4,   4,   4,   4,   4,   4,   4,   4,   4,

    4,   4,   4,   5,   5,   5,   5,   5,   5,   5,   5,   5,   5,   6,   6,   6,

    6,   6,   6,   6,   6,   7,   7,   7,   7,   7,   7,   7,   8,   8,   8,   8,

    8,   8,   9,   9,   9,   9,   9,   9,   10,  10,  10,  10,  10,  11,  11,  11,

    11,  11,  12,  12,  12,  12,  12,  13,  13,  13,  13,  14,  14,  14,  14,  15,

    15,  15,  16,  16,  16,  16,  17,  17,  17,  18,  18,  18,  19,  19,  19,  20,

    20,  20,  21,  21,  22,  22,  22,  23,  23,  24,  24,  25,  25,  25,  26,  26,

    27,  27,  28,  28,  29,  29,  30,  30,  31,  32,  32,  33,  33,  34,  35,  35,

    36,  36,  37,  38,  38,  39,  40,  40,  41,  42,  43,  43,  44,  45,  46,  47,

    48,  48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,

    63,  64,  65,  66,  68,  69,  70,  71,  73,  74,  75,  76,  78,  79,  81,  82,

    83,  85,  86,  88,  90,  91,  93,  94,  96,  98,  99,  101, 103, 105, 107, 109,

    110, 112, 114, 116, 118, 121, 123, 125, 127, 129, 132, 134, 136, 139, 141, 144,

    146, 149, 151, 154, 157, 159, 162, 165, 168, 171, 174, 177, 180, 183, 186, 190,

    193, 196, 200, 203, 207, 211, 214, 218, 222, 226, 230, 234, 238, 242, 248, 255,

};



const int sensorPin = 0;  // pin the potmeter is attached too

const int ledPinR   = 9;  // pwm pin with red led

const int ledPinG   = 10; // pwm pin with green led

const int ledPinB   = 11; // pwm pin with blue led



int sensorVal = 0; // store the value coming from the sensor

int fadeVal   = 0; // value that changes between 0-255

int fadeSpeed = 4; // 'speed' of fading



// getRGB function stores RGB values in this array

// use these values for the red, blue, green led. 

int rgb_colors[3]; 



int hue;

int saturation;

int brightness;



void setup() { 

  pinMode(9, OUTPUT);

  pinMode(10, OUTPUT);

  pinMode(11, OUTPUT);

  Serial.begin(57600);

}



void loop()  { 



  sensorVal = analogRead(sensorPin);



  // fade from 0 - 255 and back with a certain speed   

  fadeVal = fadeVal + fadeSpeed;         // change fadeVal by speed

  fadeVal = constrain(fadeVal, 0, 255);  // keep fadeVal between 0 and 255



  if(fadeVal==255 || fadeVal==0)         // change from up>down or down-up (negative/positive)

  { fadeSpeed = -fadeSpeed;  

  }  



  // set HSB values

  hue        = map(sensorVal,0, 1023,0, 359);     // hue is a number between 0 and 360

  saturation = 255;                               // saturation is a number between 0 - 255

  brightness = fadeVal;                           // value is a number between 0 - 255



  getRGB(hue,saturation,brightness,rgb_colors);   // converts HSB to RGB



  analogWrite(ledPinR, rgb_colors[0]);            // red value in index 0 of rgb_colors array

  analogWrite(ledPinG, rgb_colors[1]);            // green value in index 1 of rgb_colors array

  analogWrite(ledPinB, rgb_colors[2]);            // blue value in index 2 of rgb_colors array



  delay(20); // delay to slow down fading

}



void getRGB(int hue, int sat, int val, int colors[3]) { 

  /* convert hue, saturation and brightness ( HSB/HSV ) to RGB

     The dim_curve is used only on brightness/value and on saturation (inverted).

     This looks the most natural.      

  */



  val = dim_curve[val];

  sat = 255-dim_curve[255-sat];



  int r;

  int g;

  int b;

  int base;



  if (sat == 0) { // Acromatic color (gray). Hue doesn't mind.

    colors[0]=val;

    colors[1]=val;

    colors[2]=val;  

  } else  { 



    base = ((255 - sat) * val)>>8;



    switch(hue/60) {

    case 0:

        r = val;

        g = (((val-base)*hue)/60)+base;

        b = base;

    break;



    case 1:

        r = (((val-base)*(60-(hue%60)))/60)+base;

        g = val;

        b = base;

    break;



    case 2:

        r = base;

        g = val;

        b = (((val-base)*(hue%60))/60)+base;

    break;



    case 3:

        r = base;

        g = (((val-base)*(60-(hue%60)))/60)+base;

        b = val;

    break;



    case 4:

        r = (((val-base)*(hue%60))/60)+base;

        g = base;

        b = val;

    break;



    case 5:

        r = val;

        g = base;

        b = (((val-base)*(60-(hue%60)))/60)+base;

    break;

    }



    colors[0]=r;

    colors[1]=g;

    colors[2]=b; 

  }   

}

Related posts:

1. Arduino Programming – State change
2. Arduino Programming – Interval

Level : beginner with Arduino. ( Basic knowledge of programming principles like if/else and variables ).

Download the Arduino ( .pde ) files : arduino_tutorial_map-and-smooth.zip

Map.pde :

1
2
3
4
5
6
7
8
9
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
/* 

  Mapping example



  Re-map a number from one range to another. 



  created 01-12-2009 by kasperkamperman.com

*/



const int sensorPin = 0;    // the pin that the potmeter is attached to

int sensorValue     = 0;    // store the value coming from the sensor

int mappedValue;            // store the new value



void setup() {

  // opens serial port, sets data rate to 57600 bits per second

  Serial.begin(57600);

}



void loop() {

  // read the value from the sensor

  // the range from an analog input is 0 - 1023

  sensorValue = analogRead(sensorPin);  



  // print the value

  Serial.print("sensorValue                                 : ");

  Serial.println(sensorValue);   



  // map(value, fromLow, fromHigh, toLow, toHigh)

  mappedValue = map(sensorValue, 0, 1023, 0, 255);



  Serial.print("map to 0 - 255                              : ");

  Serial.println(mappedValue);  



  // invert a value is possible too 

  mappedValue = map(sensorValue, 0, 1023, 255, 0);



  Serial.print("map to 255 - 0                              : ");

  Serial.println(mappedValue);  



  // or negative values

  mappedValue = map(sensorValue, 0, 1023, -127, 128);



  Serial.print("map to -127 - 128                           : ");

  Serial.println(mappedValue);  



  // only watch a certain part of the sensor values

  // for example when using a sensor that doesn't cover the whole

  // range

  mappedValue = map(sensorValue, 512, 712, 0, 100);

  Serial.print("map 512 - 712 to 0 - 100                    : ");

  Serial.println(mappedValue);



  // constraining the sensorValue can be usefull to prevent negative values

  sensorValue = constrain(sensorValue, 512, 712);  

  Serial.print("constrained sensorValue                     : ");

  Serial.println(sensorValue);



  mappedValue = map(sensorValue, 512, 712, 0, 100);

  Serial.print("map 512 - 712 to 0 - 100 ( with constrain ) : ");

  Serial.println(mappedValue); 



  // division between next read

  Serial.println("------------------------------------------------");



  // wait for 1000 milliseconds ( 1 second ) to read every second

  delay(1000);

}

Analog_smooth.pde :

1
2
3
4
5
6
7
8
9
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
/* 

  Smoothing example



  Read the analog input and smooth out the result by averaging

  the result with past values of the input.



  The more samples to longer it takes to reach the final value. 

  4/5 samples give a smooth and reactive enough result. 



  Simpler algorithm than the smoothing included with the Arduino 

  examples.



  based on : Analog Smoothing Algorithm by Tom Igoe 

  <http://www.tigoe.net/pcomp/code/category/arduinowiring/41>



  created 05-01-2010 by kasperkamperman.com

*/



const int sensorPin = 0;    // the pin that the potmeter is attached to



int sensorVal       = 0;    // store the value coming from the sensor

int smoothedVal     = 0;    // smoothed result

int samples         = 4;    // amount of samples



void setup() {

  Serial.begin(57600);

}



void loop() {



  // read the value from the sensor

  // the range from an analog input is 0 - 1023

  sensorVal = analogRead(sensorPin); 



  smoothedVal = smoothedVal + ((sensorVal - smoothedVal)/samples);



  // print the original value and the smoothedValue

  Serial.print(sensorVal); 

  Serial.print(", ");

  Serial.println(smoothedVal); 



  // slow down amount of readings and prints

  delay(100); 



}

Related posts:

1. Arduino Programming – HSB to RGB
2. Arduino Programming – State change

How to write a program that fires actions with different intervals without using the delay() function. Configuration of the serial port and printing values is also explained.

Level : beginner with Arduino. ( Basic knowledge of programming principles like if/else and variables ).

Download the Arduino ( .pde ) files : arduino_tutorial_interval.zip

Interval_basic.pde :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
/*

  Print serial text with an interval.

  Basic example.   

  

  created 01-12-2009 by kasperkamperman.com

*/



unsigned long previousMillis  = 0;

unsigned long currentMillis   = 0;



int interval = 1000;



void setup() {

  // opens serial port, sets data rate to 57600 bits per second

  Serial.begin(57600);   

}



void loop()

{ // save number of milliseconds since the program started

  currentMillis = millis();

  

  // check to see if the interval time is passed. 

  if (currentMillis - previousMillis >= interval == true ) {

    

      Serial.print("this program runs now for : ");

      Serial.print(currentMillis);

      Serial.println(" milliseconds");

      

      // save the time when we displayed the string for the last time

      previousMillis = currentMillis;

  }

}

Interval_for_loop.pde :

1
2
3
4
5
6
7
8
9
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
/*

  Print serial text with different intervals.   

  Check the array with a for-loop.

  

  created 01-12-2009 by kasperkamperman.com

*/



const int amountOfIntervals = 3;



unsigned long previousMillis[amountOfIntervals]  = {0, 0, 0};

unsigned long currentMillis                      = 0;



int intervals[amountOfIntervals]       = {1000, 2500, 5000};



void setup() {

  // opens serial port, sets data rate to 57600 bits per second

  Serial.begin(57600);   

}



void loop()

{ // save number of milliseconds since the program started

  currentMillis = millis();

  

  // check the 3 intervals one by one with a for-loop. 

  for(int i=0; i<amountOfIntervals; i++) {

    

    // check to see if the interval time is passed.  

    if (currentMillis - previousMillis[i] >= intervals[i]) {

      

      if(i==0) Serial.println("-   every 1 second");

      if(i==1) Serial.println(" -  every 2.5 second");

      if(i==2) Serial.println("  - every 5 seconds");

      

      // save the time when we displayed the string for the last time

      previousMillis[i] = currentMillis; 

            

    }

  }

}

Related posts:

1. Arduino Programming – Map and smooth values
2. Arduino Flash communication AS3 – Messenger

How to program a state change functionality. ‘State change detection’ is a method to see when a button is pressed or released. You can use it to fire a different action each press of a button.

For example the “Play/Pause” button on a cd-player behaves like that. The first press is play, the next press is pause, the next play again etc. Depending the state the action is different ( play > pause, pause > play ).

In this tutorial I explain also the basic code structure ( setup, loop ) of Arduino script.

Level : beginner with Arduino. ( Basic knowledge of programming principles like if/else and variables ).

Download the Arduino ( .pde ) files : arduino_tutorial_statechange.zip

OnOff.pde :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*

  LED on when you press a button.

  LED off when you release a button.  

  

  created 01-12-2009 by kasperkamperman.com

*/



const int buttonPin = 2;      // the pin that the pushbutton is attached to

const int ledPin    = 13;     // the pin that the LED is attached to



int buttonState     = 0;      // current state of the button



void setup() {

  pinMode(buttonPin, INPUT);  // initialize the button pin as a input

  pinMode(ledPin, OUTPUT);    // initialize the button pin as a output

}



void loop() {

  // read the pushbutton input pin

  buttonState = digitalRead(buttonPin);



  // turns LED on if the buttonState=HIGH or off if the buttonState=LOW

  digitalWrite(ledPin, buttonState);

}

State_change.pde :

1
2
3
4
5
6
7
8
9
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
/*

  Set a state of a variable when you press a pushbutton ( the 

  button went from off to on ). 

  

  created 01-12-2009 by kasperkamperman.com

  based on example 'State change detection' by Tom Igoe

*/



const int buttonPin  = 2;     // the pin that the pushbutton is attached to

const int ledPin     = 13;    // the pin that the LED is attached to



int buttonState      = 0;     // current state of the button

int lastButtonState  = 0;     // previous state of the button

int ledState         = 0;     // remember current led state



void setup() {

  pinMode(buttonPin, INPUT);  // initialize the button pin as a input

  pinMode(ledPin, OUTPUT);    // initialize the button pin as a output

}



void loop() {

  // read the pushbutton input pin

  buttonState = digitalRead(buttonPin);



  // check if the button is pressed or released

  // by comparing the buttonState to its previous state 

  if (buttonState != lastButtonState) {

    

    // change the state of the led when someone pressed the button

    if (buttonState == 1) { 

      if(ledState==1) ledState=0;

      else            ledState=1;         

    }

    

    // remember the current state of the button

    lastButtonState = buttonState;

  }

  

  // turns LED on if the ledState=1 or off if the ledState=0

  digitalWrite(ledPin, ledState);

  

  // adding a small delay prevents reading the buttonState to fast

  // ( debouncing )

  delay(20);

}

If you like to work with more than two states, do something like below. And use a switch or if statement later to perform some action on a certain stateNum value.

1
2
3
4
if (buttonState == 1) { 

      stateNum++; 

      if(stateNum>2) stateNum=0;      

}

Related posts:

1. Arduino Programming – HSB to RGB
2. Arduino Programming – Map and smooth values

Tutorial that explains how to setup communication between Arduino and Flash with provided example files.

Update : See Arduino Flash communication AS3 – As3Glue bundle for an Actionscript 3 tutorial.

You can read sensors connected to the Arduino in Flash and send output information to actuators connected to the Arduino. Communication between Flash and Arduino is setup with the Serialproxy program that converts serial strings in to XML socket data.

The zip package can be download from : arduino.cc/playground/uploads/Interfacing/flash_arduino_io_2.zip

UPDATE : Serialproxy doesn’t work anymore under Snow Leopard ( osx 10.6 ) without installing Rosetta. However you can also use Tinkerproxy2. That works in the same way as Serialproxy. Just rename your serproxy.cfg to tinkerproxy2.cfg or you can rename the program tinkerproxy2 to serproxy. tinkerproxy-2_0.zip

See the Playground in Arduino for more Flash implementations : arduino.cc/playground/Interfacing/Flash/

Related posts:

1. Arduino Flash communication AS3 – As3Glue bundle
2. Arduino Flash communication AS3 – Messenger