//
// hello.speaker.45.c
//
// speaker PWM hello-world
//    square wave, pseudo-random frequency
//
// Neil Gershenfeld
// 11/14/10
//
// (c) Massachusetts Institute of Technology 2010
// This work may be reproduced, modified, distributed,
// performed, and displayed for any purpose. Copyright is
// retained and must be preserved. The work is provided
// as is; no warranty is provided, and users accept all 
// liability.
//

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

#define output(directions,pin) (directions |= pin) // set port direction for output
#define set(port,pin) (port |= pin) // set port pin
#define clear(port,pin) (port &= (~pin)) // clear port pin
#define pin_test(pins,pin) (pins & pin) // test for port pin
#define bit_test(byte,bit) (byte & (1 << bit)) // test for bit set
#define bit_delay_time 102 // bit delay for 9600 with overhead
#define bit_delay() _delay_us(bit_delay_time) // RS232 bit delay
#define half_bit_delay() _delay_us(bit_delay_time/2) // RS232 half bit delay
#define char_delay() _delay_ms(10) // char delay
#define input(directions,pin) (directions &= (~pin)) // set port direction for input

#define cycle_delay() _delay_us(2) // cycle delay
#define current 230 // PWM current
#define off 255 // PWM off

#define MOSFET_pin (1 << PB1)
#define MOSFET_port PORTB
#define MOSFET_direction DDRB

#define serial_port PORTB
#define serial_direction DDRB
#define serial_pins PINB
#define serial_pin_in (1 << PB0)
#define serial_pin_out (1 << PB2)
#define serial_interrupt (1 << PCIE)
#define serial_interrupt_pin (1 << PCINT0)

#define ID 'S'

volatile char in;

void get_char(volatile unsigned char *pins, unsigned char pin, volatile char *rxbyte) {
   //
   // read character into rxbyte on pins pin
   //    assumes line driver (inverts bits)
   //
   *rxbyte = 0;
   //while (pin_test(*pins,pin))
      //
      // wait for start bit
      //
   //   ;
   //
   // delay to middle of first data bit
   //
   half_bit_delay();
   bit_delay();
   //
   // unrolled loop to read data bits
   //
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 0);
   else
      *rxbyte |= (0 << 0);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 1);
   else
      *rxbyte |= (0 << 1);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 2);
   else
      *rxbyte |= (0 << 2);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 3);
   else
      *rxbyte |= (0 << 3);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 4);
   else
      *rxbyte |= (0 << 4);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 5);
   else
      *rxbyte |= (0 << 5);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 6);
   else
      *rxbyte |= (0 << 6);
   bit_delay();
   if pin_test(*pins,pin)
      *rxbyte |= (1 << 7);
   else
      *rxbyte |= (0 << 7);
   //
   // wait for stop bit
   //
   bit_delay();
   half_bit_delay();
   }

void put_char(volatile unsigned char *port, unsigned char pin, char txchar) {
   //
   // send character in txchar on port pin
   //    assumes line driver (inverts bits)
   //
   // start bit
   //
   output(serial_direction, serial_pin_out);
   clear(*port,pin);
   bit_delay();
   //
   // unrolled loop to write data bits
   //
   if bit_test(txchar,0)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,1)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,2)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,3)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,4)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,5)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,6)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   if bit_test(txchar,7)
      set(*port,pin);
   else
      clear(*port,pin);
   bit_delay();
   //
   // stop bit
   //
   set(*port,pin);
   bit_delay();
   input(serial_direction, serial_pin_out);
}
ISR(PCINT0_vect) {
	//
	// pin change interrupt handler
	//
	get_char(&serial_pins, serial_pin_in, &in);
	//put_char(&serial_port, serial_pin_out, in); // new line
	//status++;
	set(GIFR, (1<<PCIF));
	}
   
int main(void) {
   //
   // main
   //
   static uint16_t cycle,cycles,delay,bit;
   static uint32_t freqDelay,newFreq;
   //
   // set clock divider to /1
   //
   CLKPR = (1 << CLKPCE);
   CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
   //
   //
   //
   TCCR0A = ((1 << COM0B0) | (1 << COM0B1) | (1 << WGM01) | (1 << WGM00)); // set OC0B on compare match and set fast PWM mode, 0xFF TOP
   TCCR0B = (1 << CS00); // set timer 0 prescalar to 1
   //
	// initialize output pins
	//
	set(serial_port, serial_pin_out);
   //
   // initialize MOSFET pin
   //
   clear(MOSFET_port, MOSFET_pin);
   output(MOSFET_direction, MOSFET_pin);
   //
	// set up pin change interrupt on input pin
	//
	set(GIMSK, serial_interrupt);
	set(PCMSK, serial_interrupt_pin);
	sei();
   freqDelay=0;
   //
   // main loop
   //
   while (1) {
      //
      // update 11 bit LFSR
      //
      // loop over cycles
      //
      cycles = 10;
      for (cycle = 0; cycle < cycles; ++cycle) {
         //
         // set PWM current on and delay
         //
         OCR0B = current;
         for (delay = 0; delay < freqDelay; ++delay)
            cycle_delay();
         //
         // set PWM current off and delay
         //
         OCR0B = off;
         for (delay = 0; delay < freqDelay; ++delay)
            cycle_delay();
      }
      if (in == ID) {
			in=0;
         while (in == 0);
         newFreq = (in & 0x0f) * 1000;
         in=0;
         while (in == 0);
         newFreq += (in & 0x0f) * 100;
         in=0;
         while (in == 0);
         newFreq += (in & 0x0f) * 10;
         in=0;
         while (in == 0);
         newFreq += (in & 0x0f);
         in=0;
         freqDelay = 150000/newFreq;
			}
      }
   }