interface and application programming

Starting by shearching "http://playground.arduino.cc/Main/RotaryEncoders" for suitable programs for encoder reading and computing. It took several tries using arduino board but I end up finding a good program, with simple enough coding so as to make it easy to manipulate. This program allowed getting data for step counting and rotation direction and give 7200 steps per revolucion with the 2800CT encoder I'm using . It uses Arduino Interrupt, so to set it to ATTiny44 and to my sistem as I had both encoder pins on portA at ATTiny44 and I only have a changing state interrupt routine per port, I had to modify the Arduino's program routines to make them both identical and see if the whole thing worked with only one routine. And it did for Arduino, ATTiny44 needed some more work.

After some research on ATTiny44's changing state interrupt routine and a careful look in Neal's "hello.ftdi.44.echo.interrupt.c “ with the help from ATTiny44's data-sheet, I was able to make the interrupts work but strangely the system only made positive increments, not negative ones. And this is a very summarised account of the process, for in middle I had some “difficulties”; I was getting the whole ASCII code set in the ATTiny44 instead of the number values received in Arduino – got to it because the PUTCHAR command didn't had enough bits to carry the information. I solved it using Neal's strategy of dividing the message in several segments carried by different PUTCHAR commands and reassemble it on the processing. It was then that the “incrementation” problem became evident to me, not before I tried to alter everything I could thought of in the program,I discovered it was due to mixing arduino and C languages, I had iniciated the pins in C and then used the Arduino DIGITAL READ command and for that reason the last command was doing absolutely nothing, and the variables "Aold" and "Bnew" were keeping the value given on the initial declaration, 0 for both of them. As the whole step count is based on a bitwise operation XOR, if the variables don't change values neither does the XOR output thus the motion was in a single direction. Summing it up, everthing was working as planned except... there was no direction control.

Having sorted out the programming issues, there are still some bugs to iron out from the interface design and control as it can be seen in the video by the occasional odd step count value.

//
// hello.ftdi.44.echo.interrupt.c
//
// 115200 baud FTDI character echo, interrupt version
//
// set lfuse to 0x7E for 20 MHz xtal
//
// Neil Gershenfeld
// 12/8/10
//
// (c) Massachusetts Institute of Technology 2010
// Permission granted for experimental and personal use;
// license for commercial sale available from MIT.
//

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.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 8.5 // 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_in1 (1 << PA7)
const int ENCODER1_PIN = 6; // the number of the pushbutton pin
const int ENCODER2_PIN = 7;
const int boton1_PIN = 5;
#define serial_pin_in (1 << PA1)
#define serial_pin_out (1 << PA0)
#define serial_interrupt1 (1 << PCIE0)
#define serial_interrupt_pin1 (1 << PCINT6)
#define serial_interrupt_pin2 (1 << PCINT7)
volatile int encoder0Pos = 0;
unsigned int tmp = 0;
unsigned int Aold = 0;
unsigned int Bnew = 0;
#define max_buffer 25

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();
}

ISR(PCINT0_vect) {
//
//
Bnew=digitalRead(ENCODER1_PIN);
Bnew^Aold ? encoder0Pos--:encoder0Pos++;
Aold=digitalRead(ENCODER2_PIN);

}

int main(void) {
//
// main
//static uint16_t count;
//static uint8_t cycle;



//
// set clock divider to /1
//
CLKPR = (1 << CLKPCE);
CLKPR = (0 << CLKPS3) | (0 << CLKPS2) | (0 << CLKPS1) | (0 << CLKPS0);
//
// initialize output pins
//

set(serial_port, serial_pin_out);
output(serial_direction, serial_pin_out);
//
// set up pin change interrupt on input pin
//
set(GIMSK, serial_interrupt1);

PCMSK0 = 0b11000000;
//set(PCMSK0, serial_interrupt_pin1);
//set(PCMSK0, serial_interrupt_pin2);
sei();

while (1) {
if (tmp != encoder0Pos) {
put_char(&serial_port, serial_pin_out, 1);
char_delay();
put_char(&serial_port, serial_pin_out, 2);
char_delay();
put_char(&serial_port, serial_pin_out, 3);
char_delay();
put_char(&serial_port, serial_pin_out, 4);
char_delay();

put_char(&serial_port, serial_pin_out, (tmp & 255));
char_delay();
put_char(&serial_port, serial_pin_out, ((tmp >> 8) & 255));
char_delay();

tmp = encoder0Pos;
}}}