So, in the spirit of teaching I decided to write a post on the Arduino Pro Mini and the Parallax Ultrasonic sensor. I went the extra mile and added audio feedback via a 8-ohm mini speaker, visual feedback via a BlinkM Led and included an external power source.

You will need the following components to build an ultra-sonic beeping thingamajiggy:

Lets start by addressing the Arduino Pro Mini.
The Arduino Pro Mini is intended for advanced users who require flexibility, low-cost, and small size. Please note that there are two versions of the board, one that operates at 5V (like most Arduino boards), and one that operates at 3.3V. Both boards come with the minimum of components (no on-board USB or pin headers) to keep the cost down. The Arduino Site has an overview on the Arduino Pro Mini, I suggest you at least review the page to get familiar with the Inputs and Outputs of the board. The Arduino Pro Mini is programmed using a FTDI Cable or in my case a FTDI Basic Breakout board.

Since we are using a breadboard to prototype the ultra-sonic beeping thingamajiggy, I suggest you solder the break away headers to the Arduino, in fact, I always suggest creating connectors for sensors rather than just soldering them to the Arduino. A quick soldering tip is to stick the headers into a breadboard and place the Arduino board on top. Then solder all headers. Make sure you also solder headers to Analog 4 and 5, which you will find on the board near the ATmega328 chip. You should now have something that resembles this:

Now, lets hook up some power. This part is very important, you don’t want to fry your board so pay close attention. Locate The power pins on your Arduino Pro Mini:

* RAW. For supplying a raw (unregulated) voltage to the board.
* VCC. The regulated 3.3 or 5 volt supply.
* GND. Ground pins.

The VCC pin on the Arduino Pro Mini is bypassing the regulator and you should NOT CONNECT ANY POWER SUPPLY ABOVE 5 VOLTS to this pin. In most cases you will use the RAW pin to connect a power supply (up to 12V) in need of regulation.

The enclosed 4 “AA” battery holder from Radio Shack, has a voltage of 6 volts, therefore I have no other choice but to connect it to the unregulated RAW pin.

ONLY USE THE VCC PIN IF YOU ARE SURE YOU HAVE A REGULATED 5 VOLT POWER SOURCE.

I took the battery enclosure and added a 2 pin screw terminal to the end of the wires to make the connection to the breadboard easier.

Make sure the battery enclosure switch is on the OFF state and then connect the power supply to the breadboard.
Add the ground (black) wire from the battery enclosure to the blue rail of the breadboard.
Add the power (red) wire from the battery enclosure to the red rail of the breadboard.

Grab some jumper wires and connect a wire from the blue rail of the breadboard to the GND pin on the Arduino (green wire in image below). Connect a wire from the red rail of the breadboard to the RAW pin on the Arduino (blue wire in image below).

Next lets connect the ultrasonic sensor.

You will notice the sensor only has 3 pins, the 5V pin, the GND pin and the SIG (signal) pin. You can easily place the senor onto your breadboard and wire it up. I had some extra Male/Female jumper wires, so I utilized them to free up some space on the breadboard.
Connect the GND pin of the sensor to the blue rail on the breadboard (black wire in image below).
Connect the 5V pin of the sensor to the red rail on the breadboard (red wire in image below).
Connect the SIG pin of the sensor to pin 7 of the Arduino (blue wire in image below).

If connecting the sensor is all you cared about, you could stop here. All you have left to do is connect the FTDI Cable or FTDI Basic breakout board to the Arduino Pro Mini. Open up the Arduino IDE:
Select Tools -> Serial Port
and select the correct usb port (mac) /dev/tty.usbserial-XXXXXXXX.
Select Tools->Board
and select Lilypad Arduino w/Atmega328 (I’m running Arduino IDE 018 and for some unknown reason this selection is the only one which enables an upload without errors).
Select File-> Examples->Sensors->Ping
and upload the sketch.
Your done! If you open up the Serial Monitor, it will display the distance being detected from the sensor in inches and cm’s.

Moving forward, lets add the BlinkM RGB Led. If you read my previous post on the BlinkM you will be familiar with the process. If not, grab your BlinkM and lets get familar with it.

The BlinkM is a networkable and programmable full-color RGB LED. It has a small AVR micro-controller on board to allow a user to digitally control the LED over a simple I2C interface. The Arduino will communicate with the BlinkM, using the Wire library so we don’t have to worry about the details of I2C. If you haven’t already checked out the BlinkM support page please do so, it has a bunch of perks you should be aware of. Take a look at the print on the board itself. You will notice PWR and I2C printed directly on the board, take mental note because that’s what we will be interfacing with shortly. BlinkM needs two wires for power and two for data. We will be connecting to the Arduino analog pins 4 & 5 which double as the I2C data signal (“SDA”) and clock signal (“SCL”), respectively.

Place the BlinkM onto your breadboard and connect a wire (red wire in image below) from the red rail on the breadboard to the positive (+) symbol printed on the BlinkM. Connect a wire (brown wire in image below) from the blue rail on the breadboard to the ground (-) symbol printed on the BlinkM.

Proceed by connecting a wire (blue wire in image below) to analog 4 of the Arduino Pro Mini. Connect the other end of the wire to the ‘d’ (I2C SDA) symbol printed on the BlinkM.
Connect another wire (green wire in image below) to analog 5 of the Arduino Pro Mini. Connect the other end of the wire to the ‘c’ (I2C SCL) symbol printed on the BlinkM.

Next, lets hook up the 8 ohm mini speaker for audio feedback.
Simply connect the black wire from the speaker to the blue rail of the breadboard. Connect the red wire from the speaker to digital pin 7 on the Arduino Pro Mini.

And there you have it. We have completed our simple circuit for an ultra-sonic beeping thingamajiggy.
Lets move onto the code.

The first thing you are going to want to do is connect the FTDI Cable or FTDI Basic breakout board to the Arduino Pro Mini. There are pros and cons to the FTDI Cable vs the FTDI Basic breakout board . The breakout board has TX and RX LEDs that allow you to actually see serial traffic on the LEDs to verify if the board is working, but the board requires a miniB cable. The FTDI Cable is well protected against the elements, but is large and cannot be embedded into a project as easily. The FTDI Basic breakout board uses DTR to cause a hardware reset where the FTDI Cable uses the RTS signal.

I prefer to use the FTDI Basic breakout board to connect to the Arduino pro Mini. Anyhow, connect either the FTDI Cable or Basic breakout board to the Arduino and open up the Arduino IDE.
Select Tools -> Serial Port
and select the correct usb port (mac) /dev/tty.usbserial-XXXXXXXX.
Select Tools->Board
and select Lilypad Arduino w/Atmega328.
Select File->New
and copy the following code to the sketch:
*NOTE you can download my source below*

/*
Code under (cc) by Manuel Gonzalez, www.codingcolor.com
http://creativecommons.org/license/cc-gpl
Digital pin 7 Parallax Ultrasonic Range Finder
Digital Pin 4 8-ohm mini speaker
Analog pins 4 (SDA),5(SCL) I2C communication with BlinkM
*/
#include <Wire.h>
#include "BlinkM_funcs.h"



const int pingPin = 7;
const int speakerPin = 4;
const int blinkm_addr = 9;//address to blinkM
byte r,g,b;

void setup() {
 // Serial.begin(9600);
  pinMode(speakerPin,OUTPUT);
 
  BlinkM_beginWithPower();
  BlinkM_stopScript(blinkm_addr);//stop the BlinkM
  BlinkM_setFadeSpeed(blinkm_addr, 255);//set up fade param
  BlinkM_fadeToRGB(0,0x00,0x00,0x00);//fade all to black
}

void loop()
{

  long duration, inches;
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance
  inches = microsecondsToInches(duration);
  /*
  Serial.print(inches);
  Serial.print("in, ");
  Serial.println();
  */
  displayColor(inches);
  delay(100);
}

void displayColor(long inches)
{
  if(inches < 12)
  {
     r = 255;
     g = 0;
     b = 0;
    beep(speakerPin, 2500, 500);
  }else {
     r = 9;
     g = 249;
     b = 17;
  }
 
   BlinkM_fadeToRGB(0, r,  g,  b);
}
void beep(int targetPin, long frequency, long length) {
 
  long delayValue = 1000000/frequency/2; // calculate the delay value between transitions
  long numCycles = frequency * length/ 1000; // calculate the number of cycles for proper timing
 for (long i=0; i < numCycles; i++){
    digitalWrite(targetPin,HIGH);
    delayMicroseconds(delayValue);
    digitalWrite(targetPin,LOW);
    delayMicroseconds(delayValue);
  }
}

long microsecondsToInches(long microseconds)
{
  // According to Parallax's datasheet for the PING))), there are
  // 73.746 microseconds per inch (i.e. sound travels at 1130 feet per
  // second).  This gives the distance travelled by the ping, outbound
  // and return, so we divide by 2 to get the distance of the obstacle.
  // See: http://www.parallax.com/dl/docs/prod/acc/28015-PING-v1.3.pdf
  return microseconds / 74 / 2;
}

Take note of the include.
#include "BlinkM_funcs.h"
It’s a BlinkM Arduino library written by Tod E. Kurt. You will need the BlinkM_funcs.h library which is also availbe in my download.

Upload the code to your Arduino Pro Mini disconnect the FTDI Cable or Basic breakout board and turn the power on.

If all went well, you should have an ultra-sonic beeping thingamajiggy.

Click here to view the embedded video.

Enjoy!
Download Source:
Ultra-Sonic beeping thingamajiggy (5)

The ‘Swarm Light‘ is a light installation with a real ‚collective consciousness. It’s a contemporary example of how the arbitrary boundaries of fine and decorative art, design and utility are no longer of immediate aesthetic relevance. Sounds or movement captured as light and shadow create a type of participatory and performative synthesis that culminates in an instinctual perception of the space, rather than a cerebral judgment.

Check out more projects by rAndom International.

var _username:String;
var _password:String;
var _apiUrl:String;

private var logIn():void
{
var path:String = _apiUrl +"&"+_username + "&" + _password;
var request:URLRequest = new URLRequest(_path);
_loader = new URLLoader();
_loader.load(request);
}

Then proceeded to ask, “What’s wrong with this code?” Well, I looked over the method and pointed out that the code wasn’t complete, but the engineer replied, just assume that the syntax is correct and all variables needed are present. The only thing that came to mind, when dealing with API’s, is that there is usually some type of security measure, usually in the form of a user token or session variable. I felt like I was being tricked, the only other answer I could provide was to encrypt the string to secure the data passing over the network, and in short, that’s the answer they were looking for. They should have asked, “How would you protect the users login data when submitting it to an API?” Thanks for the trick question, guys, but as you know almost every API has a different strategy in handling security.

Creating secure SWF applications is not an easy task. The best way to protect your sensitive data is to leverage the HTTPS protocol for sending encrypted data instead of performing the encryption within ActionScript code. Unfortunately, we cant always hide behind HTTPS and It is not advisable to permit HTTP content to access HTTPS content.

There are several strategies to encrypt data in SWF web applications. The most popular are hashing algorithms and symmetric and asymmetric ciphers. Hashing algorithms is a method for performing non-reversible encryption that transforms the original text into a unique string, or hash. The hash is non-reversible, meaning it can not be decrypted and is usually stored on disk. This method is usually used as password authentication and storage. Symmetric and asymmetric ciphers are useful when you want to create a reversible encryption of data, however, the secret and private keys for these tools are usually stored in the SWF, which can be exposed using a decompiler. You can try to hide the key from a decompiler by using a flash obfuscation software, tho I have never implemented this method, I can not advise doing so.

This post is not about Flash security, because I’m not a security expert, it’s about base64 encoding.

Exactly what is Base64 encoding? Base64 encoding is a scheme that encodes arbitrary binary data as a string composed from a set of 64 characters. The exact character set can be any 64 distinct ASCII characters, but by far the most common set is “A” through “Z,” “a” through “z,” “0″ through “9,” “+,” and “/.” Base64 encoding is used by many applications to “obscure” data when it travels across the network. Base64 encoding does not implement a cryptographic algorithm to protect sensitive information, yet is often used in many networks and end-user applications to my amazement.

I recently developed a sweepstakes micro-site for a client, which prerequisite was to obscure users personal data over the network. Since base encoding visually hides otherwise easily recognized information, It satisfied the prerequisite, with an understanding that it was not a secure method and the client signed off on it.

I scripted up a quick little demo app which shows you how to use Base64 encoding.

The demo gathers the users input, encodes it in a JSON object, encodes the object using base64, and passes it to the server where a php script receives it, decodes the base64 JSON object and then passes it back to the flash app. As you noticed, I may have added a complexity by using JSON. JSON is your friend, the JSON format is often used for serializing and transmitting structured data over a network connection. It is primarily used to transmit data between a server and web application, serving as an alternative to XML. I have become accustomed to using it over the years, so I just left it in my code, just for clarification you can use a simple string.

Lets take a look at the demo. I created this app in CS4 using the UI flash components. As most flash apps start out, I created a Main document class:

Main.as
/****************************
* Manuel Gonzalez           *
* design@stheory.com        *
* www.stheory.com           *
* www.codingcolor.com       *
*****************************/
package {

    import flash.display.Sprite;
    import fl.controls.Button;
    import fl.controls.TextArea;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.text.TextField;
    import flash.text.TextFieldAutoSize;
    import flash.text.TextFormat;
    import com.stheory.view.LoginForm;
    import com.stheory.business.LoginProxy;

    public class Main extends Sprite {



        private var _logInView:LoginForm;
        private var _logInProxy:LoginProxy;
        private var _traceField:TextArea;
        private var _okButton:Button;


        public function Main() {

            showLoginView();
        }
        /*
         Method: showLoginView
         Parameters:
         Returns:  
         */
        private function showLoginView():void {
            _logInView = new LoginForm();
            _logInView.x=20;
            _logInView.y=50;
            _logInView.addEventListener(Event.COMPLETE,submitData);
            addChild(_logInView);
        }
        /*
         Method: removeLoginView
         Parameters:
         Returns:  
         */
        private function removeLoginView():void {
            _logInView.removeEventListener(Event.COMPLETE,submitData);
            _logInView.dispose();
            removeChild(_logInView);
        }
        /*
         Method: submitData
         Parameters:
         event:Event
         Returns:  
         */
        private function submitData(event:Event):void {
            removeLoginView();
            createTraceField();
            var loginObj:Object={username:event.target.username,password:event.target.password,remember:event.target.rememberMe};
            _logInProxy=LoginProxy.getInstance();
            _logInProxy.addEventListener(Event.COMPLETE,logInComplete,false,0,true);
            _logInProxy.addEventListener(Event.CANCEL,logInError,false,0,true);
            _logInProxy.submitFormData(loginObj);
        }
        /*
         Method: logInComplete
         Parameters:
         event:Event
         Returns:  
         */
        private function logInComplete(event:Event):void {
            var results=event.target.scriptResult;
            _traceField.text=results;
            _logInProxy.removeEventListener(Event.COMPLETE,logInComplete);
            _logInProxy.removeEventListener(Event.CANCEL,logInError);
        }
        private function logInError(event:Event):void
        {
            var results= event.target.errorEvent;
            _traceField.text=results;
            _logInProxy.removeEventListener(Event.COMPLETE,logInComplete);
            _logInProxy.removeEventListener(Event.CANCEL,logInError);
        }
        /*
         Method: createTraceField
         Parameters:
         Returns:  
         */
        private function createTraceField():void {

            _traceField = new TextArea();
            _traceField.setSize(350, 100);
            _traceField.move(25, 25);
            addChild(_traceField);
            _okButton = new Button();
            _okButton.width=75;
            _okButton.move(300,135);
            _okButton.label="OK";
            _okButton.setStyle("textFormat", new TextFormat("Arial"));
            _okButton.toggle=true;
            _okButton.addEventListener(MouseEvent.CLICK, okClick,false,0,true);
            addChild(_okButton);
        }
        /*
         Method: okClick
         Parameters:
         event:MouseEvent
         Returns:  
         */
        private function okClick(event:MouseEvent):void {
            removeTraceField();
            showLoginView();
        }
        /*
         Method: removeTraceField
         Parameters:
         Returns:  
         */
        private function removeTraceField():void {
            _okButton.removeEventListener(MouseEvent.CLICK,okClick);
            removeChild(_traceField);
            removeChild(_okButton);
        }






    }
}

The Main.as class simply instantiates a logIn view, logIn proxy and creates a trace/log view to print out the interactions with the server. I’m going to skip the logIn view, just assume that all it does is set up the login UI and dispatches an event when the Submit button is pressed. The class that we will focus on is the LogInProxy.as. I utilize Steve Websters base64 encoder/decoder class and the AS3CoreLib developed by Mike Chambers, Daniel Dura and Christian Cantrell for the JSON encoding.
LogInProxy.as
/****************************
* Manuel Gonzalez           *
* design@stheory.com        *
* www.stheory.com           *
* www.codingcolor.com       *
*****************************/
package com.stheory.business{
    import flash.display.Sprite;
    import flash.events.EventDispatcher;
    import flash.events.IEventDispatcher;
    import flash.events.Event;
    import flash.events.IOErrorEvent;
    import flash.events.SecurityErrorEvent;
    import flash.net.URLLoader;
    import flash.net.URLLoaderDataFormat;
    import flash.net.URLRequest;
    import flash.net.URLRequestMethod;
    import flash.net.URLVariables;
    import com.adobe.serialization.json.JSON;
    import com.utils.Base64;



    public class LoginProxy extends Sprite {

        private static  var _instance:LoginProxy;
        private var _loader:URLLoader;
        private var _formObj:Object;
        private var _encryption:String;
        private var _path:String = "http://www.stheory.com/stheory/downloads/scripts/securityTest.php";
        private var _errorEvent:*;
        private var _testScriptResult:String;
       

        public function LoginProxy(singletonEnforcer:SingletonEnforcer) {
            super();
        }
        /*
         Method: getInstance
         Returns: AppServices
         */
        public static  function getInstance():LoginProxy {
            if (_instance == null) {
                _instance=new LoginProxy(new SingletonEnforcer  );
               
            }
            return _instance;
        }
        ////////////// Getters ///////////////////////
        public function get scriptResult():String
        {
            return "base64 to server :\n" +_encryption + "\n\nResults from Server :\n" + _testScriptResult;
        }
        public function get errorEvent():*
        {
            return _errorEvent;
        }
        //////////////////////////////////////////
        /*
         Method: submitFormData
         Parameters:
         inObj:Object
         Returns:  
         */
        public function submitFormData(inObj:Object):void
        {
            _formObj = inObj;
            encodeAndEncryptData();
            sendData();
        }
        /*
         Method: encodeAndEncryptData
         Parameters:
         Returns:  
         */
        private function encodeAndEncryptData():void {
           
           
            var jStr:String = JSON.encode(_formObj);
            _encryption  = Base64.encode(jStr);

        }
        /*
         Method: sendData
         Parameters:
         Returns:  
         */
        private function sendData():void {

            var dataVars:URLVariables = new URLVariables();
            dataVars.data =  _encryption;

            var request:URLRequest = new URLRequest(_path);

            request.method = URLRequestMethod.POST;
            request.data = dataVars;

            _loader = new URLLoader();
            configureListeners(_loader);

            try {
                _loader.load(request);

            } catch (error:Error) {
                trace("Unable to load URL");
                _errorEvent = error;
                dispatchEvent(new Event(Event.CANCEL))
            }

        }
        /*
         Method: configureListeners
         Parameters:
         dispatcher:IEventDispatcher
         Returns:  
         */
        private function configureListeners(dispatcher:IEventDispatcher):void {
            dispatcher.addEventListener(Event.COMPLETE, completeHandler);
            dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
        }
        /*
         Method: removeListeners
         Parameters:
         dispatcher:IEventDispatcher
         Returns:  
         */
        private function removeListeners(dispatcher:IEventDispatcher):void {
            dispatcher.addEventListener(Event.COMPLETE, completeHandler);
            dispatcher.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
            dispatcher.addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);
        }
        /*
         Method: completeHandler
         Parameters:
         event:Event
         Returns:  
         */
        private function completeHandler(event:Event):void {
            var result = _loader.data;
            try {
                    _testScriptResult = result.toString()
                    dispatchEvent(new Event(Event.COMPLETE))
                }
             catch (error:Error) {
                _errorEvent = error;
                dispatchEvent(new Event(Event.CANCEL))
            }
            removeListeners(_loader);
            _loader=null;
        }
        /*
         Method: securityErrorHandler
         Parameters:
         event:SecurityErrorEvent
         Returns:  
         */
        private function securityErrorHandler(event:SecurityErrorEvent):void {
            //trace("securityErrorHandler: " + event + " \n\n");
            _errorEvent = event;
            dispatchEvent(new Event(Event.CANCEL))
        }
        /*
         Method: ioErrorHandler
         Parameters:
         event:IOErrorEvent
         Returns:  
         */
        private function ioErrorHandler(event:IOErrorEvent):void {
            //trace("ioErrorHandler: " + event + " \n\n");
            _errorEvent = event;
            dispatchEvent(new Event(Event.CANCEL))
        }

    }
}

internal class SingletonEnforcer {
}

I created the LogInProxy class as a Singleton pattern, because I only want to make one object which will handle the data transaction between the client side and the server. LoginProxy is responsible for the base64 encoding, it also submits the data and reports the results. Review the encodeAndEncryptData() method:

 private function encodeAndEncryptData():void  {
           var jStr:String = JSON.encode(_formObj);
            _encryption  = Base64.encode(jStr);
   }

this is where all the magic happens. You can revise this method to meet your needs, for example remove the option of using JSON and just use a simple string. The SendData method, does what it implies, pretty straight forward. Now, lets take a look at the Php.

The Php script is really simple and was created just for this demo:
<?php
$data= $_POST['data'];
$decoded = base64_decode ($data);
echo "$decoded";
?>

It receives the base64 encoded data, decodes it and prints it back to Flash.

Now, for a sanity check, I would recommend using a packet sniffer that captures network traffic, like Service Capture. Here’s a screenshot of the demo app in action:

As you can see, we successfully passed an encoded string to the Php script, which in return passed back a JSON object.
Its really that easy! I could have gone the extra mile and re-encoded a response in base64 and had Flash decode it, but I’ll leave that up to you.
Enjoy!

Download Source:
Base64 encoding example (0)

www.sun-boxes.com