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

#define output(directions,pin) (directions |= pin) // set port direction for output
#define input(directions,pin) (directions &= (~pin)) // set port direction for input
#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 bridge_port PORTA // H-bridge port
#define bridge_direction DDRA // H-bridge direction
#define Ab (1 << PA0) // H-bridge output pins
#define Aa (1 << PA1) // "
#define Bb (1 << PA3) // "
#define Ba (1 << PA4) // "
#define on_delay() _delay_us(40) // PWM on time
#define off_delay() _delay_us(5) // PWM off time
#define PWM_count 200 // number of PWM cycles
#define step_count 200 // number of steps

#define serialOUT_port PORTA
#define serialOUT_direction DDRA
#define serialOUT_pins PINA
//#define serial_pin_in (1 << PA0)
#define serialOUT_pin_out (1 << PA7)

#define serialIN_port PORTB
#define serialIN_direction DDRB
#define serialIN_pins PINB
#define serialIN_pin_in (1 << PB2)

#define close_id    '2'
#define low_avg_id  '3'
#define high_avg_id '4'
#define open_id     '5'

static uint8_t count;
static uint8_t i,j,t,q;


//
// A+ B+ PWM pulse
//
void pulse_ApBp() {
  clear(bridge_port, Ab);
  clear(bridge_port, Bb);
  set(bridge_port, Aa);
  set(bridge_port, Ba);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, Aa);
      set(bridge_port, Ba);
      on_delay();
      clear(bridge_port, Aa);
      clear(bridge_port, Ba);
      off_delay();
      }
   }
//
// A+ B- PWM pulse
//
void pulse_ApBm() {
  clear(bridge_port, Ab);
  clear(bridge_port, Ba);
  set(bridge_port, Aa);
  set(bridge_port, Bb);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, Aa);
      set(bridge_port, Bb);
      on_delay();
      clear(bridge_port, Aa);
      clear(bridge_port, Bb);
      off_delay();
      }
   }
//
// A- B+ PWM pulse
//
void pulse_AmBp() {
  clear(bridge_port, Aa);
  clear(bridge_port, Bb);
  set(bridge_port, Ab);
  set(bridge_port, Ba);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, Ab);
      set(bridge_port, Ba);
      on_delay();
      clear(bridge_port, Ab);
      clear(bridge_port, Ba);
      off_delay();
      }
   }
//
// A- B- PWM pulse
//
void pulse_AmBm() {
  clear(bridge_port, Aa);
  clear(bridge_port, Ba);
  set(bridge_port, Ab);
  set(bridge_port, Bb);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, Ab);
      set(bridge_port, Bb);
      on_delay();
      clear(bridge_port, Ab);
      clear(bridge_port, Bb);
      off_delay();
      }
   }
//
// clockwise step
//
void step_cw() {
   pulse_ApBp();
   pulse_AmBp();
   pulse_AmBm();
   pulse_ApBm();
   }
//
// counter-clockwise step
//
void step_ccw() {
   pulse_ApBm();
   pulse_AmBm();
   pulse_AmBp();
   pulse_ApBp();
   }


void get_char(volatile unsigned char *pins, unsigned char pin, 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
   //
   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();
   //
   // char delay
   //
   bit_delay();
   }

void put_string(volatile unsigned char *port, unsigned char pin, PGM_P str) {
   //
   // send character in txchar on port pin
   //    assumes line driver (inverts bits)
   //
   static char chr;
   static int index;
   index = 0;
   do {
      chr = pgm_read_byte(&(str[index]));
      put_char(&serialOUT_port, serialOUT_pin_out, chr);
      ++index;
      } while (chr != 0);
   }

   //
   //

   void stepper (){

    
   clear(bridge_port, Aa);
   output(bridge_direction, Aa);
   clear(bridge_port, Ab);
   output(bridge_direction, Ab);
   clear(bridge_port, Ba);
   output(bridge_direction, Ba);
   clear(bridge_port, Bb);
   output(bridge_direction, Bb);
   
   if (j<<i){
   t= (i-j);
   for (q= 0; q < t; ++q){
            step_cw(); }}
   else if (j>>i){
   t= (j-i);
   for (q= 0; q < t; ++q){
            step_ccw(); }}
            
   else if (j==i){
   for (q=0; q<0 ; ++q){
            step_cw();}}


   
   
         /*for (j = 0; j < 75; ++j){
            step_cw(); }
            for (i = 0; i < 75; ++i){
            step_ccw(); }*/
            }

int main(void) {
   //
   // main
   //
   static char chr;
   
   //
   // set clock divider to /1
   //
   CLKPR = (1 << CLKPCE);
   CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
//
   // initialize bridge pins
   //
   
   //
   //
   // initialize output pins
   //
   set(serialOUT_port, serialOUT_pin_out);
   input(serialOUT_direction, serialOUT_pin_out);

   //
   // main loop
   //
   j=0;
   while (1) {
     get_char(&serialIN_pins, serialIN_pin_in, &chr);
      if (chr == open_id) {
      
               clear(bridge_port, Aa);
   output(bridge_direction, Aa);
   clear(bridge_port, Ab);
   output(bridge_direction, Ab);
   clear(bridge_port, Ba);
   output(bridge_direction, Ba);
   clear(bridge_port, Bb);
   output(bridge_direction, Bb);
   
   if (j<75){
   t= (75-j);
   for (q= 0; q < t; ++q){
            step_cw(); }}
   else if (j>75){
   t= (j-75);
   for (q= 0; q < t; ++q){
            step_ccw(); }}
            
         j=75;
       output(serialOUT_direction, serialOUT_pin_out);
         static const char message[] PROGMEM = "Opened";
         put_string(&serialOUT_port, serialOUT_pin_out, (PGM_P) message);
         put_char(&serialOUT_port, serialOUT_pin_out, 4);
         put_char(&serialOUT_port, serialOUT_pin_out, 10); // new line

         input(serialOUT_direction, serialOUT_pin_out);

         }
        else if (chr == close_id) {
      
          clear(bridge_port, Aa);
   output(bridge_direction, Aa);
   clear(bridge_port, Ab);
   output(bridge_direction, Ab);
   clear(bridge_port, Ba);
   output(bridge_direction, Ba);
   clear(bridge_port, Bb);
   output(bridge_direction, Bb);
   
   if (j<0){
   t= (0-j);
   for (q= 0; q < t; ++q){
            step_cw(); }}
   else if (j>0){
   t= (j);
   for (q= 0; q < t; ++q){
            step_ccw(); }}


         j=0;
       output(serialOUT_direction, serialOUT_pin_out);
         static const char message[] PROGMEM = "Opened";
         put_string(&serialOUT_port, serialOUT_pin_out, (PGM_P) message);
         put_char(&serialOUT_port, serialOUT_pin_out, 1);
         put_char(&serialOUT_port, serialOUT_pin_out, 10); // new line

         input(serialOUT_direction, serialOUT_pin_out);

         }
         
        else if (chr == low_avg_id) {
      i=25;
                 clear(bridge_port, Aa);
   output(bridge_direction, Aa);
   clear(bridge_port, Ab);
   output(bridge_direction, Ab);
   clear(bridge_port, Ba);
   output(bridge_direction, Ba);
   clear(bridge_port, Bb);
   output(bridge_direction, Bb);
   
   if (j<25){
   t= (25-j);
   for (q= 0; q < t; ++q){
            step_cw(); }}
   else if (j>25){
   t= (j-25);
   for (q= 0; q < t; ++q){
            step_ccw(); }}
            
  

         j=25;
        
       output(serialOUT_direction, serialOUT_pin_out);
         static const char message[] PROGMEM = "Opened";
         put_string(&serialOUT_port, serialOUT_pin_out, (PGM_P) message);
         put_char(&serialOUT_port, serialOUT_pin_out, '2');
         put_char(&serialOUT_port, serialOUT_pin_out, 10); // new line

         input(serialOUT_direction, serialOUT_pin_out);

         }
        else if (chr == high_avg_id) {
      i=50;
                  clear(bridge_port, Aa);
   output(bridge_direction, Aa);
   clear(bridge_port, Ab);
   output(bridge_direction, Ab);
   clear(bridge_port, Ba);
   output(bridge_direction, Ba);
   clear(bridge_port, Bb);
   output(bridge_direction, Bb);
   
   if (j<i){
   t= (i-j);
   for (q= 0; q < t; ++q){
            step_cw(); }}
   else if (j>i){
   t= (j-i);
   for (q= 0; q < t; ++q){
            step_ccw(); }}
         j=50;
         
       output(serialOUT_direction, serialOUT_pin_out);
         static const char message[] PROGMEM = "Opened";
         put_string(&serialOUT_port, serialOUT_pin_out, (PGM_P) message);
         put_char(&serialOUT_port, serialOUT_pin_out, '3');
         put_char(&serialOUT_port, serialOUT_pin_out, 10); // new line

         input(serialOUT_direction, serialOUT_pin_out);

         }
      }
}