FunnyRobotics

B-Squares: Solar Powered Arduino In The Wild

2011-06-19T22:09:00.000+02:00

The B-Squares is a KickStarter Project launched by Jordan McRae which intended to facilitate the conception of solar powered devices / hacks by the "DIY" community.

B-Squares is a 3D modular electronics system which emphasize on solar power and expandable energy storage. Each Square has a magnetic contact on each of the corners which allows the Squares to easily snap together without wires. The magnetic contacts are also used to transmit electric signals between the Squares.

The Squares aren't restricted to being connected side-to-side in a single plane, but can also be stacked on top of or perpendicular one another. Think of it like a deck of electric cards that you can use to make 2D or 3D card houses and have the electricity flow through the entire array

There are currently 6 different type of B-Squares:

Solar-Square -- Includes 0.325W Solar Panel and a non-adhesive microsuction cup material for sticking to windows and other flat surfaces.
Battery-Square -- Includes three (3) internal rechargeable AAA batteries.
LED-Square -- Includes three (3) multi-color Light Emitting Diodes (LED).
Arduino-Square -- Includes a 3.3V Arduino Pro compatible microcomputer with easy access to the shield ports.
iPhone-Square -- Includes iPhone/iPod dock connector, PC USB connector, and stereo outputs.
Proto-Square -- Includes a standard 2.54mm pitch perfboard area on the printed circuit board (PCB).

Seeing the incredible success of this KickStarter Project, which reaches nearly six times its goal, one can hope to see this kind of device soon available via the main Arduino e-shops.

More information on B-Squares project HERE

Microsoft Kinect SDK For Windows In Beta

2011-06-16T22:03:00.000+02:00

It is rare that the DIYers'community is so dynamic and enthusiastic about something that one of the most powerful software company feels obliged to respond. And yet, that is what happened with the Kinect, which started as a game accessory for the XBOX360.

Microsoft announced the availability of Kinect for Windows Software Development Kit (SDK) from Microsoft Research, a free beta release for noncommercial applications. The Kinect for Windows SDK can be downloaded today at no cost for development of noncommercial applications.

To celebrate the release, Microsoft invited a select group of developers to the Microsoft campus in Redmond, to test the limits of their imaginations using the SDK in a Channel 9 Live 24-hour coding marathon, visible at http://channel9.msdn.com/live.

The Kinect for Windows SDK, which works with Windows 7, includes drivers, rich APIs for Raw Sensor Streams, natural user interfaces, installer documents and resource materials. The SDK provides Kinect capabilities to developers building applications with C++, C# or Visual Basic using Microsoft Visual Studio 2010.

Features of the SDK include the following:

Raw Sensor Streams.
Developers have access to raw data streams from depth sensor, color camera sensor and the four-element microphone array.
Skeletal Tracking.
The SDK has the capability to track the skeleton image of one or two people moving within the Kinect field of view, making it possible to create gesture-driven applications.
Advanced Audio Capabilities.
Audio processing capabilities include sophisticated noise suppression and echo cancellation, beam formation to identify the current sound source, and integration with the Windows speech recognition API.
Ease of installation.
The SDK quickly installs in a standard way for Windows 7 with no complex configuration required and a complete installer size of less than 100 MB.
Extensive documentation.
The SDK includes more than 100 pages of high-quality technical documentation. In addition to built-in help files, the documentation includes detailed walkthroughs for most samples provided with the SDK.

The offical web site contains plenty of information, documentation and code samples. A must see!

Official Kinect SDK web site HERE

Autodesk 123D, From Simulation To Prototype

2011-06-15T22:13:00.000+02:00

Autodesk releases 123D, a Windows based application mainly dedicated to hobbyists which allows not only to create 3D models but also real prototypes, thanks to its solid modeling capabilities. The purpose of 123D is to provide access to the tools to help you take your concept and make it reality, to give shape to your idea, exploring it, and most importantly, making it.

Solid modeling is is a consistent set of principles for mathematical and computer modeling of three dimensional solids. Solid modeling is distinguished from related areas of Geometric modeling and Computer graphics by its emphasis on physical fidelity. Together, the principles of geometric and solid modeling form the foundation of Computer-aided design and in general support the creation, exchange, visualization, animation, interrogation, and annotation of digital models of physical objects.

Not only you can freely donwload the 123D application but you also have access to free 3D models to help you get your project started, finished, or just to use in exploring ideas.

If 123D does not seems ''easy'' at first, I would say that it is certainly an interesting software which should retain your attention for a while. Fortunately there are tutorials, samples, and everything you can think of to learn 123D. And if you give yourself the trouble of creating objects relating to robotics, Do not hesitate to let us know, we will be happy to relay the information.

More information about 123D HERE

AlienCortex, One Board To Rule Them All.

2011-06-14T21:03:00.001+02:00

There is currently an interesting project on KickStarter, the AlienCortex board.

AlienCortex AV provides a new and powerful electronic canvas. The specificity of the Aliencortex is that it doesn't use a traditional micro-controller. Instead, the heart of AlienCortex is a Xilinx Spartan 3e 500K FPGA.

A Field-programmable Gate Array (FPGA) is an integrated circuit designed to be configured by the customer or designer after manufacturing—hence "field-programmable". The FPGA configuration is generally specified using a hardware description language (HDL), similar to that used for an application-specific integrated circuit (ASIC). FPGAs can be used to implement any logical function that an ASIC could perform.

The ability to update the functionality after shipping, partial re-configuration of the portion of the design and the low non-recurring engineering costs relative to an ASIC design, offer advantages for many applications.

The AlienCortex's strength lies in the fact that it can mimic just about any other kind of board that you can think of, limited only by the size of the FPGA. Because of this kind of flexibility, it can be a VGA graphics controller, a digital music synthesizer, a micro-controller (like the one used in the Arduino), and much more. AlienCortex's Spartan FPGA can be reconfigured as often as you like with new and different "cores"... so it's almost like a silicon etch-a-sketch in a way.

In the past, FPGAs have not been very easy for beginners to use. The AlienCortex AV platform is set upon changing that with a simple, unified, GUI-based environment and a growing library of cores to base your own creations around.

In essence, AlienCortex AV allows you to harness the power of what an FPGA is capable of with the same skills level and programming environment as an Arduino. It's library of pre-built cores turns AlienCortex into almost whatever you need it to be... a programmable video game console, a digital music synthesizer, a powerful robotics platform controller, a logic analyzer, and more.

Even more exciting is that many of the AlienCortex cores are "multicore" capable, and the board also includes 512KB of synchronous SRAM allowing you to run as many as four independent Arduino sketches all at the same time.

Already built in are the most common ports to connect AlienCortex AV to the outside world, including VGA, audio, PS/2 mouse and keyboard, 2 joysticks, SPI, USB JTAG/Serial port, and a Xilinx JTAG port.

AlienCortex AV also has pin headers for 54 5-volt IO pins and 16 5-volt analog inputs arranged in an Arduino Mega128/256 form factor, making AlienCortex compatible with most Arduino shields.


AlienCortex AV has already been designed, and the final series of prototypes have been built and verified. This Kickstarter project is to fund the next stage... the first manufacturing run. Should this project be successfully funded, those who back this project at the $147 reward level (or more) will receive an AlienCortex AV from the initial production run.


AlienCortex AV Hardware Specifications:

FPGA: Xilinx PQ208 Spartan 3e (500K)
RAM: 512KB 133Mhz 16 bit Synchronous SRAM
SPI FLASH: 1MB (8 megabit) Numonyx Flash EEPROM for FPGA configurations, sketches, and other user data
Two 5V Atari-compatible joystick ports
PS/2 Keyboard and Mouse ports
Sixteen multiplexed 5V analog inputs (bit resolution is determined by the core being used)
54 5V Digital/PWM I/O pins (Arduino Mega128/256 form factor)
Compatible with most shields designed for the Arduino Mega, Duemilanove or Diecimila. (Most Arduino shields.)
1 1/8" stereo digital audio jack
1 15 pin VGA connector
4 Programmable LEDs
4 Programmable Buttons
1 Reset button
1 FT2232 (Port A is dedicated to USB JTAG access to load cores, programs and sketches. Port B serves as a USB serial port or Computer->USB MIDI.)
1 Xilinx JTAG port (compatible with the Xilinx Platform USB Cable)

More information about FabulousSilicon HERE
More information on AlienCortex project HERE
More information on the Xilinx Spartan 3e 500K HERE
More information about FGPA HERE

Arduino, Interrupts And Timers

2011-06-13T22:07:00.000+02:00

Most of us, when working on an Arduino project, put their code in the "Loop" function and this code is executed again and again. We can of course use "If" or "Switch / Case" statements, often related to sensors data, to execute some code only if a specified conditions are met. But honestly, they are situation where this way of doing things is not efficient at all.

The "Doorbell" case
To illustrate such a case, imagine being at home, waiting for a relative or a friend. If you had been programmed with a main "Loop" function, you would do whatever you do and then go to open the door to check if your friend is waiting, and then do whatever you do and check the door and so on...

The above case illustrated as a skecth

void Setup ()
{
  // no Setup needed 
}

void Loop()
{
  Do_stuff_1 ;
  Do_stuff_2 ;
  // ...
  Do_stuff_3 ;
  Go_Check_Entry_Door ;
  If (someoneAtDoor)
  {
    Invite_Host ;
  }
}

void Invite_Host()
{
  Action_01 ;
  Action_02 ;
  Action_03 ; 
}

Of course, no one would react in such a way. Instead, we do our stuff until we hear the door bell. Then we interrupts our activities and we go open the door. The door bell is the "interrupt".


What Is An Interrupt ?
Interrupts are signals that interrupt the normal flow of a program. Interrupts are usually used for hardware devices that require immediate attention when events occur. More precisely, An interrupt is a signal sent to the CPU that does exactly what it sounds like: it interrupts the current program flow and makes it jump off in a different section temporarily, before returning to whatever it was doing previously. As far as the main program code is concerned, it doesn't even need to know that an interrupt has taken place. It will simply lose some time in the middle of whatever it was doing; other than that, everything will continue as if nothing happened. They can be very useful if you want your code to react fast to external events, while keeping your code simple.


Using Interrupts with an Arduino
Most Arduino designs have two hardware interrupts (referred to as "interrupt0" and "interrupt1") hard-wired to digital I/O pins 2 and 3, respectively. The Arduino Mega has a total of six hardware interrupts, with the additional interrupts ("interrupt2" through "interrupt5") on pins 21, 20, 19, and 18, respectively.

By defining a special function called an "Interrupt Service Routine" (ISR) that you want executed whenever the interrupt is triggered, and then specifying the conditions under which that can happen. With an Arduino, you can trigger the interrupt under four conditions, which are predefined as valid values:

LOW to trigger the interrupt whenever the pin is low,
CHANGE to trigger the interrupt whenever the pin changes value
RISING to trigger when the pin goes from low to high,
FALLING for when the pin goes from high to low.

Note that while an interrupt routine is running, all other interrupts are blocked. As a result, timers will not work in interrupt routines and other functionality may not work as expected. Therefore, always keep your interrupt routines short and simple.

To Specify a function to call when an external interrupt occurs, use "AttachInterrupt" with the following parameters.

attachInterrupt(interrupt, function, mode)

interrupt: the number of the interrupt (int)
function: the ISR; this function must take no parameters and return nothing.
mode: one of the four conditions listed above; Low, Change, Rising, Falling.

Note also that due to the fact that interrupts are blocked and timers are stopped during the ISR processing, inside the attached function, delay() won't work and the value returned by millis() will not increment. Serial data received while in the function may be lost. You should declare as volatile any variables that you modify within the attached function.

If we examine our doorbell case with an interrupt approach we will now have the following code:

interruptPin = 0;
void Setup ()
{
  // declare interrupt with three paramaters
  // If the doorbell rings (pin 0 changes its state)
  // execute function Invite_Host
  attachInterrupt(interruptPin , Invite_Host, CHANGE);
}

void Loop()
{
  Do_stuff_1 ;
  Do_stuff_2 ;
  // ...
  Do_stuff_3 ;
}

void Invite_Host()
{
  Action_01 ;
  Action_02 ;
  Action_03 ; 
}

Reassigning Interrupts
Interrupts can be changed at any point by using the attachInterrupt() method. As soon as this is done, any previously assigned interrupt on the associated pin is removed.


Starting / Stopping Interrupts
Arduino also has the ability to temporarily ignore all the interrupts. You may want to do this if you have some sensitive code that must be executed without interruption. In this case you would issue a noInterrupts() call. Once your sensitive code block has completed, interrupts can be restarted by calling interrupts().

Removing Interrupts
Interrupts can also be removed by using the detachInterrupt(interrupt_number) method.


Timers on Arduino
There are 3 hardware timers available on the ATmega168/328, and they can be configured in a variety of ways to achieve different functionality.

Timer0 (System timing, PWM 5 and 6)Used to keep track of the time the program has been running. The millis() function to return the number of milliseconds since the program started using a global incremented in the timer 0 ISR. Timer 0 is also used for PWM outputs on digital pins 5 and 6.
Timer1 (PWM 9 and 10)Used to drive PWM outputs for digital pins 9 and 10.
Timer2 (PWM 3 and 11)Used to drive PWM outputs for digital pins 3 and 11.

While all the timers are used only Timer0 has an assigned timer ISR. This means we can hijack Timer1 and/or Timer2 for our uses. The PWM function on some of the I/O pins will be affected as a result however. If you plan to use PWM you need to know what is affected. I chose to use timer 2 so PWM pins 3 and 11 will be affected.

The easiest way to use the timers is to download the TimerOne Library. This library will allow you to execute an ISR (Interrupt Service Routine) with regular delay.

The most important routines of the TimerOne library do:

initialize(period)You must call this method first to use any of the other methods. You can optionally specify the timer's period here (in microseconds, 1/1000000 second), by default it is set at 1 second. Note that this breaks analogWrite() for digital pins 9 and 10 on Arduino.
setPeriod(period)Sets the period in microseconds. The minimum period or highest frequency this library supports is 1 microsecond or 1 MHz. The maximum period is 8388480 microseconds or about 8.3 seconds. Note that setting the period will change the attached interrupt and both pwm outputs' frequencies and duty cycles simultaneously.
pwm(pin, duty, period)Generates a PWM waveform on the specified pin. Output pins for Timer1 are PORTB pins 1 and 2, so you have to choose between these two, anything else is ignored. On Arduino, these are digital pins 9 and 10, so those aliases also work. Output pins for Timer3 are from PORTE and correspond to 2,3 & 5 on the Arduino Mega. The duty cycle is specified as a 10 bit value, so anything between 0 and 1023. Note that you can optionally set the period with this function if you include a value in microseconds as the last parameter when you call it.
attachInterrupt(function, period)Calls a function at the specified interval in microseconds. Be careful about trying to execute too complicated of an interrupt at too high of a frequency, or the CPU may never enter the main loop and your program will 'lock up'. Note that you can optionally set the period with this function if you include a value in microseconds as the last parameter when you call it.
setPwmDuty(pin, duty)A fast shortcut for setting the pwm duty for a given pin if you have already set it up by calling pwm() earlier. This avoids the overhead of enabling pwm mode for the pin, setting the data direction register, checking for optional period adjustments etc. that are mandatory when you call pwm().
detachInterrupt()Disables the attached interrupt.
disablePwm(pin)Turns PWM off for the specified pin so you can use that pin for something else.

A simple implementation of the attachInterrupt of the TimerOne libray here below. This will execute myISR at a regular time lapse, a tenth of a second.

#include <TimerOne.h>

void setup() 
{
  
  Timer1.initialize(100000); // set a timer of length 100000 microseconds
  Timer1.attachInterrupt(myIsr); // attach the service routine here
}

void loop()
{
  // Main code loop
}

void myIsr()
{
  // The code executed every tenth of a second here
  // ....
}

More information on Arduino interrupts HERE
More information on TimerOne library HERE

RobotShop Microcontroller Instructables Contest

2011-06-09T15:39:00.000+02:00

RobotShop is partnering with Instructables, to bring you the Robotshop Microcontroller Instructables contest. To enter the Microcontroller Contest, you will jast have to Create a new photo, video, or step by step Instructable. From simple buzzer,to high tech rover, no matter what the project is as long as it includes a microcontroller and that you share your code. A video showing what it does will be a big plus !

Prices.
500$ RobotShop Gift certificate and a DFRobotShop Rover for the grand prize, 250$ robotShop Gift certificate and a DFRobotShop rover for the second prize. A DFRobotShop Rover for the runner-Up Prize...

The three happy winners will also get a RobotShop/Instructables prize pack (which includes several promotional goodies such as pens, a mousepad, a screw driver, and more).

An extra special prize for the best instructable that makes something move with a microcontroller.

Everyone entering in the contest will receive a 50% off for a DFRobotShop Rover.

Due date.
The contest closes for entries on July 3rd 2011. So Back to work and HAVE FUN !!!

More information about the Robotshop Microcontroller Instructables contest HERE
More information about RobotShop HERE
More information about Instructable HERE

The Robot Can, Mbed Controlled

2011-06-07T23:21:00.000+02:00

Cool DIY robot...

Controlled by an Mbed controller...

See our article on the MBed controller HERE

MBED, Microcontroller for Rapid Prototyping

2011-06-07T22:50:00.000+02:00

The mbed Microcontroller is a 32-bit ARM processor with a comprehensive set of peripherals and a built-in USB interface, all provided in a small and practical DIP package. It is designed specifically to make ARM microcontrollers easily accessible for rapid prototyping and experimentation.

Some features:

0.1" DIP pins so you can use it in breadboard, stripboard and through-hole pcbs
Powered via USB or an external power source
Re-program it like a FLASH drive; it appears as a USB disk, and you just drag on your .bin files
Has on-board LEDS, and provides a serial port over the USB connection to allow for printf-style debugging

Architecture
The mbed Microcontroller is based on a Cortex-M3 Core running at 96MHz, with 512KB FLASH, 64KB RAM and a load of interfaces including Ethernet, USB Device, CAN, SPI, I2C and other I/O. The diagram below shows the commonly used interfaces and their pinout locations. Note that all the numbered pins (p5-p30) can also be used as DigitalIn and DigitalOut interfaces.

The LPC17xx is an ARM Cortex-M3 based microcontroller for embedded applications requiring a high level of integration and low power dissipation. The ARM Cortex-M3 is a next generation core that offers system enhancements such as modernized debug features and a higher level of support block integration, operating at up to an 100 MHz CPU frequency. The ARM Cortex-M3 CPU incorporates a 3-stage pipeline and uses a Harvard architecture with separate local instruction and data buses as well as a third bus for peripherals. The ARM Cortex-M3 CPU also includes an internal prefetch unit that supports speculative branches.

The peripheral complement includes 512 kB of flash memory, 64 kB of data memory, Ethernet MAC, a USB interface that can be configured as either Host, Device, or OTG, 8 channel general purpose DMA controller, 4 UARTs, 2 CAN channels, 2 SSP controllers, SPI interface, 3 I2C interfaces, 2-input plus 2-output I2S interface, 8 channel 12-bit ADC, 10-bit DAC, motor control PWM, Quadrature Encoder interface, 4 general purpose timers, 6-output general purpose PWM, ultra-low power RTC with separate battery supply, and up to 70 general purpose I/O pins.

The architecture and implementation of the hardware and software components of mbed provide a convenient approach when it comes to prototyping. The mbed Microcontroller hardware packages a microcontroller, support components and smart USB interface in a practical 40-pin 0.1" pitch DIP form-factor, ideal for experimenting on solderless breadboard, stripboard and through-hole PCBs. To support the exposed interfaces, an mbed C/C++ library provides high-level interfaces to microcontroller peripherals, enabling a clean, compact, API-driven approach to coding. The combination gives immediate connectivity to peripherals and modules for prototyping and iteration of microcontroller-based system designs.

Mbed focuses on reusable library functionality. The core mbed library supports the main peripherals, and the libraries already contributed by the mbed design community include USB, TCP/IP, and HTTP support. It is also possible to add third-party and open-source stacks.


Compiler and Librairies
The mbed Compiler lets you write programs in C++, and then compile and download them to run on the mbed Microcontroller. The Mbed official web site offers a lot example, tutorials and librairies. The workspace is cloud based, so you can login from anywhere and carry on where you left off. And because it is a web app, it does not matter if you work on Windows, Mac or Linux.

The mbed Library gives you an API-driven approach to coding for the mbed Microcontroller. All the hard work of implementing drivers is laready done, so you don't have to do it. You code using meaningful abstract objects and API calls, so you don't need to learn the microcontroller hardware details to get going.

You will find libraries and tutorials on (just to name a few of tem):

TCP/IP Networking
Ethernet - physical connection and wiring
Network clients and servers
HTTP Server - handle HTTP requests
SMTP / POP3 Client
MySQL Client - connect to MySQL
LCDs and Displays
XBee - Simple Zigbee modules
RN-42-Bluetooth
Motors and Actuators
Servo motors
DC motor with PWM and an H-bridge
Dynamixel AX12 Servo
GlobalSat EM-406 GPS Module
Ultrasonic Ranger - I2C Ranging sensor
I2C MEMS barometric, absolute pressure sensor
JPEG Color Camera with UART Interface
Triple axis digital SPI accelerometer
Robot digital compass module
RFID readers from IB technology
A SPI digital thermometer
I2C temperature sensor with alert
OneWireCRC DS18S20, DS18B20 temperature sensors
ADT7410 I2C Temperature Sensor Handles temperatures lower than TMP102
Clocks and Oscillators
PID - Proportional, integral, derivative controller
IMU - Inertial measurement unit orientation filter
IR - Infrared ray transmitter and receiver
PS2 - PS/2 keyboard, mouse
Midi - Controlling Synthesizers, etc..
A library for touch screen controller.
SD Card File System
Interfacing with other languages (RPC, Matlab, Python, LabVIEW, Java, .NET)

Mbed Controlled Quadrotor

Price & availability
The Mbed will cost around 50.00€ and is available in a lot of online shops. If you look for something more powerful than an arduino but yet affordable, well documented, with an active community, the Mbed is certainly a good solution


Mbed official web site HERE

Arduino With Servo Motor

2011-06-06T23:05:00.000+02:00

If you plan to build a robot based on an Arduino, sooner or later, you will have to drive a servo motor. Servo motors enable you to accurately control movement because they move to a position instead of continuously rotating.. Servos are easy to connect and to control because the controller is built into the servo, and because the Arduino environment comes with a servo library.

Servos contaims a small motor connected through gears to a shaft. The shaft drives the servo arm and is also connected to a potentiometer to output position feedback to an internal controller.

Servos respond to changes in the duration of a pulse. A short pulse (1 ms or less) will position the servo to one extreme, and a longer pulse will rotate the servo to the other extreme. Pulses ranging in between these extremes will rotate the shaft proportionally to the pulse duration.

Note that although the duration of the pulse is modulated, servos require pulse that are different from the Pulse Width Modulation (PWM). You could damage your servo by connecting it to the output from AnalogWrite.

It is extremelly easy to control the position of a servo using an angle. To do so, use the Servo library distributed with the Arduino. Connect the servo power and ground to a suitable power supply (small servo can be directly powered from the Arduino) and connect the servo signal to an Arduino digital pin.

#include <servo.h>

Servo myServo ; // Create the Servo object
int angle = 0 ; // Store servo position

void setup()
{
  myServo.attach(9); // Specify the pin used to connect the servo
}

void loop()
{
  for(angle = 0; angle < 180; angle+=1) // loop from 0 to 180 degrees
  {
    myServo.write(angle);
    delay(20);  // delay between servo commands
  }
  for(angle = 180; angle >= 1; angle-=1) // loop from 180 to 0 degrees
  {
    myServo.write(angle);
    delay(20);
  }
  delay(2000);  
}

The servo library allows an Arduino board to control RC (hobby) servo motors. The Servo library supports up to 12 motors on most Arduino boards and 48 on the Arduino Mega. On boards other than the Mega, use of the library disables analogWrite() (PWM) functionality on pins 9 and 10, whether or not there is a Servo on those pins. On the Mega, up to 12 servos can be used without interfering with PWM functionality; use of 12 to 23 motors will disable PWM on pins 11 and 12.

Our article on the Dynamixel AX-12 Servo HERE

More information on servo HERE
More information on Arduino servo library HERE

Quadrotor Controller Board (KK Board) From HobbyKing

2011-06-05T21:10:00.001+02:00

The HobbyKing QuadRotor controller is a flight control board for 4 rotor Aircraft (Quadcopters). Its purpose is to stabilise the aircraft during flight. To do this it takes the signal from the three on board gyros (roll, pitch and yaw) then passes the signal to the Atmega48PA IC. The Atmega48PA IC unit then processes these signals according the users installed software and passes control signals to the installed Electronic Speed Controllers (ESCs). These signals instruct the ESCs to make fine adjustments to the motors rotational speed which in turn stabalises your quadrotor.

The control board also uses signals from your radio systems receiver (Rx) and passes these signals to the Atmega48PA IC via the ail, ele, thr and rud inputs. Once this information has been processed the IC will send varying signals to the ESCs which in turn adjust the rotational speed of each motor

Specifications.

Size: 50.5mm x 50.5mm x 23.5mm
Weight: 14.5 gram
IC: Atmega48PA
Gyro: Murata Piezo
Input Voltage: 3.3-5.5V
Signal from Receiver: 1520us (4 channels)
Signal to ESC: 1520us (4 ESCs)

The HobbyKing Quadrotor control board uses Japanese Murata piezo gyros that are less sensitive to vibration than SMD type gyros. This controller is priced at $29.99.

Piezo Gyros

Normal rotating mechanical gyroscopes like found on aircraft and ships use gyroscopic forces to detect changes in rotation. In order to make a ultra-small, ultra-lightweight, quick-response, low cost gyroscope a related phenomenon has been used. It uses the phenomenon of Coriolis force to detect changes in rotational angular velocity (rotation) in oscillating bodys. Rather than having a spining disk like on it's larger cousins these gyroscopes have a vibrating component. The vibrations are so small they cannot be felt by the human hand. In the engineering literature, this type of device is also known as a Coriolis vibratory gyro because as the plane of oscillation is rotated, the response detected by the transducer results from the Coriolis term in its equations of motion

Click to enlarge image

atMega48PA

It is a High Performance, Low Power AVR 8-Bit Microcontroller, very close to the atMega328 found on the Arduino, but less powerful. It has only 4 Kb of Ram (instead of 32 for the atMega328) and it is also slower than the atMega328. Otherwise both devices are manufactured using Atmel’s high density non-volatile memory technology. The On-chip ISP Flash allows the program memory to be reprogrammed In-System through an SPI serial interface, by a conventional non-volatile memory programmer, or by an On-chip Boot program running on the AVR core. The Boot program can use any interface to download the application program in the Application Flash memory. Software in the Boot Flash section will continue to run while the Application Flash section is updated, providing true Read-While-Write operation.

More information on the Quadrotor Controller Board HERE
More information on the Murata Piezo HERE
More information on the Atmel atMega48P HERE

FreeScale Tower System: New Peripheral Modules

2011-05-30T23:11:00.000+02:00

The Freescale Tower System is a modular development platform constitued of interchangeable and reusable modules (along with open source design files). Sold in kits or as individual modules, the expansion of the Tower System is simple and cost effective. You will find a link to our previous article about the Tower system below.

FreeScale announced two new peripheral modules.

Sensor fusion with the accelerometer and magnetometer
The LFSTBEB3110 is an evaluation board for the Freescale MAG3110FC 3-axis magnetometer. The LFSTBEB3110 kit includes a daughter board containing the MAG3110FC and MMA8451Q to allow for system calibration and compensation for demonstrating ecompass capability. For customers already familiar with the Sensor Toolbox Platform, the LFSTBEB3110 is designed to work with the LFSTBUSB for communication to a PC. For customers that desire the complete system, the development kit RD4247MAG3110 comes with both the LFSTBEB3110 and the LFSTBUSB boards together.

Freescale’s MAG3110 is a small, low-power, 3-axis digital magnetometer. The MAG3110 magnetometer measures the three components of the local magnetic field which will be the sum of the geomagnetic field and the magnetic field created by components on the circuit board. The MAG3110 features a standard I2C serial interface and is capable of measuring local magnetic fields up to 1000 uT with output data rates (ODR) up to 80 Hz.

The MMA8451Q is a smart low-power, three-axis, capacitive accelerometer with 14 bits of resolution. This accelerometer is packed with embedded functions with flexible user programmable options, configurable to two interrupt pins. Embedded interrupt functions allow for overall power savings relieving the host processor from continuously polling data. The device can be configured to generate inertial wake-up interrupt signals from any combination of the configurable embedded functions allowing the MMA8451Q to monitor events and remain in a low power mode during periods of inactivity.

The TWR-AUDIO-SGTL, Audio Module with SGTL5000 Codec

The TWR-AUDIO-SGTL peripheral module provides an audio interface for the Freescale Tower System. It features the Freescale SGTL5000 audio codec and line-in, line-out, headphone, and headset/microphone jacks. The SGTL5000 is a low-power stereo codec that includes a headphone amp and is designed to provide a comprehensive audio solution for portable products that require line-in, mic-in, line-out, headphone-out and digital I/O.

Our previous article on the FreeScale Tower System HERE

More information on the Sensor Toolbox Board HERE
More information on the TWR-AUDIO-SGTL Audio Module HERE

Arduino and Near Field Communication (NFC)

2011-05-29T23:03:00.000+02:00

The Near field communication, or NFC, is a set of short-range wireless technologies, typically requiring a distance of 4 cm or less. NFC operates at 13.56 MHz and at rates ranging from 106 kbit/s to 848 kbit/s. NFC always involves an initiator and a target; the initiator actively generates an RF field that can power a passive target. This enables NFC targets to take very simple form factors such as tags, stickers, key fobs, or cards that do not require batteries.

NFC peer-to-peer communication is of course possible, where both devices are powered. According to the NFC Forum, the three main uses of NFC currently are “sharing, pairing, and transaction.”

Currently, The most practical means of accomplishing a wireless communication with an Arduino Board is to use a Bluetooth or WiFi module, adding significantly to the cost of a project (between $30 and $60). Fortunately, Joe Desbonnet published a very interesting article on a hack to establish an NFC communication between and arduino and a NFC enabled devices.

If this technology has no direct application to drive or control a robot,It could be a way to identify yourself and securise your robot. Definitively geeky, "Just because you can do it", and learn something...

Joe Desbonnet Blog HERE
NFC Forum HERE

TurtleBot, The Clones War

2011-05-29T22:22:00.000+02:00

A few weeks ago, Willow Garage introduced the TurtleBot, which is basically an IRobot Create, a deck, a laptop and a kinect. We also saw the introduction of the Bilibot, also based on the Irobot Create platform. Unfortunately, both kits are priced at $1199.99, which might be an obstacle for some students or hobbyists to get access to these robots.

Based on this observation, Martin Mason, professor of physics and engineering, wrote a very detailled article which describes how to build your own turtlebot's clone.

You will find the necessary cad files to build the deck, a schema to connect the kinect to the battery and to the computer. There is even replacement solution for the laptop, which might be replaced by a mini-itx system. The lowest cost solution is estimated to $650.00. Nice Job professor !

Not only is this article really interesting, but the whole blog is full of articles related to ROS, kinect based navigation, ...
A must see for everyone interested in ROS and the turtlebot.

Our previous article on turtleBot HERE
Our previous article on BiliBot HERE

ProfMason Blog HERE

Turtlebot official website HERE
BiliBot official website HERE

Fairly Priced Android Development Kit (ADK) Board By Seeeduino

2011-05-24T22:14:00.000+02:00

Good news, Seeeduino just added an ADK board (Open Accessory Development Kit) to its catalog. Unlike the board sold by a japanese company around $400.00, the Seeeduino product is offered at a very fair price, $79.90. It is already possible to pre-order on the Seeeduino web site, but you will have to wait until June 20th to be delivred.

Features

Arduino Mega2560 compatible
56 Digital IOs
16 Analog inputs
14 PWM outputs
4 Hardware serial ports (UART)
1 Hardware TWI (I2C)
1 Hardware SPI (upto 8Mbps)
On board USB host(MAX3421), and IO breakout
On board USB slave(FT232), and Is breakout
Build-in 5V-1A switch power regulator (input range 6V - 18V)
Build-in 3.3V-500mA LDO power regulator
Red PCB, ROSH compatible and Golden finish
Android compatible

The Open Accessory Dev Kit allows external USB hardware (an Android USB accessory) to interact with an Android device in a special "accessory" mode. When an Android device (smartphone or tablet) is in accessory mode, the connected accessory acts as the USB host (powers the bus and enumerates devices) and the Android device acts as the device.

Read our previous article on the Open Accessory Development Kit HERE

More information on the Seeeduino ADK board HERE
More information on Open Accessory Development Kit HERE

Kleekbots In Beta: NXT Bots Controlled With a SmartPhone

2011-05-22T21:51:00.001+02:00

KleekBots lets you controls pre-defined MindStorms NXT robots with a smartphone, namely IPhone, Android based devices, Windows Mobile devices, Nokia, Samsung, IPod Touch, IPad and BlackBerry.

Kleekbots requires a client application running on a Windows PC. Once installed, You will be able to connect on "My Kleekbots". Kleekbot will communicate you precise information to build a MindStorms NXT robot. There are different robots you can build and control with kleekbots. You will have then to plug in the robot to your computer. You will also be able to specify if you want to use a webcam.

after that, You will access a screen that will let you check if you can control your robot and specify if you allow other users to access your robot with a "Share" option. Finally, you will have to activate an application on your smartphone by surfing on the http://www.kleekbots/m address.

Thank's to the "AnyBot" feature, you can even define your own robots, and the actions you want it to do. Anybot can be any robot that you choose to build. Create your own onboard RXE programs and assign each program to a button on the control panel and take ultimate control. Design, build, and control your very own robot from your smartphone, share control with friends and do everything that Kleekbots can do!

The process is well defined and is easily accessible even to beginners. Currently KleekBots is FREE, and with the possibility to "Share" your robot , there are certainly a lot of funny stuff to do , so why don't you give it a try....


More informations about Kleekbots HERE

LittleBits, Big Idea

2011-05-15T17:39:00.000+02:00

LittleBits is a library of discrete electronic components pre-assembled in tiny circuit boards that snap (or don't) together with tiny magnets. The concept is extremely simple, and will allow people without any knowledge in computing, electronic or programmation to try, test and develop ideas and concepts in electronic.

There are over 50 littleBits modules, divided into 4 categories: power, input, output, wire.
The starter kit contains 10 blocks and can be pre-ordered for $99.00.

LittleBits has been founded by Ayah Bdeir. She is an engineer and interactive artist who does not believe in boundaries set by disciplines or cultures. With an upbringing between Lebanon, Canada and the US, Bdeir's work uses experimental tools to look at deliberate and subconscious representations of identity.

Bdeir received her masters degree from the MIT Media Lab and undergraduate degrees in Computer Engineering and Sociology from the American University of Beirut. Her first solo show Identities in Motion" occurred in September of 2009 at the Peacock Visual Arts gallery in Scotland, and her work has been exhibited at numerous venues around the world including the New Museum, Ars Electronica, Badcuyp and Location One and this coming July at the Museum of Modern Art (MoMA).


More information about LittleBits HERE

Android Catapults The Arduino Into The Cloud

2011-05-15T03:01:00.000+02:00

The Open Accessory Development Kit.
Google created the buzz at the Google I/O 2011 with the announcement of the "Android Open Accessory API and Development Kit" (ADK). For those of you who missed the news, the Open Accessory Dev Kit allows external USB hardware (an Android USB accessory) to interact with an Android device in a special "accessory" mode. When an Android device (smartphone or tablet) is in accessory mode, the connected accessory acts as the USB host (powers the bus and enumerates devices) and the Android device acts as the device.

Android USB accessories are specifically designed to attach to Android devices and adhere to a simple protocol (Android accessory protocol) that allows them to detect Android devices that support accessory mode. Accessories must also provide 500mA at 5V for charging power.

Many previously released Android devices are only capable of acting as a USB device and cannot initiate connections with external USB devices. Android Open Accessory support overcomes this limitation and allows you to build accessories that can interact with an assortment of Android devices by allowing the accessory initiate the connection.

The main hardware and software components of the ADK include:

A USB micro-controller board that is based on the Arduino Mega2560 and Circuits@Home USB Host Shield designs (now referred to as the ADK board), which you will later implement as an Android USB accessory.
An Android Demo Shield (ADK shield) that affixes atop the ADK board implements the input and output points on the board. These implementations include a joystick, LED outputs, and temperature and light sensors. You can create or buy your own shields or wire your own features to the ADK board to implement custom functionality.
A library based on the Arduino USB Host Shield library provides the logic for the USB micro-controller board to act as a USB Host. This allows the board to initiate transactions with USB devices. Describing how to use this entire library is out of the scope of this document. Where needed, this document points out important interactions with the library. For more information, see the source code for the Arduino USB Host Shield library in the firmware/arduino_libs/USB_Host_Shield directory.
An Arduino sketch, firmware/demokit/demokit.pde, defines the firmware that runs on the ADK board and is written in C++. The sketch calls the Android accessory protocol library to interact with the Android device. It also sends data from the ADK board and shield to the Android application and receives data from the Android application and outputs it to the ADK board and shield.
The Android accessory protocol library. This library defines how to enumerate the bus, find a connected Android device that supports accessory mode, and how to setup communication with the device.

Due to the fact that this "ADK board" is mostly an Arduino, all librairies written for the Arduino will be supported by the ADK board. You will find at the end of this article a link to the official Arduino librairies.

"Building a mechanical device for its appearance is like putting lace on a bowling ball."
At first glance, it is certainly a good thing for all of us that Android gives some credit to the "physical computing" community, and more specifically to the Arduino but...

Because ADK has its own protocol you’ll need an Android 3.1 or 2.3.4 device (API level 12) for it to work, meaning that nobody will be able to use ADK on anything but the latest phones, which makes it completely useless for commercial applications in the short term. For hobbyists it means that unless they’re willing and able to update their devices to the latest roms they won’t be able to join the fun until their next smartphone purchase.

Secondly, currently the only commercially available ADK board I could find will cost you $390.00, which is more than extremely expensive for an Arduino Mega 2560, costing $64.95 at Sparkfun, to which you will have to add an USB Host Shield from Circuits@home costing $40.00. Four times more expensive, it's not a shame, it's a scam. Let's hope we will see other ADK board suppliers soon on the market.


"There is nothing worse than a sharp image of a fuzzy concept"
Android devices version 1.5 and above support a USB protocol for debugging applications, ADB (Android Debug Bridge), which also provides a lot of other useful functionality such as shell access, TCP forwarding, pushing files to the device, and so on. This protocol is know as the Android Debug Bridge (ADB), and can be enabled manually in the settings of your phone. ADB is very useful since it is essentially a byte stream multiplexer over USB. The host can open multiple streams concurrently, so it’s for example possible to talk to a running process, read logcat data, and pipe data to a file, all at the same time. Especially redirecting logcat output to the serial port of the MCU is crucial for debugging, but can also be used to let your micro detect when the Android process has crashed so it can be restarted. it can even reboot the phone.

ADK protocol offers a single bidirectional byte pipe between the phone and the accessory device, and comes with a nice Java API to detect and interact with connected accessories. So with ADK you can essentially attach a USB host capable microcontroller and talk to it from Java, but that’s about it. This means it actually offers fewer features than what was already out there.

So why does ADK come with a new byte stream protocol when nearly every device already supports ADB (Android Debug Bridge), a protocol which was specifically designed to do the same thing ?

Wanna play ?
Fortunately, there are different solutions if you want to use your Android phone (older version included) with "third party" hardware.

IOIO Board
The IOIO is a board specially designed to work with your Android device (OS versions 1.5 and greater). The board provides extensive and robust connectivity to an Android device via a USB connection. The IOIO is fully controllable from within an Android application, using a simple and intuitive Java API. It will cost you $49.95

The IOIO board contains a single MCU that acts as a USB host and interprets commands from an Android app. In addition, the IOIO can interact with peripheral devices in the same way as most MCUs. Digital Input/Output, PWM, Analog Input, I2C, SPI, and UART control can all be used with the IOIO. Code to control these interfaces is written in the same way as you write an Android app with the help of a simple to use app-level library

USB Host Shield 2.0 for Arduino from Circuits@home + MicroBridge library
The USB Host Shield contains all of the digital logic and analog circuitry necessary to implement a full-speed USB peripheral/host controller with your Arduino. This means you could use your Arduino to interface with and control any USB slave device - thumbdrives, digital cameras, bluetooth dongles, and...Android phones

An Arduino Mega 2560 + the USB host shield will cost you $104.00

You will also need the MicroBridge library, which is an Android Debug Bridge (ADB) implementation for microcontrollers. MicroBridge allows stock, unrooted Android devices to talk directly to USB host enabled MCUs, thereby enabling phones to actuate servos, drive DC motors, talk to I2C and SPI devices, read ADCs, and so forth.

Amarino
Amarino is a toolkit to connect Android-driven mobile devices with Arduino microcontrollers via Bluetooth. The toolkit provides easy access to internal phone events which can be further processed on the Arduino open-source prototyping platform. Started as a project at MIT Media Lab at the High-Low Tech group, this toolkit seeks to empower people to externalize their phone events to creatively demonstrate them on wearables, living spaces, or other tangibles.

This solution will cost you an Arduino Mega 2560 and a bluetooth shield, around $115.00

Conclusion
There are many solutions, and the one promoted by Google is, from far, the most expensive for no true advantage, at least in its current version. ADK is not a good reason to throw away your "old" Android phone and to spend your money for an ADK board. This situation might change in the future but for now, the fun is already available, and the good news is that it's NOT expensive.

Our previous article on the IOIO Board HERE

More information on the Android Open Accessory Development Kit HERE
More information about the IOIO Board HERE
More information about the Arduino USB host shield HERE
More information about MicroBridge HERE
More information on Amarino HERE
More information on the Arduino librairies HERE

Thermal Infrared Sensor For Mindstorms NXT

2011-05-14T02:01:00.000+02:00

Dexter Industries, which is nowadays extremely dynamic, is introducing a new sensor for the Lego MindStorms NXT, a digital Thermal Infrared Sensor.

The thermal infrared is a sensor measures the temperature of objects without contact, by measuring the infrared radiation coming off.

Soon you’ll be able to measure the temperature of objects just by pointing this sensor at something. This sensor will be able to measure up to 380° C!


More information on the thermal infrared sensor HERE

Tower System From FreeScale, MicroController "à la carte"

2011-05-14T01:37:00.001+02:00

Through the use of open software and a standardized form factor and signal list, FreeScale and its partners continually design new modules. These new modules can be used for future product development. Featuring multiple development boards or modules, the Tower System provides designers with building blocks for entry-level to advanced microcontroller development.

The best analogy I could do is an Arduino with its shields, except that with the tower system you get a lot more processing power and the possibility to stack multiple shields at once, thanks to the "Tower" approach.

The most evident advantage of the Tower system is its modularity, both at the controller module which comes with different processors, and also for the numerous peripheral modules.


Controller Module.
The controller modules can be used as stand-alone debug tools or as part of an assembled Tower System and feature an integrated debugging interface for easy programming and run-control via a standard USB cable. There is a lot of different controllers available for the Tower System. Each controller board comes with a specific MCU/MPU and different on-board connectors. The less expensive version is priced at $29,00, for one of the most advanced version, you will have to pay $129,00.

For instance, the TWR-K60N512 controller board already offer a LOT of good stuff.

K60N512: Kinetis K60 Low-Power MCU, 100MHz
Capacitive Touch Pads
SD Card Slot
MMA7660 3-axis accelerometer
Integrated, Open-Source JTAG
Potentiometer, 4 LEDs, 2 pushbuttons, infrared port
Battery Holder for 20mm lithium battery
Tower connectivity for access to USB, Ethernet, RS232/RS485, CAN, SPI, I²C, Flexbus, etc.

The K60 controller itself is a very interesting controller with:

ARM Cortex-M4 core + DSP. 100-150 MHz, single cycle MAC, single instruction multiple data (SIMD) extensions
Optional single precision floating point unit
Up to 32-channel DMA for peripheral and memory servicing with reduced CPU loading.
Cross bar switch enables concurrent multi-master bus accesses, increasing bus bandwidth
Up to 16 KB of instruction/data cache for optimized bus bandwidth and flash execution performance
Independent flash banks allow concurrent code execution and firmware updating with no performance degradation or complex coding routines

The above controller board will cost you $69.00 $, which is definitively inexpensive.

You will also find third party controller boards like the TWR1650, produced by Micro/Sys, a board based on a ARM Cortex-A8 processor running at 800MHz, with 512MB SDRAM, 1GB Flash, four USB ports, a10/100BASE-T Ethernet, a controller Area Network (CAN) port, five (5) serial ports, one (1) SD/MMC card slot and a16 bits of digital I/O.


Peripheral Modules
Adding features and functionality to your embedded design is really easy. The modularity of the Tower System makes it simple to add new system capabilities, like Wi-Fi, Sensors, Graphical LCD, and more. Sold separately as individual development boards, these peripheral modules simply plug into. Once again, very similar to the shields of an Arduino board.

Select your processor module, get peripheral modules and get started. All peripheral modules are designed to be combined and used with other Tower System modules.

Illustrated here, the LCD module connected to the tower elevator.

It is not possible to list them all, but for the most common, you will find:

Wi-fi Modules
Graphical LCD Module
High Precision Analog Module
Tower System RF Wireless Mesh Networking Module
Serial Module featuring Ethernet, USB, RS232/485, CAN
Prototyping Module featuring ample perfboard area for custom circuitry
Memory Module featuring Serial Flash, MRAM, CPLD, SD Card and Compact Flash
Sensor Module featuring multiple plug-in sensors, including inertial, pressure and touch sensors

Sensors
The sensor module will let you plug sensors like Digital Barometer, Digital Ambient Light Sensor, Proximity Sensor, Orientation/Motion Detection, Humidity and Temperature , keypad, etc...

The sensor module, click to enlarge.

Tower System with Lego MindStorms sensor

Robotic Kit

Not only does freescale produces and sells microcontroller, but they also have a robotic kit based on the Tower System. The kit includes four PWM controlled servos (actuators), metal legs, and the Tower System Mechatronics board that has a 3-axis accelerometer and a 12 channel touch sensor.

The Tower System Mechatronics board has a 32-bit ColdFire microcontroller with 64K of RAM, 512K of flash, and supports the full range of Freescale Xtrinsic sensors via plug-in daughter boards. It is programmable in C/C++ using CodeWarrior and an on-board OSBDM flash programming tool. For fast prototyping or for individuals without C/C++ experience, the Tower System Mechatronics Board is supported by the Robot Vision Toolkit and RobotSee (a language as simple as BASIC with the power of C).

The Mechatronic Board can be plugged into the Tower System. When plugged into the Tower System to become a controller module, capable of interfacing with all peripheral modules available in the Tower System family to expand its capabilities.

If the mechatronics board is certainly a good bargain, the "mechanical" side of this robotic kit, the chassis, is not what it should be, four degrees of freedom is definitely not enough to highlight the power of the controller, its peripherals and sensors. Let's hope that a new version of the chassis is quickly made available.

I told you, 4 DOF is not enough ;-)

The Mechatronics board will cost you $99.00 and the robotic kit $199.00.

Development tools.
Freescale's CodeWarrior Development Studio is a comprehensive development tool suite designed to enable embedded developers to meet the requirements of project life cycles. CodeWarrior comes complete with an IDE designed for each stage of the development process—from board bring-up through embedded application development.

The development environment comes in different versions:

The "Special" version, FREE, is limited by the code and data size (128 KB).
The "Basic" version priced at $399.00, is also limited by the code and data size (512 KB)

Note that the code used by the Tower System is a lot more complex than the very simple structure found in the Arduino's sketch. Fortunately, the Code Warrior comes with some "wizard" to help you in your project's setup. Nevertheless, be sure that you will face a steeper learning curve with the Tower system than with the Arduino, at least if you are not an advanced user.


Community
If the Freescale community, and moreprecisely the one devoted to the Tower System is not as large as the Arduino one, it is still really easy to find tutorials, and examples and examples and this without relying on the information and the forum found on the Freescale web site.


Last Thoughts
The Tower system concept is certainly interesting both technically et economically. The product range is wide and the available information are numerous enough to ensure that you will not be stuck in a dead-end during the development of your project.

Finally, one of the major players of the embedded industry shows some interests to the education sector and to the hobbyists market via a dedicated range of products. Let's hope that this initiative will encounter a lot of succes because, and it is just my opinion, they do it vey well.


More information on Tower System HERE
TowerGeeks Blog HERE
Embedded Linux for Tower System HERE

Quadrotor Circus, The Inverted Pendulum

2011-05-12T01:42:00.000+02:00

When it comes to agility, it seems that nothing can compete with these little machines. Another demonstration of this fabulous machines...

DuinoBot, The Arduino For The Youngest

2011-05-06T23:53:00.000+02:00

DuinoBot is a robotics development kit targeted to kids. It's based on the Atmel ATmega32u4 microcontroller, which is compatible with the ATMega328, the Arduino Uno microcontroller. This to say that this kit is compatible with the Arduino and will be programmable with all available tools to the Arduino like Scratch, ModKit, MiniBloq and the standard Arduino IDE.

The big difference with the Arduino Uno is that the Duinobot is protected from undesirable contact by a plastic casing, which is really fine if you intend to show the joy of the Arduino's universe to the youngest.

RobotGroup, the company which produces DuinoBot, also offers sensors and actuators for its board. Wheels encoder, light sensor, ultrasound sensor, in short all the usual ones. But Duinobot is also compatible at the hardware level (pins) with the Arduino and will accept all the Arduino shields.

RobotGroup also offers a complete robot set, the N6, which is built around the DuinoBot microcontroller and used "Multiplo" for the mechanical part. Multiplo is a construction set which includes wheels, motors, plates, ...

The product seems very interesting to anyone willing to introduce kids into the robotics, with the great advantage of having a direct gateway to the Arduino universe.

More information on DuinoBot HERE

Our previous article on MiniBloq HERE
Our previous article on ModKit HERE
Our previous article on Scratch for Arduino HERE

NI LabVIEW For Lego MindStorms NXT

2011-05-04T22:33:00.000+02:00

National Instruments is introducing "LEGO MINDSTORMS NXT 2.0 – powered by LabVIEW".

Program your robot to do what you want with an easy-to-use, intuitive software based on LabVIEW. Experimented users will notice many similarities between LEGO MINDSTORMS NXT software and LabVIEW, because NI and LEGO collaborated to retain all core LabVIEW graphical programming elements while optimizing the user interface for novice computer users.

Developing programs with the all new LEGO MINDSTORMS NXT software is fun and simple. The software, powered by NI LabVIEW, comes with building instructions and programming guides to easily begin constructing and programming with MINDSTORMS NXT robots. Drag and drop blocks from the left side of the screen on to the diagram. Each block performs a unique function such as moving the motors, displaying a message, detecting a sound, or measuring a distance. By combining a series of blocks you can program your robot to do almost anything you want!

LabVIEW users can also program their MINDSTORMS NXT robots in LabVIEW. The LabVIEW add-on for LEGO MINDSTORMS NXT gives users the ability to create and download VIs to operate and control their LEGO robotics systems.

Once ready, download it to your NXT. The compiled program is sent to the NXT using the wireless Bluetooth link or the connected USB cable. The NXT then executes the code that it receives from your host computer.

More information on "LEGO® MINDSTORMS® NXT - Powered by NI LabVIEW" HERE

FisherTechnik: ROBO TX Automation Robots

2011-05-02T23:26:00.000+02:00

Fischertechnik introduces a new product, the "ROBO TX Automation" set acts as both a replacement and an upgrade to the recently retired “Industrial Robots II” kit. This set addresses the construction and programming of the type of robots commonly found in industrial plants, such as automobile manufacturing, on a production line or in an automated warehouse. It includes instructions for building four different models to perform tasks such as gripping, moving, sorting and stacking. The kit includes sturdy aluminum channels for smoother operation and increased stability.

This set is a great way to explore industrial robotics, and like all fischertechnik products, you can easily incorporate parts from other sets, and even order additional parts, sensors and motors for building more sophisticated and elaborate robotic models. The kit contains 470 components, including 2 Encoder Motors, 2 XS Motors, 6 sensors. It also includes a disc with the upgrade to the latest version of ROBO Pro software as well as a teaching and activity guide PDF providing background information, projects and programming tips.

ROBO Pro Software is a visual programming language simple enough to allow middle school students to begin learning robotic programming and complete enough to allow professional engineers to model complex industrial processes. The language provides all the key elements of a modern programming language, including arrays, functions, recursion, objects, asynchronous events and quasiparallel processing. An editor menu allows you to select your experience level so beginners see only basic language elements while advanced users have access to a comprehensive development system. ROBO Pro generates machine code for maximum efficiency and complete access to controller features.

ROBO TX Controller

The controller with 32-bit processor, display, high storage capacity and with compact casing (90x90x15mm) offers numerous attachment possibilities on five sides. With integrated Bluetooth radio interface. Several „ROBO TX Controller“ can be coupled together.

32-bit ARM 9 processor (200 MHz)
Storage capacity: 8 MB RAM, 2 MB flash
8 Universal inputs: Digital, analog 0-9V DC, analog 0-5kΩ
4 fast counting inputs: Digital, frequency up to 1kHz
4 motor outputs, 9V, 250mA: Speed infinitely variable, short circuit proof, alternatively 8 individual outputs
2 expansion connections: I2C and RS 485 for coupling of additional „ROBOTX Controller“
Display: 128x64 pixel, monochrome
USB interface: USB 2.0 (1.1 compatible)
Programable with „ROBO Pro“ or C compiler (not included)

TX Explorer

What puzzled me is that even with a great quality assembly, a controller including an I2C and an RS 485, some more "funny" packages like the ROBO TX Explorer, there are nearly no hack, no buzz and very few movies on youtube, at least if you compare with the Lego MindStorms NXT...

More information on FisherTechnik products HERE

Amazingly Tiny QuadRotor: Daedalus CrazyCopter

2011-04-30T18:07:00.000+02:00

The quadrotor itself is organised around the main CPU. The job of this CPU is to acquire the physical measurement given by the gyroscopes and accelerometers and to control the motors to keep the copter stable. This is done by a regulation loop which controls the motors speed 250 times per second.

The computer runs control and telemetry programs. The control program reads the input from a game-pad and sends control commands to the copter. There are programs that can configure the quadrotor regulation parameters and log the measurements in order to make easier to tune the regulation.

The top of the board contains the sensors and the control/communication electronic:

The JTAG/Serial connector permit to program the processor and to communicate debug messages.
The Main CPU is a STM32 Cortex-M3. It is clocked at 64MHz from the internal oscillator.
The 2 Axis X-Y Gyro is an invensense IDG500.
The 1 Axis Z gyro is an invensense ISZ500.
The 2.4GHz Radio is based on an RF24L01+ chip from Nordic Semiconductor. It is actually a breakout board sold by SparkFun. The radio is connected to the CPU via a SPI port.
The 3 Axis Accelerometer is a SMB380 from Bosch. It is connected to the CPU via an I²C bus.

About power supply:

The charge connector accepts 5V and permits to charge the battery
The power switch permits to power the copter either from the charge connector or from the battery.
The 5V step-up permits to increase the power voltage from the 3~4V coming from the battery to 5V.
The two 3.3V linear regulators, reduces the 5V to power the copter electronic. The digital and analog 3.3V are generated independently. This was made to reduce the noise on the analog components.
Finally at the four sides there are the motors transistors. The power for the motors pass on the top and bottom of the part of PCB that hold the motors.
The battery charging chip is just at the right of the 3.3V regulators. It is a classical MAX1555.

The idea with the step-up was to get a more stable voltage when the battery is depleted and also to remove some of the noise coming from the motor electonic. Anyway, this boars is capable to work without by using 2.8V linear regulators instead.

The motors and propellers are taken from a Silverlit X-twin plane. They are powered by the battery voltage.
The distance between the motors (horizontally and vertically) is around 8 cm and the total weight is around 20 g.

More information about Daedalus crazy copter HERE.

CubeLets By Modular Robotics, Simplicity is the ultimate sophistication

2011-04-30T14:49:00.000+02:00

I already wrote an article to introduce the Cubelets by Modular Robotics which is a kit that comes with 20 magnetic blocks that can be snapped together to make an endless variety of robots with no programming and no wires.

You can build robots that drive around on a tabletop, respond to light, sound, and temperature, and have surprisingly lifelike behavior. But instead of programming that behavior, you simply snap the cubelets together and watch the behavior emerge.

Each cubelet in the kit has different equipment on board and a different default behavior. There are Sense Blocks that act like our eyes and ears, Action blocks, and Think blocks. Just like with people, the senses are the inputs to the system.

If the Arduino galaxy was on one side of the "robotics space time continuum", the Cubelets would be just at the opposite.


Our previous article on Cubelets HERE

More information on CubeLets HERE