since i don’t have a mobile phone (i must be the only one in japan without a keitai) i wasn’t aware of the incoming earthquake and my software was useless (being alert 10 minutes after the earthquake):

by detecting the primary waves we know in how many seconds (depending on the epicenter location) an earthquake will occur. i don’t know if it’s possible to build a p waves monitoring device (anyone?), but for now i’m using a free software (windows & japanese only) that send me an alert (no hardware required).

connecting the software to a microcontroller was not that hard, but since i don’t want to boot in windows just for monitoring the p waves i had to hack little. grosso modo: virtual box (windows in linux) -> autoit (checking for a p waves popup) -> create file <- linux bash checking for new file -> send serial command to arduino -> physical feedback.

please make a donation to the japanese red cross society

• take an old electric toothbrush;
• add a led and a vibrator;
• shape something around it;

i am using polycaprolactone (FDA approuved). the schematic is pretty simple, but i had to play with the capacitor and inductor to get more power into the vibrator. it’s overkill to use an attiny for cycling the colors of the led (i didn’t know that you can buy RGB led with built-in pwm). even so, i am sharing the small code, maybe it can be useful to someone. since i am using an electric toothbrush there’s no physical connection to recharge it, thus completely waterproof. i will need to remelt the polycaprolactone to change the battery someday.

 #define F_CPU 9600000UL
 #include <avr/io.h>
 #include <util/delay.h>
 #define LED PB0
 #define LED2 PB1
 int i;
 
 int main (void)
 {
	 DDRB = 0xff;
	 TCCR0A |= ((1 << COM0A1) | (1 << COM0A0) | (1 << COM0B1) | (1 << COM0B0) | (1 << WGM01) | (1 << WGM00)); // WGM01 - WGM00 (set fast PWM)
	 OCR0A = 0; // initialize Output Compare Register A to 0
	 OCR0B = 0;
	 TCCR0B |= (1 << CS01); // Start timer at Fcpu / 256
 
	 for (;;)
	 {
		 for (i = 0 ; i < 255 ; i++ ) // For loop (Up counter 0 - 255)
		 {
			  OCR0A = i; // Update Output Compare Register (PWM 0 - 255)
			 _delay_ms(8);
		 }
		 for (i = 255 ; i > 1 ; i-- ) // For loop (down counter 255 - 0 )
		 {
			 OCR0B = i; // Update Output Compare Register (PWM 0 - 255)
			 _delay_ms(8);
		 }
		 for (i = 255 ; i > 1 ; i-- ) // For loop (down counter 255 - 0 )
		 {
			  OCR0A = i; // Update Output Compare Register (PWM 0 - 255)
			 _delay_ms(8);
		 }
		 for (i = 0 ; i < 255 ; i++ ) // For loop (Up counter 0 - 255)
		 {
			  OCR0B = i; // Update Output Compare Register (PWM 0 - 255)
			 _delay_ms(8);
		 }
	 }
 }

i just found out that it’s possible to power the avr from the camera (focus ring). have a look at this complete and small solution: http://www.doc-diy.net/photo/hdr-jack/

//Intervalometer from 1 second to 1 minute
 
//Author: Patrick Sebastien Coulombe
//Website: www.workinprogress.ca
//Date: 2010-07-24
 
#define F_CPU 8000000
#include <avr/io.h>
#include <util/delay.h>
 
// use PB2 for led, pin 7
#define LED_BIT 2
// select ADC2, PB4, pin 3
#define CHANNEL 2
// shutter on (in ms)
#define HOLD 300 
 
// Return the 10bit value of the selected adc channel.
uint16_t get_adc(uint8_t channel) {
 
	// ADC setup
	ADCSRA = (1 << ADEN) | (1 << ADPS1) | (1 << ADPS0);
 
	// select channel
	ADMUX = channel;
 
	// warm up the ADC, discard the first conversion
	ADCSRA |= (1 << ADSC);
	while (ADCSRA & (1 << ADSC)); 
 
	ADCSRA |= (1 << ADSC); // start single conversion
	while (ADCSRA & (1 << ADSC)); // wait until conversion is done
 
	return ADCW;
}
 
// Scale
long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}
 
// Main program
int main(void) {
 
	// vars
	uint16_t adcvalue = 0;
	uint16_t i;
 
	// define LED as outputs
	DDRB |= (1 << LED_BIT);	
 
	while (1) {	
 
		//release the shutter
		PORTB |= (1 << LED_BIT);
 
		//exposure length
		for (i=0; i<HOLD; i++) { 
			_delay_ms(1); 
		}
		PORTB &= ~(1 << LED_BIT);
 
		//interval time (using a potentiometer to adjust)
		adcvalue = map(get_adc(CHANNEL), 0, 1023, 1, 60);
		adcvalue = adcvalue * 1000;
 
		//one way to achieve long delay
		for (i=0; i<adcvalue; i++) { 
			_delay_ms(1); 
		}
 
	}
	return 0;
 
}

Time lapse test (3 hours) from my balcony.

I used Blender for making the tilt / shift effect. Here’s the source of the Blender file.

VIDEO:

PHOTOS:

Schematic & Board (Kicad)
How to filter PWM for music

sd player source code

/*---------------------------------------------------------------*/
/* 8-pin SD audio player R0.02                     (C)ChaN, 2009 */
/*---------------------------------------------------------------*/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/sleep.h>
#include <avr/wdt.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include "diskio.h"
#include "pff.h"

char strbuff[10];
unsigned int position = 0;
unsigned long count = 0;
unsigned int nbwave = 0;

#define FCC(c1,c2,c3,c4)  (((DWORD)c4<<24)+((DWORD)c3<<16)+((WORD)c2<<8)+(BYTE)c1)  /* FourCC */

/*---------------------------------------------------------*/
/* Work Area                                               */
/*---------------------------------------------------------*/

volatile BYTE FifoRi, FifoWi, FifoCt;  /* FIFO controls */

BYTE Buff[256];    /* Wave output FIFO */

FATFS fs;      /* File system object */
DIR dir;      /* Directory object */
FILINFO fno;    /* File information */

WORD rb;      /* Return value. Put this here to avoid bugs of avr-gcc */

EMPTY_INTERRUPT(WDT_vect);

/*---------------------------------------------------------*/

static
DWORD load_header (void)  /* 0:Invalid format, 1:I/O error, >1:Number of samples */
{
  DWORD fcc, sz;
  UINT i;
  FRESULT res;

  res = pf_read(Buff, 256, &rb);    /* Load file header (256 bytes) */
  if (res) return 1;

  if (rb != 256 || LD_DWORD(Buff+8) != FCC('W','A','V','E')) return 0;

  i = 12;
  while (i < 200) {
    fcc = LD_DWORD(&Buff[i]);  /* FCC */
    sz = LD_DWORD(&Buff[i+4]);  /* Chunk size */
    i += 8;
    switch (fcc) {

    case FCC('f','m','t',' ') :    /* 'fmt ' chunk */
      if (sz > 100 || sz < 16)        /* Check chunk size */
        return 0;
      if (Buff[i+0] != 1)            /* Check coding type (1) */
        return 0;
      if (Buff[i+2] != 1 && Buff[i+2] != 2)  /* Check channels (1/2) */
        return 0;
      GPIOR0 = Buff[i+2];    /* Channel flag */
      if (Buff[i+14] != 8 && Buff[i+14] != 16)  /* Check resolution (8/16) */
        return 0;
      GPIOR0 |= Buff[i+14];  /* Resolution flag */
      OCR0A = (BYTE)(F_CPU / 8 / LD_WORD(&Buff[i+4])) - 1;  /* Sampling freq */
      break;

    case FCC('f','a','c','t') :    /* 'fact' chunk (skip) */
      break;

    case FCC('d','a','t','a') :    /* 'data' chunk (start to play) */
      fs.fptr = i;
      return sz;

    default :            /* Unknown chunk (error) */
      return 0;
    }
    i += sz;
  }

  return 0;
}

static
UINT play (
  const char *fn
)
{
  DWORD sz;
  FRESULT res;
  BYTE sw;
  WORD btr;

  if ((res = pf_open(fn)) == FR_OK) {
    sz = load_header();      /* Load file header */
    if (sz < 256) return (UINT)sz;

    if (!TCCR1) {        /* Enable audio out if not enabled */
      PLLCSR = 0b00000110;  /* Select PLL clock for TC1.ck */
      GTCCR =  0b01100000;  /* Enable TC1.OCB as PWM out (L-ch) */
      OCR1B = 128; OCR1A = 128;
      TCCR1 = STEREO ? 0b01100001 : 0b00000001;  /* Start TC1 with TC1.OCA is enabled as PWM out (R-ch) */
      TCCR0A = 0b00000010;  /* Enable TC0.ck = 2MHz as interval timer */
      TCCR0B = 0b00000010;
      TIMSK = _BV(OCIE0A);
    }

    FifoCt = 0; FifoRi = 0; FifoWi = 0;    /* Reset FIFO */
    pf_read(0, 512 - fs.fptr, &rb);      /* Snip sector unaligned part */
    sz -= rb;

    sw = 1;    /* Button status flag */
    do {
      /* Forward audio data */
      btr = (sz > 1024) ? 1024 : (WORD)sz;
      res = pf_read(0, btr, &rb);
      if (res != FR_OK || btr != rb) break;
      sz -= rb;
      /* Check button down and break on button down */
      sw <<= 1;
      //if (bit_is_clear(PINB, 0) && ++sw == 1) break;
      if (bit_is_clear(PINB, 0) && ++sw == 1) {
        
        count = 0;
        
        do { 
          count++;
          wdt_reset();
        } while (bit_is_clear(PINB, 0));
        
        if(count > 500000) {
          position--;
          position--;
        }
        
        break;
        
      }
      wdt_reset();
    } while (rb == 1024);  /* Repeat until all data read */
  }

  while (FifoCt) ;      /* Wait for FIFO empty */
  OCR1A = 128; OCR1B = 128;

  return res;
}

long smallrandom(long howbig)
{
  if (howbig == 0) {
    return 0;
  }
  return random() % howbig;
}

long rangerandom(long howsmall, long howbig)
{
  if (howsmall >= howbig) {
    return howsmall;
  }
  long diff = howbig - howsmall;
  return smallrandom(diff) + howsmall;
}

int main (void)
{
  PORTB = 0b111011;    /* Initialize port: - - H H H L H P */
  DDRB  = 0b111110;
  
  sei();
  
  //RANDOM (SEED)
  unsigned long seednumber = 1;
  unsigned char i;
  ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (0 << ADPS0);  //ADC Prescalar set to 64 - 125kHz@8MHz
  ADMUX |= (1 << ADLAR);
  ADCSRA |= (1 << ADEN);  // Enable ADC
    for(i = 0; i < 100; i++) {
    wdt_reset();
    ADCSRA |= (1 << ADSC);  // Start A2D Conversions
    while (ADCSRA & (1 << ADSC)); 
    seednumber = seednumber + ADCH;
  }
  ADCSRA |= (0 << ADATE);
  ADCSRA |= (0 << ADEN);  // Disable ADC
    ADCSRA |= (0 << ADSC);  // Stop A2D Conversions
  
  MCUSR = 0;
  WDTCR = _BV(WDE) | 0b110;  /* Enable WDT reset in timeout of 1s */

  BYTE res;
  //mount
  do {
    res = pf_mount(&fs);
    wdt_reset();
    seednumber++;
  } while (res != FR_OK);
  
  Buff[0] = 0;
  do {
    res = pf_opendir(&dir, (char*)Buff);
    wdt_reset();
    seednumber++;
  } while (res != FR_OK);
  
  //nb files
  for (;;) {
    res = pf_readdir(&dir, &fno);
    if (res != FR_OK || fno.fname[0] == 0) break;
    wdt_reset();
    nbwave++;
    seednumber++;
  }
  
  srandom(seednumber);
  //start with a random position
  position = rangerandom(1, nbwave + 1);

  for (;;) {
    
    //limit
    if(position > (nbwave + 1)) {
      position = 1;
    } else if(position < 1) {
      position = 1;
    }
    
    //play
    sprintf(strbuff,"%d.wav", position);
    play(strbuff);
    
    //increment song
    position++;

  }
}

servo source code

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include <avr/sleep.h>
#include <util/delay.h> 

#define F_CPU 8000000
#define nop()  __asm__ __volatile__("nop")

void wait100us(void) {
    unsigned char i;
    for(i = 0; i < 100; i++) {
      nop();
    }
}

void Delay_ms(unsigned int t)

  {
   unsigned int i, aika;
   aika = 140;

   while(t--)
    for(i = 0; i < aika; i++)

       if(t==0) return;

  } 

void adcinit (void) {

      // PRESCALER 128
      ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (0 << ADPS0);

      // AUTO TRIGGER ENABLE
      ADCSRA |= (1 << ADATE);

      // VCC ref
      ADMUX |= (0 << REFS1) | (0 << REFS0);

      // RIGHT ADJUST
      ADCSRB |= (0 << ADLAR);

      // CHANNEL 0
      ADMUX |= (0 << MUX5) | (0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (1 << MUX0);

      // FREE RUNNING MODE
      ADCSRB |= (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0);

      // ENABLE ADC
      ADCSRA |= (1 << ADEN);

    // PORT A: INPUT
    DDRA = 0x00;
    PORTA = 0x00;

}

void pwminit (void) {
    // disable PWM while configuring it
    TCCR1A = 0;

    // used for TOP, makes for 50 hz PWM = (8,000,000 / (8 * 50)) - 1
    ICR1 = 19999;

    // servo pins outputs
    DDRA = _BV(PA5) | _BV(PA6);

    // set up counter 1 (16 bit) to act as a dual channel PWM generator
    // comparator mode = non-inverting, use ICR1 as TOP and have a prescale of 8.
    TCCR1A = _BV(COM1A1) | _BV(COM1B1) | _BV(WGM11);
    TCCR1B = _BV(WGM13) | _BV(WGM12) | _BV(CS11);
}

long map(long x, long in_min, long in_max, long out_min, long out_max)
{
  return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

int main() {

  adcinit();
  pwminit();
    sei();

    // START A2D
    ADCSRA |= (1 << ADSC);

  while(1) {
    
    //700 to 2400
    //but here we need only 50 degress
    OCR1A = map(ADC, 0, 1023, 700, 1100);
    ADMUX |= (1 << MUX1);
    ADMUX &= ~(1 << MUX0);
    Delay_ms(2);
    OCR1B = map(ADC, 0, 1023, 700, 1100);
    ADMUX |= (1 << MUX0);
    ADMUX &= ~(1 << MUX1);
    Delay_ms(2);
  }
    return(0);
}

all this information will be outdated, now.

running a realtime kernel with enlightenment and blender:

schematic editor & cvpcb (transcript):

pcbnew (transcript):

V-USB kicad project (clean):
http://www.workinprogress.ca/wp-content/uploads/kicad_vusb.zip

Kicad:
http://kicad.sourceforge.net/wiki/index.php/Main_Page

Update:
http://kicad.1301.cz/

Libraries:
http://kicadlib.org/
http://per.launay.free.fr/kicad/kicad_php/composant.php

Tutorial:
http://KiCadHowTo.org

for 2.75$ you can have a chip that is able to run at 64 mhz (phase-locked loop) and output a pulse width modulation at 250 khz. attiny85 is your friend here. i didn’t found any atmega with this option (pll)… the good news is that it’s fast enough to output a stereo WAV at 16 bits / 48 khz. if you are interested in this project, take a look here: http://elm-chan.org/works/sd8p/report.html

since i want to connect the pwm output in a power amplifier, i need to filter the signal. here’s the waveform of the pulse width modulation @ 440 hz:

now let’s see if we use a simple RC low pass:

looks good to me, but then testing with a triangle instead of an oscillator revealed this:

that’s not beautiful… here’s a close-up:

maybe using more passive filter could help, but since you need to use an op-amp as a buffer (so that your load doesn’t affect the RC filter), why not use a sallen-key topology. this will act as an active low pass filter and a buffer. let’s look at the results:

close-up:

not perfect, but better!

SIMULATIONS
simple RC (250khz = -22db)

sallen-key second-order (250khz = -44db)

sallen-key third-order (250khz = -67db)

third-order is the best and using this method only 1 stage is needed.

when choosing the op-amp, consider this:
100 * highest Q * GBW = Gain Bandwidth Product (read about it here)
slew rate => 2V/µs
i am using a rail-to-rail input / output op-amp.

now simply add an electrolytic capacitor (100 uf) and you can feed an amplifier with the original pwm signal (hopefully).

You don’t need the 2 LEDs (visual feedback for debugging / bootloader).
Not using a bootloader? Then you can connect R4 to VCC (thus freeing PD4).

I am using an ATMEGA164p. The example code need to be modify to suit your device (bootloader address, registers, EEPROM functions).

This tutorial is for people who have some experience or are patient. Please pardon my english.

1) breadboard your avr for programmation (SPI / JTAG)

2) download vusb (last version)

A SIMPLE TEST (hid mouse)

cd vusb-x/examples/hid-mouse/firmware
open usbconfig.h – set the pin for usb (USB_CFG_DMINUS_BIT – USB_CFG_DPLUS_BIT)
open Makefile – edit DEVICE / F_CPU / FUSES / AVRDUDE
make hex
make program

Replug the device and automagically the mouse will move on your screen.

BOOTLOADERHID (optional)
3) download bootloadhid (last version)
This bootloader doesn’t require a driver (it’s HID). With it, you will be able to program your firmware without your programmer.

4) delete usbdrv, cp the usbdrv from vusb
5) open usbconfig.h – change the VENDOR and DEVICE name if you want
6) open bootloaderconfig.h – set the pin for usb (USB_CFG_DMINUS_BIT – USB_CFG_DPLUS_BIT) and if you want to be able to reset via usb (USB_CFG_PULLUP_IOPORTNAME). Change the bootloadcondition to suit your needs, i am using the EEPROM to write (from the firmware) & read (from the bootloader) + a button on PD5 (need to be hold) for the condition and finally 2 leds (so i know that i am in the bootloader).

show code ▼

#define JUMPER_BIT  5
#define BOOTLED_BIT  6
#define BOOTLED_BITB  7

static inline void  bootLoaderInit(void)
{
  DDRD |= (1 << BOOTLED_BIT);     // turn bootloader led on
  DDRD |= (1 << BOOTLED_BITB);     // turn bootloader led on 2
  PORTD |= (1 << JUMPER_BIT);     /* activate pull-up */
  _delay_us(10);  /* wait for levels to stabilize */
}

static inline void  bootLoaderExit(void)
{
    PORTD = (1 << BOOTLED_BIT);                 // turn bootloader led off
    PORTD = (1 << BOOTLED_BITB);                 // turn bootloader led off
}

7) main.c: Edit your condition, mine looks like this:
show code ▼

...
static void leaveBootloader()
{
 DBG1(0x01, 0, 0);
 bootLoaderExit();
 cli();
...
}
// ------------------------------------------------------------------------------
// - Write to EEPROM
// ------------------------------------------------------------------------------
void eepromWrite(unsigned int uiAddress, unsigned char ucData)
{
  /* Wait for completion of previous write */
  while(EECR & (1<<EEPE));
  /* Set up address and Data Registers */
  EEAR = uiAddress;
  EEDR = ucData;
  cli();
  /* Write logical one to EEMPE */
  EECR |= (1<<EEMPE);
  /* Start eeprom write by setting EEPE */
  EECR |= (1<<EEPE);
  sei();
}

// ------------------------------------------------------------------------------
// - Read EEPROM
// ------------------------------------------------------------------------------
unsigned char eepromRead(unsigned int uiAddress)
{
  /* Wait for completion of previous write */
  while(EECR & (1<<EEPE));
  /* Set up address register */
  EEAR = uiAddress;
  /* Start eeprom read by writing EERE */
  EECR |= (1<<EERE);
  /* Return data from Data Register */
  return EEDR;
}

int main(void)
{
    /* initialize hardware */
    bootLoaderInit();
    odDebugInit();
    DBG1(0x00, 0, 0);
    
    unsigned char do_boot_load;
  unsigned char do_boot_load_via_eeprom;
    
    do_boot_load = ~PIND & (1 << JUMPER_BIT);  // see if jumper is set (= 0)
    do_boot_load_via_eeprom = eepromRead(0); // bootloader bit in eeprom address 0
    
    /* jump to application if jumper is set */
    if(do_boot_load || do_boot_load_via_eeprom){
      eepromWrite(0, 0); // reset bit in eeprom
      PORTD &= ~(1 << BOOTLED_BIT);  /// Light led
      PORTD &= ~(1 << BOOTLED_BITB);  /// Light second led
      
        uchar i = 0, j = 0;
#ifndef TEST_MODE
        GICR = (1 << IVCE);  /* enable change of interrupt vectors */
        GICR = (1 << IVSEL); /* move interrupts to boot flash section */
#endif
        initForUsbConnectivity();
        do{ /* main event loop */
            wdt_reset();
            usbPoll();
#if BOOTLOADER_CAN_EXIT
            if(exitMainloop){
#if F_CPU == 12800000
                break;  /* memory is tight at 12.8 MHz, save exit delay below */
#endif
                if(--i == 0){
                    if(--j == 0)
                        break;
                }
            }
#endif
        }while(1);
    }
    leaveBootloader();
    return 0;
}

8) edit the Makefile

You need to know the BOOTLOADER_ADDRESS of your device (learn more about bootloader). Basically your datasheet will tell you the Start Bootloader section (look for Boot Size Configuration) in word address. You need to multiply it by 2 (the toolchain works on BYTE ADDRESS). For example, the atmega164p for 1024 words, the address is: 1C00 * 2 = 3800.

I am using a 20mhz clock, V-USB can be clocked with 12 Mhz, 15 MHz, 16 MHz or 20 MHz crystal or from a 12.8 MHz or 16.5 MHz internal RC oscillator.

Finally, you need to set the fuse correctly:

• Boot Flash section size = 1024 words
• Uncheck Divide clock by 8 internally

DEVICE = atmega164p
BOOTLOADER_ADDRESS = 3800
F_CPU = 20000000
FUSEH = 0xd8
FUSEL = 0xff
PROGRAMMER = avrispmkII
PORT = usb
...

make fuse
make flash

Now that you have the bootloaderhid, let’s write a simple firmware to test it.

test.c

#define F_CPU 20000000
#include <avr/io.h>
#include <util/delay.h>

int main(void) {

  // Set Port B pins as all outputs
  DDRB = 0xff;

  while(1) {

    PORTB = 0xFF;
    _delay_ms(100);

    PORTB = 0x00;
    _delay_ms(200);

  }

  return 1;
}

then:
avr-gcc -mmcu=atmega164p -Os test.c
avr-objcopy -j .text -j .data -O ihex a.out a.hex

cd bootloader/commandline
edit main.c if you changed the VENDOR and PRODUCT string
make

You need to connect the usb cable while holding the reset button. 2 LEDs should light up and you should see in dmesg something like:

[ 1727.956432] usb 3-2: new low speed USB device using uhci_hcd
[ 1728.119279] usb 3-2: configuration #1 chosen from 1 choice
[ 1728.142142] generic-usb 0003:16C0:05DF.000A: hiddev97,hidraw4: USB HID v1.01 Device [YOURVENDOR YOURPRODUCT] on usb-0000:00:1a.0-2/input0

Do:
./bootloadHID -r a.hex

FIRMWARE

Now what you want in your custom firmware is a way to tell your device to go in the bootloader (so you don’t have to hold the reset button anymore). With this method in place, adding the reset button is optional, but recommanded (in case you break something in the firmware, you need a way to go back in the bootloader).

Remember, in the bootloader we are reading the EEPROM to see if we need to stay in the bootloader section, if not we load the firmware. So in the firmware we will write the EEPROM if we want to go in the bootloader.
show code ▼

// ------------------------------------------------------------------------------
// - Write to EEPROM
// ------------------------------------------------------------------------------
void eepromWrite(unsigned int uiAddress, unsigned char ucData) {
  while(EECR & (1<<EEPE));
  EEAR = uiAddress;
  EEDR = ucData;
  cli();
  EECR |= (1<<EEMPE);
  EECR |= (1<<EEPE);
  sei();
}

/* ------------------------------------------------------------------------- */
/* ------------------------------- BOOTLOADER ------------------------------ */
/* ------------------------------------------------------------------------- */
void (*jump_to_bootloader)(void) = 0x1C00; __attribute__ ((unused))

void startBootloader(void) {
  
    eepromWrite(0 , 1);        // stay in bootloader
    
    TIMSK0 &= ~(1<<TOIE0);      // disable timer overflow
  
    cli();              // turn off interrupts
    wdt_disable();          // disable watchdog timer
    usbDeviceDisconnect();       // disconnect from USB bus
    
    cbi(ADCSRA, ADIE);        // disable ADC interrupts
    cbi(ADCSRA, ADEN);        // disable ADC (turn off ADC power)
    
    PORTA = 0;            // pull all pins low
    PORTB = 0;
    PORTC = 0;            
    
    jump_to_bootloader();
}

// - main
int main(void)
{

  while(1) {

    //jump to bootloader if jumper is HIGH
    if(bit_is_clear(PIND, 5)) {
      startBootloader();
    }
  }
  return 0;
}

You are ready to write the firmware for your application. Since you are using V-USB not only it let you upgrade your firmware very easily, but you can of course send and receive message between your computer and the device. Here’s an example of sending the value of a potentiometer to your computer and telling your device to blink a led at a certain speed. This example is for my device, Atmega164p.

vusbtut.tar.gz

WINDOWS
You can trick Windows so it doesn’t popup the driver installation when you plug your device. Your need to use a HID descriptor (Vendor type requests sent to custom HID class device).

hiddescriptor.h
show code ▼

// This HidReportDescriptor is not used, it's only here for avoiding a driver popup install on Windows
// See: Vendor type requests sent to custom HID class device
// http://vusb.wikidot.com/usb-device-classes

PROGMEM char usbHidReportDescriptor[33] = {
0x06, 0x00, 0xff,              // USAGE_PAGE (Generic Desktop)
0x09, 0x01,                    // USAGE (Vendor Usage 1)
0xa1, 0x01,                    // COLLECTION (Application)
0x15, 0x00,                    //   LOGICAL_MINIMUM (0)
0x26, 0xff, 0x00,              //   LOGICAL_MAXIMUM (255)
0x75, 0x08,                    //   REPORT_SIZE (8)

0x85, 0x01,                    //   REPORT_ID (1)
0x95, 0x06,                    //   REPORT_COUNT (6)
0x09, 0x00,                    //   USAGE (Undefined)
0xb2, 0x02, 0x01,              //   FEATURE (Data,Var,Abs,Buf)

0x85, 0x02,                    //   REPORT_ID (2)
0x95, 0x83,                    //   REPORT_COUNT (131)
0x09, 0x00,                    //   USAGE (Undefined)
0xb2, 0x02, 0x01,              //   FEATURE (Data,Var,Abs,Buf)
0xc0                           // END_COLLECTION
};

usbconfig.h
show code ▼

#define USB_CFG_DEVICE_CLASS        0    /* set to 0 if deferred to interface */
#define USB_CFG_DEVICE_SUBCLASS     0
/* See USB specification if you want to conform to an existing device class.
* Class 0xff is "vendor specific".
*/
#define USB_CFG_INTERFACE_CLASS     0x03   /* define class here if not at device level */
#define USB_CFG_INTERFACE_SUBCLASS  0
#define USB_CFG_INTERFACE_PROTOCOL  0
/* See USB specification if you want to conform to an existing device class or
* protocol. The following classes must be set at interface level:
* HID class is 3, no subclass and protocol required (but may be useful!)
* CDC class is 2, use subclass 2 and protocol 1 for ACM
*/
#define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    33

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include "usbdrv.h"
#include "hiddescriptor.h"

Here’s an example for installing the software & driver:
edubeat.zip

HOST SOFTWARE

Here’s the most basic host software written in python.
show code ▼

import usb

def findDevice(vendor_id):
  buses = usb.busses()
  for bus in buses :
    for device in bus.devices :
      print 'idVendor: %x' % device.idVendor
      if device.idVendor == vendor_id:
        print 'Found'
        return device
  return None

class VUSB:
  USB_VENDOR_ID = 0x16C0
  REQUEST_TYPE = usb.TYPE_VENDOR | usb.RECIP_DEVICE | usb.ENDPOINT_IN

  USB_BUFFER_SIZE = 2
  CMD_ZERO = 0

  def __init__(self):
    device = findDevice(self.USB_VENDOR_ID)
    if not device:
      raise Exception('Device not available')
    self.handle = device.open()

  def getBufferSize(self):
    return self.send_cmd(self.CMD_ZERO)

  def send_cmd(self, cmd, param=0):
    val = self.handle.controlMsg(requestType = self.REQUEST_TYPE, request = cmd, value = param, buffer = self.USB_BUFFER_SIZE)
    return val

def main():
  client = VUSB()
  print client.getBufferSize()

if __name__ == '__main__':
  main()

HARDWARE

V-USB runs on any AVR microcontroller with at least 2 kB of Flash memory, 128 bytes RAM and a clock rate of at least 12 MHz. For example the ATTINY25 can do the job. The price of this chip is 1.66 2.00 USD!

TEMPLATE

Here’s my template for the Atmega164p. This firmware is ready for ADC free-running mode, SPI master (you need to +5V PB4), external interrupts (PORTC), EEPROM read / write, jump to bootloader.
show code ▼

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <avr/wdt.h>
#include <util/delay.h>

#include "usbdrv.h"
#include "hiddescriptor.h"
#include "utils.h"

// - Define
#define DD_MOSI     PINB5
#define DD_SCK      PINB7
#define ADC_PINS 8

// - Global
static uint8_t usb_reply[10];

// - Write to EEPROM
void eepromWrite(unsigned int uiAddress, unsigned char ucData) {
  while(EECR & (1<<EEPE));
  EEAR = uiAddress;
  EEDR = ucData;
  cli();
  EECR |= (1<<EEMPE);
  EECR |= (1<<EEPE);
  sei();
}

// - Read EEPROM
unsigned char eepromRead(unsigned int uiAddress) {
  while(EECR & (1<<EEPE));
  EEAR = uiAddress;
  EECR |= (1<<EERE);
  return EEDR;
}

// - Bootloader
void (*jump_to_bootloader)(void) = 0x1C00; __attribute__ ((unused))

void startBootloader(void) {
  eepromWrite(0, 1);                // stay in bootloader
  TIMSK0 &= ~(1<<TOIE0);            // disable timer overflow
  cli();                            // turn off interrupts
  wdt_disable();                    // disable watchdog timer
  usbDeviceDisconnect();             // disconnect from USB bus
  cbi(ADCSRA, ADIE);                // disable ADC interrupts
  cbi(ADCSRA, ADEN);                // disable ADC (turn off ADC power)
  jump_to_bootloader();
}

// - usbFunctionSetup
USB_PUBLIC uchar usbFunctionSetup(uchar data[8]) {
  usbRequest_t    *rq = (void *)data;
  static uchar    replyBuf[10];

  usbMsgPtr = replyBuf;
  if(rq->bRequest == 0) { //POST

    replyBuf[0] = usb_reply[0];
    replyBuf[1] = usb_reply[1];
    replyBuf[2] = usb_reply[2];
    replyBuf[3] = usb_reply[3];
    replyBuf[4] = usb_reply[4];
    replyBuf[5] = usb_reply[5];
    replyBuf[6] = usb_reply[6];
    replyBuf[7] = usb_reply[7];
    replyBuf[8] = usb_reply[8];
    replyBuf[9] = usb_reply[9];
    return 10;

  } else if(rq->bRequest == 1) { //GET
    //rq->wIndex.bytes[0];
    //rq->wValue.bytes[0];
  }
  return 0;
}

// - InterruptInit
void InterruptInit() {
  PCICR |= (1 << PCIE2);
  PCMSK2 |= (1 << PCINT23) | (1 << PCINT22) | (1 << PCINT21) | (1 << PCINT20) | (1 << PCINT19) | (1 << PCINT18) | (1 << PCINT17) | (1 << PCINT16);
}

// - InterruptTrigged
SIGNAL (SIG_PIN_CHANGE2)
{
  //CODE
}

// - SPI_MasterInit
void SPI_MasterInit(void) {
  /* Set MOSI and SCK output, all others input */
  DDRB = (1<<DD_MOSI)|(1<<DD_SCK);

  /* Enable SPI, Master, set clock rate fck/16 */
  SPCR = (1<<SPE)|(1<<MSTR);
  SPSR = (1<<SPI2X);
}

// - SPI_MasterTransmit
void SPI_MasterTransmit(char cData) {
  /* Start transmission */
  SPDR = cData;
  /* Wait for transmission complete */
  while(!(SPSR & (1<<SPIF)));
}

// - ADC_setPint
void ADC_setPin (int8_t pin) {
  pin %= ADC_PINS;
  pin   |= ADMUX & -8;
  ADMUX  = pin;
}

// - hardwareInit
static void hardwareInit(void)
{
  //USB
  uchar i, j;

  /* activate pull-ups except on USB lines */
  USB_CFG_IOPORT = (uchar) ~ ((1 << USB_CFG_DMINUS_BIT) | (1 << USB_CFG_DPLUS_BIT));

  /* all pins input except USB (-> USB reset) */
  #ifdef USB_CFG_PULLUP_IOPORT    /* use usbDeviceConnect()/usbDeviceDisconnect() if available */
    USBDDR = 0;        /* we do RESET by deactivating pullup */
    usbDeviceDisconnect();
  #else
    USBDDR = (1 << USB_CFG_DMINUS_BIT) | (1 << USB_CFG_DPLUS_BIT);
  #endif

  j = 0;
  while (--j) {        /* USB Reset by device only required on Watchdog Reset */
    i = 0;
    while (--i);    /* delay >10ms for USB reset */
  }

  #ifdef USB_CFG_PULLUP_IOPORT
    usbDeviceConnect();
  #else
    USBDDR = 0;        /*  remove USB reset condition */
  #endif

  // ADC SETUP :: FREE RUNNING MODE

  // PRESCALER 64
  ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (0 << ADPS0);
  // AUTO TRIGGER ENABLE
  ADCSRA |= (1 << ADATE);
  // AVCC with external capacitor at AREF pin
  ADMUX |= (0 << REFS1) | (1 << REFS0);
  // RIGHT ADJUST
  ADMUX |= (0 << ADLAR);
  // CHANNEL 0
  ADMUX |= (0 << MUX4) | (0 << MUX3) | (0 << MUX2) | (0 << MUX1) | (0 << MUX0);
  // FREE RUNNING MODE
  ADCSRB |= (0 << ADTS2) | (0 << ADTS1) | (0 << ADTS0);
  // ENABLE ADC
  ADCSRA |= (1 << ADEN);

  // PORT A: INPUT
  DDRA = 0x00;
  PORTA = 0x00;

  // PORT B: OUTPUT
  DDRB = 0xFF;

  // PORT C: INPUT
  DDRC = 0x00;

  //POWER LED
  DDRD |= (1 << 6);
  PORTD &= ~(1 << 6);

  //SPI init
  SPI_MasterInit();

  //Interrupt init
  InterruptInit();
}

// - Main
int main(void) {
  wdt_enable(WDTO_1S);
  hardwareInit();
  usbInit();
  sei();

  ADCSRA |= (1 << ADSC); //Start Free Running Mode

  while(1) {
    wdt_reset();
    usbPoll();

    //BOOTLOADER
    if(bit_is_clear(PIND, 5)) {
    startBootloader();
    }

    //SPI CODE
    SPI_MasterTransmit('A');

    //YOUR CODE

    //USB TEST
    usb_reply[0] = 1;
    usb_reply[1] = 2;
    usb_reply[2] = 3;
    usb_reply[3] = 4;
    usb_reply[4] = 5;
    usb_reply[5] = 6;
    usb_reply[6] = 7;
    usb_reply[7] = 8;
    usb_reply[8] = 0;
    usb_reply[9] = 0;
  }
  return 0;
}

MORE INFORMATION

You can find more information about the API / USB Device Class / Host Software on the wiki of V-USB.

Speech recognition done with Simon