Using the ChronulatorSMD as an Arduino

##############################################################

lilypad.name=LilyPad Arduino w/ ATmega168

lilypad.upload.protocol=arduino
lilypad.upload.maximum_size=14336
lilypad.upload.speed=19200

lilypad.bootloader.low_fuses=0xe2
lilypad.bootloader.high_fuses=0xdd
lilypad.bootloader.extended_fuses=0x00
lilypad.bootloader.path=lilypad
lilypad.bootloader.file=LilyPadBOOT_168.hex
lilypad.bootloader.unlock_bits=0x3F
lilypad.bootloader.lock_bits=0x0F

lilypad.build.mcu=atmega168
lilypad.build.f_cpu=8000000L
lilypad.build.core=arduino
lilypad.build.variant=standard

##############################################################

chronulator.name=ChronulatorSMD w/ ATmega168

chronulator.upload.protocol=arduino
chronulator.upload.maximum_size=14336
chronulator.upload.speed=19200

chronulator.bootloader.low_fuses=0xe2
chronulator.bootloader.high_fuses=0xdd
chronulator.bootloader.extended_fuses=0x00
chronulator.bootloader.path=lilypad
chronulator.bootloader.file=LilyPadBOOT_168.hex
chronulator.bootloader.unlock_bits=0x3F
chronulator.bootloader.lock_bits=0x0F

chronulator.build.mcu=atmega168
chronulator.build.f_cpu=4000000L
chronulator.build.core=arduino
chronulator.build.variant=standard

/* Delay for the given number of microseconds. Handles 20, 16, 8 or 4 MHz clock */
/* The 20 MHz change was in V1.0.1, the 4 MHz is my unofficial change.          */
void delayMicroseconds(unsigned int us)
{
	// calling avrlib's delay_us() function with low values (e.g. 1 or
	// 2 microseconds) gives delays longer than desired.
	//delay_us(us);
#if F_CPU >= 20000000L
	// for the 20 MHz clock on rare Arduino boards

	// for a one-microsecond delay, simply wait 2 cycle and return. The
	// overhead of the function call yields a delay of exactly 1 microsecond.
	__asm__ __volatile__ (
		"nop" "\n\t"
		"nop"); //just waiting 2 cycle
	if (--us == 0)
		return;

	// the following loop takes a 1/5 of a microsecond (4 cycles)
	// per iteration, so execute it five times for each microsecond of
	// delay requested.
	us = (us<<2) + us; // x5 us

	// account for the time taken in the preceeding commands.
	us -= 2;

#elif F_CPU >= 16000000L
	// for the 16 MHz clock on most Arduino boards

	// for a one-microsecond delay, simply return.  the overhead
	// of the function call yields a delay of approximately 1 1/8 us.
	if (--us == 0)
		return;

	// the following loop takes a quarter of a microsecond (4 cycles)
	// per iteration, so execute it four times for each microsecond of
	// delay requested.
	us <<= 2;

	// account for the time taken in the preceeding commands.
	us -= 2;
#elif F_CPU >= 8000000L
	// for the 8 MHz internal clock on the ATmega168

	// for a one- or two-microsecond delay, simply return.  the overhead of
	// the function calls takes more than two microseconds.  can't just
	// subtract two, since us is unsigned; we'd overflow.
	if (--us == 0)
		return;
	if (--us == 0)
		return;

	// the following _asm_ loop takes 4 cycles (half a microsecond at 8 MHz)
	// per iteration, so execute it twice for each microsecond of
	// delay requested.
	us <<= 1;

	// partially compensate for the time taken by the preceeding commands.
	// we can't subtract any more than this or we'd overflow w/ small delays.
	us--;
#else
	// For the 4 MHz case:  Do not change us.

	// for a 1 microsecond delay, simply return.  The overhead of
	// the function calls takes more than four microseconds.
	if (--us == 0)
		return;

	// the following _asm_ loop takes 4 cycles (one microsecond at 4MHz)
	// per iteration, so execute once for every microsecond of the argument.

#endif

	// busy wait
	__asm__ __volatile__ (
		"1: sbiw %0,1" "\n\t" // 2 cycles
		"brne 1b" : "=w" (us) : "0" (us) // 2 cycles
	);
}