//
//
// hello.stepper.bipolar.44.c
//
// bipolar full stepping hello-world
//
// Neil Gershenfeld
// 11/21/12
//
// (c) Massachusetts Institute of Technology 2012
// 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 <stdlib.h>
#include <util/delay.h>

#define RX    PA6   // *** D3, Pin 2
//#define input_pin (1 << PA5)
#define TX    PA5   // *** D4, Pin 3
//#define output_pin (1 << PA6)

#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

//++++++++++++++++++++++++++++++++++from seraila NEIL+++++++++++++++++++++++++++++++++++++++++++++++
#define bit_delay_time 102 // bit delay for 115200 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 serial_port PORTA
#define serial_direction DDRA
#define serial_pins PINA
#define serial_pin_in (1 << PA6)
#define serial_pin_out (1 << PA5)

#define max_buffer 25
//++++++++++++++++++++++++++++++++++from seraila NEIL+++++++++++++++++++++++++++++++++++++++++++++++

#define bridge_port PORTA // H-bridge port
#define bridge_direction DDRA // H-bridge direction
#define A2 (1 << PA0) // H-bridge output pins
#define A1 (1 << PA1) // "
#define B2 (1 << PA3) // "
#define B1 (1 << PA4) // "
#define on_delay() _delay_us(10) // PWM on time
#define off_delay() _delay_us(2) // PWM off time
#define PWM_count 100 // number of PWM cycles
#define step_count 20 // number of steps
#define wait_delay() _delay_us(1000) // PWM on time


static uint8_t count;

//
// A+ B+ PWM pulse
//
void pulse_ApBp() {
  clear(bridge_port, A2);
  clear(bridge_port, B2);
  set(bridge_port, A1);
  set(bridge_port, B1);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, A1);
      set(bridge_port, B1);
      on_delay();
      clear(bridge_port, A1);
      clear(bridge_port, B1);
      off_delay();
      }
   }
//
// A+ B- PWM pulse
//
void pulse_ApBm() {
  clear(bridge_port, A2);
  clear(bridge_port, B1);
  set(bridge_port, A1);
  set(bridge_port, B2);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, A1);
      set(bridge_port, B2);
      on_delay();
      clear(bridge_port, A1);
      clear(bridge_port, B2);
      off_delay();
      }
   }
//
// A- B+ PWM pulse
//
void pulse_AmBp() {
  clear(bridge_port, A1);
  clear(bridge_port, B2);
  set(bridge_port, A2);
  set(bridge_port, B1);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, A2);
      set(bridge_port, B1);
      on_delay();
      clear(bridge_port, A2);
      clear(bridge_port, B1);
      off_delay();
      }
   }
//
// A- B- PWM pulse
//
void pulse_AmBm() {
  clear(bridge_port, A1);
  clear(bridge_port, B1);
  set(bridge_port, A2);
  set(bridge_port, B2);
   for (count = 0; count < PWM_count; ++count) {
      set(bridge_port, A2);
      set(bridge_port, B2);
      on_delay();
      clear(bridge_port, A2);
      clear(bridge_port, B2);
      off_delay();
      }
   }
//
// clockwise step
//there is a bug if you call it repeatedly eventually it starts going back and frth instead of vcontinuiing going round
void step_cw() {
   pulse_ApBp();
   pulse_AmBp();
   pulse_AmBm();
   pulse_ApBm();
   }
//
// counter-clockwise step
//there is a possible bug if you call it repeatedly eventually it starts going back and frth instead of vcontinuiing going round.
//could be connection  in the electronics or miswiring ......
void step_ccw() {
   pulse_ApBm();
   pulse_AmBm();
   pulse_AmBp();
   pulse_ApBp();
   }
// we want:
// 1. start n at 0
// 2. repaet the following sequence but incremet the number of steps n by 50 each time:
//   2a. the sequence is to spin n steps cw
//   2b. than n steps step_ccw

//spins n steps clockwise
void step_ncw(int n) {
int i=0;
  while(i<n){
    i++;
  step_cw();
  }
}
  //spins n steps counter clockwise
void step_nccw(int n) {
  int i=0;
    while(i<n ){
      i++;
    step_ccw();
  }
}


//++++++++++++++++++++++++++++++++++from seraila NEIL+++++++++++++++++++++++++++++++++++++++++++++++
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, char *str) {
   //
   // print a null-terminated string
   //
   static int index;
   index = 0;
   do {
      put_char(port, pin, str[index]);
      ++index;
      } while (str[index] != 0);
   }

//++++++++++++++++++++++++++++++++++from seraila NEIL+++++++++++++++++++++++++++++++++++++++++++++++


int main(void) {
   //
   // main
   //
   static uint8_t i,j;
   //

   //Neil serial
   static char chr;
   static char buffer[max_buffer] = {0};
   static int index;
   //Neil serial
   
   // set clock divider to /1
   //
   CLKPR = (1 << CLKPCE);
   CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
   //
   // initialize bridge pins
   //
//   mySerial.begin(9600);
   clear(bridge_port, A1);
   output(bridge_direction, A1);
   clear(bridge_port, A2);
   output(bridge_direction, A2);
   clear(bridge_port, B1);
   output(bridge_direction, B1);
   clear(bridge_port, B2);
   output(bridge_direction, B2);

     //from Neil serial
     // initialize output pins
   //
   set(serial_port, serial_pin_out);
   output(serial_direction, serial_pin_out);
   index = 0;
   //
   //from Neil serial

   // we want:
   // 1. n starts at 0
   //int n=0;
   // 2. repaet the following sequence for ever but incremet the number of steps n by 50 each time:
   while (1)
   {
      
      //++++++++++++++++++++++from Neil+++++++++++++++++++++++++++++
        put_string(&serial_port, serial_pin_out, "hello.ftdi.44.echo.c: you typed \"");
        //step_ccw();
          do
          {
            get_char(&serial_pins, serial_pin_in, &chr);
            buffer[index++] = chr;
          }
          while ( chr != '\r' && index < 15 ); // assuming "Carriage Return" is chosen in the Serial monitor as the line ending character

          put_string(&serial_port, serial_pin_out, buffer);
          put_char(&serial_port, serial_pin_out, '\"');
          put_char(&serial_port, serial_pin_out, 10); // new line
          buffer[index] = '\0';
          if ( buffer[0] == 'z' || buffer[0] == 'Z' )
          {
            if ( buffer[1] == '-' )
            {
                int i = 0;
                while ( i < 15)
                {
                  buffer[i] = buffer[i+2];
                  i++;
                }
                int number2 = atoi( buffer );
                put_string(&serial_port, serial_pin_out, number2);
                step_ncw(number2);
                put_string(&serial_port, serial_pin_out, "negative");
                put_char(&serial_port, serial_pin_out, 10); // new line
                do
                {
                    put_string(&serial_port, serial_pin_out, "-z");
                    number2--;
                }
                while (number2 > 0);
            }

            else
              {
                int i = 0;
                while ( i < 15)
                {
                  buffer[i] = buffer[i+2];
                  i++;
                }
                int number2 = atoi( buffer );
                put_string(&serial_port, serial_pin_out, number2);
                step_nccw(number2);
                put_string(&serial_port, serial_pin_out, "positive");
                put_char(&serial_port, serial_pin_out, 10); // new line
                do
                {
                  put_string(&serial_port, serial_pin_out, "+z");
                  number2--;
                }
                while (number2 > 0);
              }
            }
            put_char(&serial_port, serial_pin_out, 10); // new line
          //if (index == (max_buffer-1))
          memset(buffer, 0, 16);
          index = 0;
    } }