Sunday, July 13, 2014

Intel GALILEO Microcontroller board

Intel GALILEO Single ATX DDR2 1066 Microcontroller Motherboard GALILEO1.Y

  • Galileo is designed to support shields that operate at either 3.3V or 5V.
  • The core operating voltage of Galileo is3.3V. However, a jumper on the board enables voltage translation to 5V at the I/O pins.
  • This provides support for 5V Uno shields and is the default behavior.
  • Galileo is a microcontroller board based on the Intel® Quark SoC X1000 Application Processor, a 32-bit Intel Pentium®-class system on a chip (SoC).
  • PC industry standard I/O ports and features to expand native usage and capabilities beyond the Arduino shield ecosystem
  • A full sized mini-PCI Express slot, 100Mb Ethernet port, Micro-SD slot, RS-232 serial port, USB Host port, USB Client Port, and 8 MByte NOR flash come standard on the board.

Saturday, July 12, 2014

Intel Galileo lab video playlist



Video include:

  1. Galileo as an Arduino compatible board
  2. Galileo as a linux server
  3. access GPIO from linux
  4. LedSensor in Arduino sketch
  5. LedSensor in shell
  6. LedSensor in C
  7. NodeJS
  8. Servo Motors


Friday, July 11, 2014

Beginning NFC with PhoneGap and Arduino - O'Reilly Webcast



Beginning NFC with PhoneGap and Arduino - O'Reilly Webcast

Originally recorded April 29, 2014. Don Coleman, Tom Igoe, and Brian Jepson (authors of Beginning NFC ) will introduce you to Near Field Communication using Android phones, Arduino, and NFC readers for computers and Arduino. Learn how information on NFC tags is stored and retrieved, how to write applications on Arduino and Android to read and write tags, and how to integrate NFC into larger projects.

Two demos in this session will feature :
  • Reading a tag with an Android PhoneGap application
  • Writing to a tag from Arduino
  • And when both are done, we'll be able to show you how an Android device can read the tag you wrote from Arduino and take an action based on the data you stored.

Saturday, July 5, 2014

duino, control Arduino with Node.js

duino is a framework for working with Arduinos in node.js. Here show how to (with little bit modification) make it run on Ubuntu, to control the LED of Arduino Due using Node.js.

- Connect Arduino Due to your host PC with USB cable.

- In Arduino Due board -

Create a new sketch, copy the source code of du.ino here, https://github.com/ecto/duino/blob/master/src/du.ino.


You will be complained with error of 'int index' redeclared as different kind of symbol. To fix it, rename variable index, for example idx.

#include <Servo.h>


bool debug = false;

int idx = 0;

char messageBuffer[12];
char cmd[3];
char pin[3];
char val[4];
char aux[4];

Servo servo;

void setup() {
  Serial.begin(115200);
}

void loop() {
  while(Serial.available() > 0) {
    char x = Serial.read();
    if (x == '!') idx = 0;      // start
    else if (x == '.') process(); // end
    else messageBuffer[idx++] = x;
  }
}

/*
 * Deal with a full message and determine function to call
 */
void process() {
  idx = 0;

  strncpy(cmd, messageBuffer, 2);
  cmd[2] = '\0';
  strncpy(pin, messageBuffer + 2, 2);
  pin[2] = '\0';

  if (atoi(cmd) > 90) {
    strncpy(val, messageBuffer + 4, 2);
    val[2] = '\0';
    strncpy(aux, messageBuffer + 6, 3);
    aux[3] = '\0';
  } else {
    strncpy(val, messageBuffer + 4, 3);
    val[3] = '\0';
    strncpy(aux, messageBuffer + 7, 3);
    aux[3] = '\0';
  }

  if (debug) {
    Serial.println(messageBuffer);
  }
  int cmdid = atoi(cmd);

  // Serial.println(cmd);
  // Serial.println(pin);
  // Serial.println(val);
  // Serial.println(aux);

  switch(cmdid) {
    case 0:  sm(pin,val);              break;
    case 1:  dw(pin,val);              break;
    case 2:  dr(pin,val);              break;
    case 3:  aw(pin,val);              break;
    case 4:  ar(pin,val);              break;
    case 97: handlePing(pin,val,aux);  break;
    case 98: handleServo(pin,val,aux); break;
    case 99: toggleDebug(val);         break;
    default:                           break;
  }
}

/*
 * Toggle debug mode
 */
void toggleDebug(char *val) {
  if (atoi(val) == 0) {
    debug = false;
    Serial.println("goodbye");
  } else {
    debug = true;
    Serial.println("hello");
  }
}

/*
 * Set pin mode
 */
void sm(char *pin, char *val) {
  if (debug) Serial.println("sm");
  int p = getPin(pin);
  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  if (atoi(val) == 0) {
    pinMode(p, OUTPUT);
  } else {
    pinMode(p, INPUT);
  }
}

/*
 * Digital write
 */
void dw(char *pin, char *val) {
  if (debug) Serial.println("dw");
  int p = getPin(pin);
  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  pinMode(p, OUTPUT);
  if (atoi(val) == 0) {
    digitalWrite(p, LOW);
  } else {
    digitalWrite(p, HIGH);
  }
}

/*
 * Digital read
 */
void dr(char *pin, char *val) {
  if (debug) Serial.println("dr");
  int p = getPin(pin);
  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  pinMode(p, INPUT);
  int oraw = digitalRead(p);
  char m[7];
  sprintf(m, "%02d::%02d", p,oraw);
  Serial.println(m);
}

/*
 * Analog read
 */
void ar(char *pin, char *val) {
  if(debug) Serial.println("ar");
  int p = getPin(pin);
  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  pinMode(p, INPUT); // don't want to sw
  int rval = analogRead(p);
  char m[8];
  sprintf(m, "%s::%03d", pin, rval);
  Serial.println(m);
}

void aw(char *pin, char *val) {
  if(debug) Serial.println("aw");
  int p = getPin(pin);
  pinMode(p, OUTPUT);
  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  analogWrite(p,atoi(val));
}

int getPin(char *pin) { //Converts to A0-A5, and returns -1 on error
  int ret = -1;
  if(pin[0] == 'A' || pin[0] == 'a') {
    switch(pin[1]) {
      case '0':  ret = A0; break;
      case '1':  ret = A1; break;
      case '2':  ret = A2; break;
      case '3':  ret = A3; break;
      case '4':  ret = A4; break;
      case '5':  ret = A5; break;
      default:             break;
    }
  } else {
    ret = atoi(pin);
    if(ret == 0 && (pin[0] != '0' || pin[1] != '0')) {
      ret = -1;
    }
  }
  return ret;
}

/*
 * Handle Ping commands
 * fire, read
 */
void handlePing(char *pin, char *val, char *aux) {
  if (debug) Serial.println("ss");
  int p = getPin(pin);

  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  Serial.println("got signal");

  // 01(1) Fire and Read
  if (atoi(val) == 1) {
    char m[16];

    pinMode(p, OUTPUT);
    digitalWrite(p, LOW);
    delayMicroseconds(2);
    digitalWrite(p, HIGH);
    delayMicroseconds(5);
    digitalWrite(p, LOW);

    Serial.println("ping fired");

    pinMode(p, INPUT);
    sprintf(m, "%s::read::%08d", pin, pulseIn(p, HIGH));
    Serial.println(m);

    delay(50);
  }
}

/*
 * Handle Servo commands
 * attach, detach, write, read, writeMicroseconds, attached
 */
void handleServo(char *pin, char *val, char *aux) {
  if (debug) Serial.println("ss");
  int p = getPin(pin);
  if(p == -1) { if(debug) Serial.println("badpin"); return; }
  Serial.println("signal: servo");

  // 00(0) Detach
  if (atoi(val) == 0) {
    servo.detach();
    char m[12];
    sprintf(m, "%s::detached", pin);
    Serial.println(m);

  // 01(1) Attach
  } else if (atoi(val) == 1) {
    // servo.attach(p, 750, 2250);
    servo.attach(p);
    char m[12];
    sprintf(m, "%s::attached", pin);
    Serial.println(m);

  // 02(2) Write
  } else if (atoi(val) == 2) {
    Serial.println("writing to servo");
    Serial.println(atoi(aux));
    // Write to servo
    servo.write(atoi(aux));
    delay(15);

    // TODO: Experiment with microsecond pulses
    // digitalWrite(pin, HIGH);   // start the pulse
    // delayMicroseconds(pulseWidth);  // pulse width
    // digitalWrite(pin, LOW);    // stop the pulse

  // 03(3) Read
  } else if (atoi(val) == 3) {
    Serial.println("reading servo");
    int sval = servo.read();
    char m[13];
    sprintf(m, "%s::read::%03d", pin, sval);
    Serial.println(m);
  }
}

Compile and upload to Arduino Due board.

- In Host PC, running Ubuntu -

Install duino for Node.js, run the command:

$ npm install duino

Create a .js file, testDuino.js. Copy the example code here, https://github.com/ecto/duino#usage.



You will be complained with error of Cannot open /dev/vboxusb.

To make it run on Ubuntu with usb port of ACMxx, modify  arduino.Board to have device: "ACM".

var arduino = require('duino');
var board = new arduino.Board({
  device: "ACM"
});

var led = new arduino.Led({
  board: board,
  pin: 13
});

led.blink();

- Now you can run your node.js code to toggle the LED on Arduino board.

$ node testDuino


Friday, July 4, 2014

Internet of Things with the Arduino Yún

Projects to help you build a world of smarter things with this book and ebook

Internet of Things with the Arduino Yún

Overview
  • Learn how to interface various sensors and actuators to the Arduino Yun and send this data in the cloud
  • Explore the possibilities offered by the Internet of Things by using the Arduino Yun to upload measurements to Google Docs, upload pictures to Dropbox, and send live video streams to YouTube
  • Learn how to use the Arduino Yun as the brain of a robot that can be completely controlled via Wi-Fi
In Detail

Internet of Things (IoT) is currently a growing trend in the technology space, and the Arduino Yun is the perfect board to get started with building IoT projects. This book covers many of the powerful features of the Arduino Yun via four exciting projects. The first project is all about sending weather measurements data to a Google Docs spreadsheet for easy online visualization. The second one is about building an energy consumption meter and controlling devices remotely. The third focuses on the field of security, by helping you to build a camera that is triggered by motion and that uploads pictures automatically to Dropbox. Finally, the last project is in relation with the field of robotics, and focuses on building a robot that is controlled via Wi-Fi.

The main focus of this book is to teach everything you need to know to build complex projects using the Arduino Yun, organized around the fields of home automation, security, and robotics.

What you will learn from this book
  • Connect various sensors to the Arduino Yun
  • Send sensor measurements to Google Docs via Temboo
  • Interface the Arduino Yun to Twitter via Temboo
  • Create automated e-mail alerts based on measured data
  • Use the Arduino Yun to control home appliances such as lamps
  • Measure energy consumption using the Yun
  • Take pictures with a USB camera and upload them to Dropbox
  • Build robots and control them remotely via Wi-Fi
Approach

All projects are explained in a step-by-step manner, always starting with the assembly of the hardware and followed by basic tests of every hardware component. You will then learn how to build exciting applications in a practical manner based on the details of the projects.