Kind words, thank you, thank you!

I am glad you like it, for my partner and me
worked hard to make this a quality product.

We hope to sell them to schools and colleges,
so please spread the word if you think this is an
easy to use and fun product.

But don't hesitate to mail me if you are
not happy with the product in any way or
see points for improvement.

Have fun!


Cheers.

Yet Another Mailchecker built with the R2Duino:



This toy duck, connected to one of the relays
on the R2Duino stick, quacks 1, 2 or 3 times (1 message,
medium load, heavy load) when there is new mail.

Very annoying, forces you to check your mail regularly;-)

[Package:]

More photos:

Package:


Mail notifier:
Perl script on PC checks for new mail, sends signal to R2Duino.
R2Duino activates small servo motor that raises arm of papercraft toy.

@Eight, the relays are able to handle 60V, AC or DC, and 400mA.

@mowcius, @crOsh, 4 rows of stackable headers are included in the package. And I am negotiating with a chinese manufacturer of molded cases for USB sticks. But the point is, you still want to be able to access the pin headers. I haven't figured out yet what the molded case should look like. Any suggestions?

I built a mail checker with it. A simple perl script om my PC sends a code to the R2Duino which activates a relay that switches on an little toy duck that makes a lot of noise when there is new mail.

It was a lot of fun building it.

Will publish some photos soon.

[Specifications:]

The R2Duino is a fully assembled USB STICK sized Arduino clone based on the ATmega328. It has the same functionality as the Arduino Nano 3.0, but comes in a different package. It lacks only a DC power jack, but has a standard size USB connector which fits right into the USB connector of your PC. The name R2Duino comes from the fact that this microcontroller board has 2 RELAYS, connected to pins D8 and D9. The R2Duino was designed and is being produced by Certeza.



Specifications:
Microcontroller: Atmel ATmega328
Operating Voltage (logic level): 5 V
Digital I/O Pins: 14 (of which 6 provide PWM output)
Analog Input Pins: 8
DC Current per I/O Pin: 40 mA
Flash Memory: 32 KB (of which 2 KB used by bootloader)
SRAM: 2 KB
EEPROM: 1 KB
Clock Speed: 16 MHz
Dimensions: 70 x 30 x 20mm
EXTRA: 2 relays (60V AC/DC 400mA) on pins D8 and D9, enabled/disabled by jumpers
EXTRA: Standard size USB connector

Included in the package:
4 rows of pin headers. You can solder them on the board if you need them.

I have produced a small run of 20 boards. If there is enough interest I will produce more.

You can order them from http://www.public-art-international.com/catalog/product_info.php/cPath/62/products_id/219.

I just produced a small batch of XBee USB adapter boards.

Put an XBee module in the socket, plug XeeBee in the USB connector of your PC and you can test XBee communication to your Arduino with a communication program on your PC.



More info here: http://www.public-art-international.com/catalog/product_info.php/cPath/62/products_id/220

I also offer a very easy to use Xbee USB adapter: the XeeBee.

Stick it into the USB connector of your PC, start up a communication app, that way you can test the communication before you fit your Arduino with an Xbee shield.

See for more info:
http://www.public-art-international.com/catalog/product_info.php/cPath/62/products_id/220

Can someone tell me what I am doing wrong?
I am trying to play 3 plucked strings more or less at the same time, but as soon as I uncomment the lines to play s1 or s2 the sound dies.

Any help is appreciated.

Code:

/**
 * Trying to play 3 plucked strings at the same time
 *
 *
 *
 **/

#include "avr/pgmspace.h"

// table of 2 octaves 3 & 4
// Octave 3: C=46, C#=48, D=52, D#=54, E=57, F=61, F#=65, G=68, G#=72, A=76, A#=80, B=86
// Octave 4: C=91, C#=97, D=103, D#=109, E=114, F=120, F#=127, G=134, G#=147, A=155, A#=162, B=170
PROGMEM  prog_uchar notes[]  = {
 46, 48,  52,  54,  57,  61,  65,  68,  72,  76,  80,  86,
 91, 97, 103, 109, 114, 120, 127, 134, 147, 154, 161, 170,
 182
};
// usage: v = pgm_read_byte_near(notes + nc);

#define SAMPLING_RATE  11025
//#define DELAY_TIME     100000/SAMPLING_RATE
#define DELAY_TIME     20000/SAMPLING_RATE

uint16_t v;
uint16_t vc;
uint8_t  nbh;
int32_t  avg;
long     cnt;

// String 1
byte s1;
uint8_t  N1;
int16_t  buf1[250];
uint8_t  bh1;
uint16_t f1;
uint16_t T1;
uint32_t iT1;
uint32_t iTMax1;

// String 2
byte s2;
uint8_t  N2;
int16_t  buf2[250];
uint8_t  bh2;
uint16_t f2;
uint16_t T2;
uint32_t iT2;
uint32_t iTMax2;

// String 3
byte s3;
uint8_t  N3;
int16_t  buf3[250];
uint8_t  bh3;
uint16_t f3;
uint16_t T3;
uint32_t iT3;
uint32_t iTMax3;


// -------------------------------------------------------------------------------------------------------------
// setup()
// -------------------------------------------------------------------------------------------------------------
void setup(){
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(5, OUTPUT);
 pinMode(6, OUTPUT);
 pinMode(7, OUTPUT);

 pinMode(8, INPUT);
 pinMode(9, INPUT);
 pinMode(10, INPUT);

 pinMode(13, OUTPUT);

 PORTD = 0;

 s1  = 0; // 0 = active
 s2  = 0; // 0 = active
 s3  = 0; // 0 = active
 cnt = 0;
}

// -------------------------------------------------------------------------------------------------------------
// loop()
// -------------------------------------------------------------------------------------------------------------
void loop(){
 
 cnt++;
 if (cnt == 10000)
   cnt=0;

 
 // pluck string at pos 100
 if (s1 == 0 && cnt > 100) {
   f1 = 46;  // freq
   T1 = 200; // duration

   // set buffer size
   N1 = SAMPLING_RATE / f1; // f == 44Hz..65535Hz
   // fill the buffer with white noise
   for (uint8_t i=0; i!=N1; i++) {
     buf1[i] = (int16_t) random(-32768,32767);
   }
   bh1 = 0;
   iTMax1 = SAMPLING_RATE * T1;
   iT1 = 0;
   s1 = 1;
 }
 else {
   // do something that takes the same time
   //delayMicroseconds(5);
 }
 

 // pluck string at pos 4000
 if (s2 == 0 && cnt > 4000) {
   f2 = 57;  // freq
   T2 = 200; // duration

   // set buffer size
   N2 = SAMPLING_RATE / f2; // f == 44Hz..65535Hz
   // fill the buffer with white noise
   for (uint8_t i=0; i!=N2; i++) {
     buf2[i] = (int16_t) random(-32768,32767);
   }
   bh2 = 0;
   iTMax2 = SAMPLING_RATE * T2;
   iT2 = 0;
   s2 = 1;
 }
 else {
   // do something that takes the same time
   //delayMicroseconds(5);
 }

 // pluck string at pos 8000
 if (s3 == 0 && cnt > 8000) {
   //Serial.println("Sound started.");
   f3 = 68;  // freq
   T3 = 200; // duration

   // set buffer size
   N3 = SAMPLING_RATE / f3; // f == 44Hz..65535Hz
   // fill the buffer with white noise
   for (uint8_t i=0; i!=N3; i++) {
     buf3[i] = (int16_t) random(-32768,32767);
   }
   bh3 = 0;
   iTMax3 = SAMPLING_RATE * T3;
   iT3 = 0;
   s3 = 1;
 }
 else {
   // do something that takes the same time
   //delayMicroseconds(5);
 }

 
 v = 0;
 vc = 0;

 /*
 if (s1 == 1) {
   v += (int8_t) (buf1[bh1] >> 8);
   vc++;

   nbh = bh1!=N1-1 ? bh1+1 : 0;
   avg = buf1[bh1] + (int32_t)buf1[nbh];
   avg = (avg << 10) - avg;    // subtract avg more than once to get faster volume decrease
   buf1[bh1] = avg >> 11;      // no division, just shift
   bh1 = nbh;

   iT1++;
   if (iT1 == iTMax1) {
     s1 = 0;
   }
 }
 else {
   // do something that takes the same time
   //delayMicroseconds(10);
 }
 */
 
 /*
 if (s2 == 1) {
   v += (int8_t) (buf2[bh2] >> 8);
   vc++;

   nbh = bh2!=N2-1 ? bh2+1 : 0;
   avg = buf2[bh2] + (int32_t)buf2[nbh];
   avg = (avg << 10) - avg;    // subtract avg more than once to get faster volume decrease
   buf2[bh2] = avg >> 11;      // no division, just shift
   bh2 = nbh;

   iT2++;
   if (iT2 == iTMax2) {
     s2 = 0;
   }
 }
 else {
   // do something that takes the same time
   //delayMicroseconds(10);
 }
 */
 
 if (s3 == 1) {
   v += (int8_t) (buf3[bh3] >> 8);
   vc++;

   nbh = bh3!=N3-1 ? bh3+1 : 0;
   avg = buf3[bh3] + (int32_t)buf3[nbh];
   avg = (avg << 10) - avg;  // subtract avg more than once to get faster volume decrease
   buf3[bh3] = avg >> 11;    // no division, just shift
   bh3 = nbh;

   iT3++;
   if (iT3 == iTMax3) {
     s3 = 0;
   }
 }
 else {
   // do something that takes the same time
   //delayMicroseconds(10);
 }
 
 
 v = v / vc;  // >> (PINB & B00000111); // tremolo effect
 sendTo8bitDAC(v); // preferably by port operation, e. g. "PORTD = v;"

 delayMicroseconds(DELAY_TIME);
}

void sendTo8bitDAC(int8_t v) {
 PORTD = v >> 2; // we use a 6 bit R2R ladder
}

Riddick, for some reason your previous posted function works better for me than your last one.

I also added some tremolo by reading 3 digital pins (8,9,10) connected to a 4040 IC driven by a clock signal from a 40106 IC.
and changing the line
const int8_t v = (int8_t) (buf[bh] >> ;
to:
const int8_t v = ((int8_t) (buf[bh] >> ) >> (PINB & B00000111);

See http://little-scale.blogspot.com/2008/01/arduino-noise-maker-info.html for more info.

It would be nice if it were possible to sound 3 plucked strings together.
Maybe make it interrupt driven?

Anyone?

Yes, it is all on a small PCB with connectors, I have included the schematic.
http://files.jeelabs.org/2010/02/Screen-shot-2010-02-14-at-12.05.27.png
The sensorplate I use is a piece of copper foil of 3 x 1 cm connected thru a short wire to pin 3 (E1 of MPR084) of SV1. A short cable connects PORT1 to my Arduino.

I just need an example how to configure the registers to activate one or more sensors and how to read them.

I need some working sample code to get me started with the MPR084 capacitive touch sensor IC.

I googled, tried every piece of code I saw, but I can get no reliable response from the little bugger.

Hi Guys,

I used Eric Latrop's code (found on http://ericlathrop.com/electronics/LedGrid.php) as a starting point to write a program that can scroll 5x7 or 8x8 characters on a 8x8 led grid using the direct drive method.
The only thing you have to do is change the constants NUM_COLS and NUM_ROWS and define either 5x7 characters or 8x8 characters or anything in between in pattern.h.

You can find the code at: http://public-art-international.com/files/LedGrid_bitmapped.zip.

Enjoy!

All much too complicated. For reliable communication up to 30 meters use Xbee. Cheap, easy and reliable. Code for Xbee communication can be found on the Arduino site.