• Home
• Science
• Software
  • Getting Started
  • 123D Design
  • TinkerCad
  • SketchUp
  • Blender
  • Processing
  • OpenSCAD
  • 123D Catch
  • Meshmixer
• Hardware
• Programming
• Assignments
• Readings

Introduction

Setting Up

1. Create an account at electricimp.com
   
   

   ---

2. Install the electric imp mobile app on your phone.
   
   

   ---

3. On the mobile app set up WIFI or WPS:
   

   Configuration with WPS button (WiFi Protected Setup)

   If you have a router which has a WPS button, press the WPS button on the router then press the WPS button in the app to transmit the WPS command to the imp within 2 minutes.
   
   When the imp is performing WPS, the LED will flash green, red, green, off. WPS setup usually takes 10-20 seconds to complete.

   Configuration with WPS PIN (WiFi Protected Setup)

   If your router has WPS but no button, you can use the WPS PIN function to configure WiFi. Often the WPS PIN will be listed on a sticker on the underside of the router.
   
   Enter this PIN into the app.

   Configuration with a network name and password

   For this, you need to know your WiFi network name (sometimes called SSID) and password. If you did not set these yourself, they may be listed on a sticker on the router.
   
   In the app, the WiFi network name your iOS/Android device is connected to is already filled in;
   
   The WiFi password cannot be automatically extracted by the app. You must enter this yourself, but it password can be saved within the electric imp app to make setup of subsequent devices easier.
   
   

   From devwiki.electricimp.com

   
   

   ---

4. Get your phone ready to blink. Don't press the button yet, but make sure your mobile app is open and ready to go.
   

   ---

5. Plug in the April Development board into the computer.
   
   

   ---

6. To blink the imp, you will press the Send BlinkUp button and hold your device as close to the sensor of the imp as possible, shielding the imp from ambient light. Your device will display a series of flashes (this is how the imp gets configured).
   

   ---

7. Insert the Imp into the board.
   
   

   ---

8. While it is blinking, blink it from your mobile app.
   
   

   ---

9. The imp should blink green and then red. If this does not happen, you may have let the imp sit powered up too long before blinking. Doing the blink-up right away seemed to work.
   
   

   ---

10. Back on the website, click on the Code Tab
    
    

    ---

11. Click on the + icon to create new code
    
    

    ---

12. Name your program and click OK
    
    

    ---

13. Paste in the following:

    // Hello World example code
     
    // Register with the server
    imp.configure("First Program", [], []);
     
    // Display our important message
    server.show("Hello, World!");
     
    // End of code.

    
    
    

    ---

14. Click on the Floppy Disk Icon to Save
    
    

    ---

15. Click on the Planner Tab
    
    

    ---

16. Power up (unplug and plug it in) the commissioned imp
    A node can represent a physical impee or a soft node running on the server.
    
    Noodles are arrows that join nodes together, connecting outputs to inputs. Since this is your first experiment you should only see a single impee node, representing your impee.
    
    
    

    ---

17. Click its settings icon. The node settings dialog will open.
    
    

    ---

18. Under firmware, select the code you saved for this example.
    
    

    ---

19. If you see Hello World all went well
    
    If this doesn't happen click edit button on the node, which brings up the code editor and log window, and check for errors. If you made a mistake entering the code it will likely be shown here, in which case correct the mistake and re-save. You may have noticed the Run Code button in the editor - if the code is associated with one or more impees this button will cause your changes to be downloaded to them (and they will restart).

    ---

GPIO

Input

// pin 7 is a digital input (0 or 1) and is pulled up externally
hardware.pin7.configure(DIGITAL_IN_PULLUP, pin7changed);

function pin7changed() {
    // declare a local variable - we can store the value of the pin in here if we need it
    local buttonState = hardware.pin7.read();
 
    // if buttonState is 0, the button is pushed
    if (buttonState == 0) {
        // server.show logs text to the logs, but also displays text right in the node on the planner
        server.show("Button Pressed!");
    } else {
        server.show("Button Released!");
    }
}

server.log("April Pushbutton Started");

imp.configure("April Pushbutton", [], []);

// Create output object
out9 <- OutputPort("Switch", "number");
 
// Store the last state so we know when we've changed; this starts out as -1 until we read the switch
laststate <- -1;
 
// Debounce code: ignore transitions for 50ms after event
ignore <- false;
function debounce() {
    // Take notice of transitions from now onward
    ignore = false;
 
    // Ensure state is in sync
    check_state();
}
 
function check_state() {
    local s = hardware.pin9.read();
 
    // Has the state changed?
    if (s != laststate) {
        // Yes, note the state, send it, and update the planner
        laststate = s;
        out9.set(s);
        server.show(s?"on":"off");
        server.log(s?"on":"off");
    }        
}
 
// This function is called whenever the imp detects a change on pin1
function switched() {
    if (!ignore) {
        check_state();
 
        // Ignore bounces
        ignore = true;
        imp.wakeup(0.05, debounce);
    }
}
 
// Get on the planner
imp.configure("Switch", [], [out1]);
 
// Set up pin1 to be an input with a pull-up. This means it'll float high when the switch is open.
// This also registers the callback handler "switched" which will be automatically called whenever the
// pin changes state.
hardware.pin9.configure(DIGITAL_IN_PULLUP, switched);
 
// Call check_state at startup to ensure things are in sync.
check_state();

1. Sign in to your account
   
   

   ---

2. Click on code.
   
   

   ---

3. Create a new program
   
   

   ---

4. Start with a title comment which will show in the Planner code list.

   // Blink-O-Matic example code
        

   
   
   

   ---

5. Declare a variable to represent the current state of the LED, 0 for off, 1 for on. In Squirrel variables are loosely typed, meaning that you don't have to declare the type of variable the variable is.

   // Variable to represent LED state
   ledState <- 0;
        

   
   
   

   ---

6. Write a function to toggle the LED state. Just before returning the function schedule a timer to run itself again after 100ms. This will result in an LED cycle rate of 5Hz. The method imp.wakeup has centisecond resolution and you can experiment with different blink rates

   // blink function called every 100ms
   function blink(){
       // Change state
       ledState = ledState?0:1;
       server.show(ledState);
       
       // Reflect state to the pin
       hardware.pin9.write(ledState);
    
       // Schedule the next state change
       imp.wakeup(0.1, blink);
   }

   
   
   

   ---

7. Configure the pin. Imp pins can be configured for different functions. For this program configure it as a GPIO (the default), and tell the Imp what kind of GPIO, an open drain output. Activate the internal pull up feature of the pin to prevent risk of the LED illuminating dimly from leakage current.

   // Configure pin 9 as an open drain output with internal pull up
   hardware.pin9.configure(DIGITAL_OUT_OD_PULLUP);
   
   

   
   
   

   ---

8. Register with the server, using a suitable name. Pass empty arrays into the other parameters for the moment.

   // Register with the server
   imp.configure("Blink-O-Matic", [], []);

   
   
   

   ---

9. Call the blink function

   // Start blinking
   blink();
   

   
   
   

   ---

10. Deploy your code onto your impee
    
    

    ---

Adding Remote Control

1. Click edit to edit your blinking code.
   
   

   ---

2. Add a new variable:

   // Variable to represent LED inhibit state
   inhibit <- 0;
   

   
   
   

   ---

3. Modify the blink function so that now the contents of the function look like this:

    if(inhibit){
           // Blinking inhibited, turn off the LED
           hardware.pin9.write(0);
       }else{
           // Change state
           ledState = ledState?0:1;
    		server.show(ledState);
           // Reflect state to the pin
           hardware.pin9.write(ledState);
    
           // Schedule the next state change
           imp.wakeup(0.1, blink);
       }
   

   
   
   

   ---

4. Define a class to represent your input port. You'll derive from the InputPort class and specify a data type of number. Zero will switch off blinking, and non-zero will switch it on.
   
   Set two member variables to give the port a name (which is displayed in the Planner to help with connecting nodes together) and define the data type. Alternatively these parameters can have been passed to the class constructor.
   
   The InputPort class has a method set which is called when data arrives from the Planner. Override this method with your own implementation which will set or clear the inhibit flag depending on the value received. When you clear the flag (enable the LED) you also call blink to re-start the LED blinking.

   // input class for LED control channel
   class input extends InputPort{
     name = "LED control"
     type = "number"
    
     function set(value){
         if(value == 0){
             // 0 = Inhibit LED operation
             inhibit = 1;
         }else{
             // 1 = Enable LED operation
             inhibit = 0;
             blink();
         }
     }
   }
   
   
   

   
   
   

   ---

5. Modify imp.configure. Remember earlier that there were two empty arrays? The first is an array of InputPort instances, and the second an array of OutputPort instances. Use these arrays to create as many communication channels as you require in each direction. In this case you need just the one input.

   // Register with the server
   imp.configure("Blink-O-Matic", [input()], []);
   

   
   
   

   ---

6. Save the code, run it and click on Planner
   
   

   ---

7. If the LED does not stop blinking unplug and replug
   
   

   ---

8. Click Add Node and add a tick tock.
   
   

   ---

9. Connect the nodes

Analog Input

local supplyVoltage = hardware.voltage()

1. Wire up a potentiometer so that the right most lead connects to 3V, the leftmost wire connects to GND and the center lead connects to a ADC pin, lets say 7.
   
   

   ---

2. Create a new program and name it.
   
   

   ---

3. The first line should be a comment with the name of the program
   
   

   ---

4. Next, you'll need to configure the 7 pin as an analog input :

   hardware.pin7.configure(ANALOG_IN);
   

   
   
   

   ---

5. Create a function called checkPot that will do three things:
   1. Read the voltage on the pin and save it to a variable:

          local rawValue = hardware.pin7.read();
          

   2. Format the result (in this case, scale the number so that the output is a float between 0 and 1)

          // check if this value is "different enough" from the last one so you don't send the same value over and over
          if (math.abs(rawValue - lastRawValue) > 150) {
              // divide by 65535.0 to get a value between 0.0 and 1.0
              local potValue = rawValue / 65535.0;
       
              lastRawValue = rawValue;
              server.show(potValue);
          }

   3. Schedule the function to run again

          imp.wakeup(0.01, checkPot);
          

   
   
   

   ---

6. Register with the imp service and call your function for the first time

   imp.configure("Potentiometer", [], []);
   checkPot();
   

   
   
   

   ---

7. Save, run replug in your device. Click on Planner tab
   
   

   ---

8. Click the settings button to change your firmware.
   
   

   ---

PWM

the program

• Configure pin 9 as a PWM output
  
  
• Read in a value - this example will use an Input Port to get a value from the planner.
  
  
• Set the duty cycle of the PWM output based on the value received
  
  

1. Open the Code tab, create a new program, name it and comment out a line that names the program
   
   

   ---

2. To configure pin 9 as a PWM output, there are three arguments that must be dealt with:
   1. Mode: PWM_OUT
   2. Period in seconds (1/frequency)
   3. Duty cycle (a floating point number between 0 and 1, where 1 is 100% duty cycle)
      
      Note that a %100 duty cycle turns the LED completely off; pin 9 will stay high and no current will flow through the LED.

   hardware.pin9.configure(PWM_OUT, 1.0/500.0, 1.0);
   

   
   
   

   ---

3. Take in a value from the planner by creating an Input Port. This is done by extending the InputPort base class. The set method of this new class will receive input sent to an object of this class by default; implement the set method to take in a value and perform an action.

   class ledBrightness extends InputPort{
       name = "LED Brightness"
       type = "number"
    
       function set(value) {
           // write a floating point number between 0.0 and 1.0, where 1.0 = 100% duty cycle
           server.log(value);
           //LED's brightness is inversely related to the duty cycle
           hardware.pin9.write(1.0-value);
       }
    
   }

   
   
   Setting the duty cycle of the PWM signal is extremely straightforward. When a pin is configured as a PWM output, calling write with a floating point number between 0 and 1 sets the duty cycle of the output signal appropriately.
   
   The set method in the InputPort will be called any time new data arrives on the input port, so there is no need to implement a loop or schedule updates within this firmware.
   
   

   ---

4. Outside the new input port class definition, register with the imp service. Make sure the input port is included in the array of input ports (the second argument) in imp.configure.

   imp.configure("Brightness Controller", [ledBrightness], []);

   
   
   

   ---

5. Save it, run it, navigate to Planner
   
   

   ---

6. Under firmware, select the program. After a second or two, you will see the node update and the label will change to “ Brightness Controller”. Note that the LED will be off when initialized and will remain off until a value is sent to the imp.
   
   

   ---

7. Add a Tick Tock node and connect it to your program
   
   

   ---

Servo Motors

1. Create a new program, name it and include a comment that names the program in the first line.
   
   

   ---

2. Configure the pin as a PWM output.
   1. Mode: PWM_OUT
   2. Period in seconds (1/frequency)
   3. Duty cycle (a floating point number between 0 and 1, where 1 is 100% duty cycle)
   With a generic servo, you can expect approximately 179 degrees of range. In this example, the servo expects a pulse every 20 to 30 ms, which means that your PWM period must be in that range (the example code shows a 20 ms period). This servo will be set fully counter-clockwise on a pulse of width 0.8 ms (0.8 / 20 = 4% duty cycle → use pin.write(0.04)), and fully clockwise on a pulse of width 2.6 ms (2.6 / 20 = 13% duty cycle → use pin.write(0.13)). Therefore, it will be necessary to scale the input value appropriately to set the duty cycle between 4% and 13%.
   
   Configure pin 9 as a PWM output. Note that the duty cycle is initialized to 8.5% (1.7 ms) to set the motor position to the center.

   hardware.pin1.configure(PWM_OUT, 0.02, 0.085);
   

   
   
   

   ---

3. Take in a value from the planner by creating an Input Port. Extend the InputPort base class. The set method of this new class will receive input sent to an object of this class by default; implement the set method to take in a value and perform an action.

   class servo extends InputPort{
       name = "servo position"
       type = "number"
    
       function set(value) {
           server.log(value);
    
           // scale the duty cycle we set on the pin so that 0 = fully counter clockwise and 1 = fully clockwise
           hardware.pin1.write(0.04 + (value * 0.09));
       } 
   }

   
   
   

   ---

4. When a pin is configured as a PWM output, calling write with a floating point number between 0 and 1 sets the duty cycle of the output signal appropriately.
   
   The set method in the InputPort will be called any time new data arrives on the input port, so there is no need to implement a loop or schedule updates within this firmware.
   
   

   ---

5. Register with the imp service. Note that the input port is included in the array of input ports (the second argument) in imp.configure.

   imp.configure("Servo Controller", [servo], []);
   

   
   
   

   ---

6. Save, go to planner, set up firmware, connect a Tick Tock Node.
   
   

   ---

7. Use a second imp with a potentiometer to control the servo.
   
   

   ---

Creating Input Ports

1. A type member, which will be displayed on the planner when you're making connections. This should describe the sort of data you want to take in with this input port (float, integer, degrees, command, etc.)
2. A name member, which will be shown as the name of the input port on the planner when you're making connections. For example, servo position, message, or LED brightness.
3. An implementation of the set function, which will be called when new data is sent to your input port. The set function describes what to do with this new data.

class Servo extends InputPort{
 
    type = "float"
    name = "position"
 
    function set(value) {
        hardware.pin1.write(0.04 + (value * 0.09));
    }
}

class Servo extends InputPort{
    type = "float"
    pin = null
 
    // define a constructor so that you can construct seperate instances for servos 1 and 2
    constructor(name, pin) {
        // call through to the base (InputPort) constructor with the provided name
        base.constructor(name)
        this.pin = pin
       // here you might like to configure the pin, if you didn't already do that at global scope
    }
 
    function set(value) {
        this.pin.write(0.04 + (value * 0.09));
    }
}

imp.configure("April Dual Servo Controller", [Servo("Pan", hardware.pin1), Servo("Tilt", hardware.pin2)], []);

Creating Output Ports

local my_output = OutputPort("potentiometer");

my_output.set(value);