Az Arduino lapkák többféle kiszerelésben és formában léteznek és közös bennük, hogy nyílt forráskóddal és hatalmas amatőr fejlesztői bázissal rendelkeznek. Én az egyik legismertebbet fogom használni az Arduino Duemilanove-ot.

Ennek a lapnak 14 digitális és 6 analóg csatlakozási pontja van, amik programozással állíthatóak. Nem kell megijedni mivel igen egyszerű c/c++ alapú pár utasításos nyelve van. A lapka USB-vel csatlakozik a számítógépünkhöz, azon keresztül programozható, és a program a lecsatlakozás után is rajta marad. A csatlakozási pontok (PIN-ek) állapotát programkóddal változtathatjuk, a legegyszerűbb esetben szabályozhatjuk, hogy folyjon-e rajtuk keresztül áram vagy ne.
Nézzünk egy egyszerű kódot amivel egy LED-et tudunk villogtatni.

int ledPin =  13;    // LED 13 as PIN-re kötve

// a setup csak induláskor fut le
void setup()   {
	// A PIN-t kimeneti módra állítjuk:
	pinMode(ledPin, OUTPUT);
}

// a loop addig fut amíg az Arduino áram alatt van
void loop()
{
	digitalWrite(ledPin, HIGH);	// adjunk áramot a LED-nek
	delay(1000);			// várjunk egy másodpercet
	digitalWrite(ledPin, LOW);	// kapcsoljuk le
	delay(1000);			// várjunk egy másodpercet
}

Részletek: Blink Tutorial

Vágjunk akkor bele a LED-ek villogtatásába. Flash és Arduino közötti kapcsolat egy proxy szerver beiktatásával fog történni. Arduino képes soros portra írni vagy onnan olvasni, ezeket az adatokat egy proxy szerver adja tovább amire Flash socket-en keresztül csatlakozik, és így tud kommunikálni az Arduino lappal. Én a TinkerProxy-t javaslom erre a célra, mivel ez speciálisan Flash-hez lett írva.

Az alábbi lépések szükségesek:

1. 8 LED-et kötünk 8 kimenetre.
2. Írunk egy programot ami a Flash-ből érkező szám alapján bekapcsolja a megfelelő LED-eket.
3. Feltöltjük a programot a lapra.
4. Írunk egy Flash zene lejátszót ami a SoundMixer.computeSpectrum segítségével figyeli a zene intenzitását
5. Konfiguráljuk a TinkerProxy-t a megfelelő port-ra, majd indítsuk el.
6. Csatlakozunk Flash-el socket-en keresztül

1. Lépés a LED-ek bekötése

A LED-ek mindegyike külön PIN-re van kötve amik egy ellenállás segítségével GND-re, vagyis a földre vannak csatlakoztatva. Tulajdonképpen csak annyiban különbözik a villogtatós bekötéstől, hogy több LED-et használunk, és beiktatnunk még egy ellenállást is. Ezt én így valósítottam meg:

2. Lépés az Arduino program

/**
* author: Reider
*/
#define LED_COUNT 8   // 8 ledünk van
int ledPins[] = { 2, 3, 4, 5, 6 , 7, 8, 9 }; // A led PIN-ek

void setup()
{
  //konfiguráljuk a kommunikáció sebességét
  Serial.begin(9600);

  //a LED-ek csatlakozásait kimenetként álíltjuk be
  for(int i=0; i<LED_COUNT; i++){
    pinMode( ledPins[i] , OUTPUT );
  }

  //villogtatunk egyet hogy jelezzük a program elindult
  blinkLeds();
}

void loop()
{
  //figyeljük hogy jött e üzenet flash-től ami egy szám lesz
   if (Serial.available() > 0) {
     //amennyiben van üzenet beolvassuk hány ledet kell bekapcsolni
     int value = Serial.read();
     //beállítjuk a LED állapotokat
     setLedStates( value );
   }
}

//a setLedStates megadott számú ledet kapcsol be
void setLedStates(int num)
{
  for(int i=0; i<LED_COUNT; i++){
    if( i+1<=num ){
      //amelyik led a kapott számban benne van felkapcsoljuk
      digitalWrite( ledPins[i], HIGH );
    }else{
      //a többit le
       digitalWrite( ledPins[i], LOW );
    }
  }
}

//a blinkLeds felvillantja a ledeket
void blinkLeds()
{
  setLedStates( LED_COUNT );
  delay(300);
  setLedStates( 0 );
}

3. Lépés a program feltöltése

A feltöltéshez az Arduino weblapjáról ingyenesen letölthető programot használhatjuk ami Mac, Windows vagy akár Linux-on is használható.

A feltöltés előtt ki kel választanunk a lapunkat és a portot amire az Arduino csatlakoztatva van, ez Windows-on többnyire COM3.

4. Lépés a Flash lejátszó

const SERVER_ADDRESS:String = "localhost"  //a cím ahova csatlakozunk
const PORT:int = 5333						//a szerver port száma
const SAMPLE_NUM:int = 5	//minták száma amit a program a hang lejátszásánál átlagol

var socket:Socket
var sound:Sound
var chanel:SoundChannel
var samplerTimer:Timer

init()
function init():void
{
	// ez a timer fogja a megadott időközönként meghívni a mintavételező függvényt
	samplerTimer = new Timer(20)
	samplerTimer.addEventListener(TimerEvent.TIMER, onSamplerTimer)

	//a gombokhoz adjuk a figyelőket
	connectBtn.addEventListener(MouseEvent.CLICK, onConnectClick)
	playBtn.addEventListener(MouseEvent.CLICK, onPlayClick)

	//létrehozzuk a socket-et
	setupSocket()
}

function setupSocket():void
{
	socket = new Socket()

	socket.addEventListener(Event.CONNECT,
		function():void{
			monitor.outputField.appendText( "connected succesfuly\n" )
		}
	);
	socket.addEventListener(Event.CLOSE,
		function():void{
			monitor.outputField.appendText( "connection closed\n" )
		}
	);
}

/* ez a függvény írja a socketre a megkapott intenzitás adatokat amik majd
a proxy segítségével átadódnak az Arduino-nak */
function writeMonitorValue(value:int):void
{
	trace( value )
	if(!socket.connected) return

	/*simán byte-ként írjuk ki a számokat, mivel nincs szükségünk nagy értékekre
	és így kezelni is egyszerű őket */
	socket.writeByte( value );
	socket.flush()
}

// a drawBytes csak grafikon szerűen kirajzolja az intenzitásokat
function drawBytes(bytes:ByteArray):void
{
	const PLOT_HEIGHT:int = 200;
	const PLOT_WIDTH:int = 500;
	const CHANNEL_LENGTH:int = 256;
	const RATIO:Number = PLOT_WIDTH/CHANNEL_LENGTH

	var g:Graphics = monitor.canvas.graphics;

	g.clear();

	g.lineStyle( 0, 0x59B9E1 );
	g.beginFill( 0x59B9E1 );
	g.moveTo( 0, PLOT_HEIGHT );

	var n:Number = 0;
	bytes.position = 0
	for (var i:int = 0; i < CHANNEL_LENGTH; i++) {
		n = Math.min(bytes.readFloat() * PLOT_HEIGHT, PLOT_HEIGHT);
		g.lineTo(i * RATIO, PLOT_HEIGHT - n);
	}

	g.lineTo( PLOT_WIDTH, PLOT_HEIGHT );
	g.endFill();
}

// a drawMonitorValue kirajzolja az Arduino-nak küldendő értékeket
function drawMonitorValue(value:int):void
{
	const DRAW_HEIGHT:int = 200;
	const DRAW_WIDTH:int = 80;
	const RATIO:Number = DRAW_HEIGHT/8

	var g:Graphics = levelDisplay.canvas.graphics

	g.clear()
	g.beginFill( 0x59B9E1 )
	g.drawRect(0,  DRAW_HEIGHT - (value*RATIO), DRAW_WIDTH, value*RATIO)
	g.endFill()
}

function onConnectClick(event:Event):void
{
	// csatlakozzunk a szerverhez
	socket.connect(SERVER_ADDRESS, PORT);
}

function onPlayClick(event:Event):void
{
	// játsszuk le a zenét
	if(chanel) chanel.stop()
	sound = new Sound()
	sound.load( new URLRequest(musicField.text) )
	chanel = sound.play()
	samplerTimer.start()
	monitor.outputField.appendText( "playing "+musicField.text+"\n" )
}

function onSamplerTimer(event:Event):void
{
	// ByteArray-ként megkapjuk az intenzitás értékeket 0-1 -es skálán
	var bytes:ByteArray = new ByteArray()
	SoundMixer.computeSpectrum( bytes , true)

	// a slider megadja hogy honnan vegyünk mintát
	bytes.position = sampleSlider.value * 4
	var sampleSum:Number = 0
	for(var i:int=0; i<SAMPLE_NUM; i++){

		sampleSum += bytes.readFloat()
	}

	/* mivel csak 0-1 ig kapunk értékeket és nekünk 8 LED-ünk van, ezért
	szorzunk 8-al hogy a megfelelő adatokat kapjuk */
	var monitorValue:int = Math.round( Math.min( (sampleSum/SAMPLE_NUM) * 8  , 8  ) )
	// átküldjük socket-en az intenzitást
	writeMonitorValue( monitorValue )
	// kirajzoljuk az egész spektrumot
	drawBytes( bytes )
	// kirajzoljuk az átküldött értéket
	drawMonitorValue( monitorValue )
}

A program működés közben:

5. Lépés TinkerProxy konfiguráció

A TinkerProxy egy egyszerű szerver program ami Arduino usb-n keresztül érkező adatait a rá csatlakozó klienseknek adja tovább. Én a leírásomhoz a TinkerProxy 2.0 -t használtam. Mint már említettem a program nagyon egyszerű, csak a futtatható fájlok és két konfigurációs fájlból áll, az egyik Windows a másik Mac környezethez. Nézzük milyen konfigurációs beállítások szükségesek Windows alatt.

# Amennyiben az XMLSocket osztályt használjuk mivel ott az új üzenetet a 0 érték jelzi
# a program képes automatikusan konvertálni nekünk az alapból \n ként érkező sorvége karaktereket
newlines_to_nils=false

# A használt COM port Windows alatt ez többnyire a 3-as
comm_ports=3

# Alap beállítások itt csak arra kell figyelnünk hogy a comm_baud
# a programunkban Serial.begin részben megadott értékkel egyezzen
comm_baud=9600

# COM3-hoz tartozó port amihez majd Flash-el csatlakozni fogunk
net_port3=5333

A program futtatásához elég csak duplán kattintani az exe-re és már várja is a csatlakozó klienseket.

6. Lépés működtetés

Amennyiben az Arduino lapunk csatlakoztatva van a gépünkhöz és elindítottuk a proxit, Flash csatlakoztatása és a zene indítása után hasonlót kell látnunk:

Beszerzés

Az Arduino Duemilanove-ot Magyarországon a Kitchen Budapest árulja körülbelül 7500FT-ért de külföldről is beszerezhető:
Cool Components Anglia
SparkFun USA cheap zovirax tablets
És még további rengeteg helyen.

További Arduino és Flash tutorial

Video Tutorial:
Physical Computing with Arduino: Getting Started
Physical Computing with Arduino: Connecting to Adobe Flash
Physical Computing with Arduino: Photocells
Physical Computing with Arduino: Passive Infrared
Physical Computing with Arduino: Temperature and Humidity
Physical Computing with Arduino: Ultrasonic Range Finder
Physical Computing with Arduino: RGB LED
Physical Computing with Arduino: Accelerometers

Szöveges Tutorial:
Getting Started with Flash and Arduino
Flash and Arduino Communication
Flash / Arduino Tips, Tricks and Gotchas
Sending Multibyte Numbers from ActionScript to Arduino
Accelerate : Flash / Arduino Based Speed Detector
Wireless Light Sensor (Part 1 of 3)
Wireless Light Sensor (Part 2 of 3)
Wireless Light Sensor (Part 3 of 3)

Források: ArduinoFlashSoundMonitor.zip