Tom's Life Bits

You've loaded an old revision of the document! If you save it, you will create a new version with this data.

/* ECE 476 Final Project
* Austin S. Lu & Albert Ren
* asl45 awr8
*/

#include <mega32.h>
#include <stdio.h>
#include <stdlib.h> //for ltoa
#include <delay.h>
#asm
    .equ __lcd_port=0x15
#endasm
#include <lcd.h>

//Bruce's definitions
#define begin {
#define end   }

//Define the states for the state machine
#define Command 0
#define DecodeCommand 1
#define Send 2
#define button_release 3
#define hold 4
#define Receive 5
int state = 0;

//Define the commands we support
//MODE 2 iPod Remote Functions
#define play 0x01
#define volup 0x02
#define voldown 0x04
#define skipfwd 0x08
#define skipback 0x10
#define menu 0x40
#define select 0x80

//MODE 4 Advanced Remote
#define type 0x12
#define name 0x14
#define current 0x1e
#define title 0x20
#define artist 0x22
#define album 0x24

//MODE 4 Send Commands
#define Switch 0
#define GetTrack 1
#define UseTrack 2
#define SwitchtoMode2 3
#define SendPlay 4

//Information on the Apple Accessory Protocol can be found at
// http://ipodlinux.org/Apple_Accessory_Protocol

//Here are some variables that we'll need
char mstime = 0;
char header1 = 0xff;
char header2 = 0x55;
char length;
char mode=0x02;
char command[2];
int checksum;
int index = 0;
int debouncecounter = 0;
char lastpress = 0;
char press = 0;
int timeout = 0;
unsigned long currentsong;
int param_length = 0;

//Here are the flags we're using
char validcommand = 0;
char commandtype = 0;
char stopflag = 0;
char releaseflag = 0;
char transmitdone_flag = 0;
char mode4flag = 0;
unsigned char switchmode[16] = {0xff, 0x55, 0x03, 0x00, 0x01, 0x04, 0xF8, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char switchback[16] = {0xff, 0x55, 0x03, 0x00, 0x01, 0x02, 0xFA, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
unsigned char currenttrackcommand[16] = {0xff, 0x55, 0x03, 0x04, 0x00, 0x1E, 0xDB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
int tempchecksum;
unsigned char t_buffer_temp[16];

//For LCD displays
unsigned char lcdbuffer[50];
unsigned int lcdbufferlength = 16;
unsigned int lcdstart = 0;
int lcdtime = 0;

char hold_timer = 0;
int timeoutcounter = 0;
int failurecount = 0;
int mode4sequence = 0;

//variables we use for transmitting
unsigned char t_index;  //current string index
unsigned char t_buffer[16];	//output string
unsigned char t_ready;  //flag for transmit done
unsigned char t_char;  //current character

//RXC ISR variables
unsigned char r_index=0;  //current string index
unsigned char r_buffer[128];	//input string
unsigned char r_ready;  //flag for receive done
unsigned char r_char;  //current character
unsigned char r_checksum; //received checksum
unsigned char prev_char = 0;
unsigned char start_checksum = 0;
unsigned char r_length = 0xF5;

//Functions we use
void initialize(void);
void puts_int(void);
void buttons (void);
void gets_int(void);
void lcd_scroll(void);

//timer 0 overflow ISR
interrupt [TIM0_COMP] void timer0_overflow(void)
begin
    mstime++;
    lcdtime ++;
end

//UART xmit-empty ISR
//TRANSMITS LSB FIRST (Little Endian is stupid!)
//http://en.wikipedia.org/wiki/Serial_port
interrupt [USART_DRE] void uart_send(void)
{
	t_index++;
    t_char = t_buffer[t_index];
    if(t_char == (char)checksum){//at this point, we know what the end is
        UDR = t_char;
        stopflag = 1;
        stopflag = 0;
        UCSRB.5=0; //kill isr
		t_ready=1; //transmit done
		checksum = 0;
    }
    else	{UDR = t_char;}     //send the char
}

//UART character-ready ISR
interrupt [USART_RXC] void uart_rec(void)
begin
		r_char=UDR;    //get a char
		//build the input string
		//iPod takes the form of 0xFF 0x55 Data Checksum
		//We are assuming idle high, so we should check for 0x55 instead
	if((r_char == (char)(r_checksum & 0xff)) && ((r_index-3)==r_length)) {
		r_ready=1;				   	//signal cmd processor
		UCSRB.7=0;   				//stop rec ISR
        start_checksum = 0;
    }

if(start_checksum == 1) {
    	r_checksum = r_checksum - r_char;
    }

if(r_char == 0x55 && prev_char == 0xff) {
    	start_checksum = 1;
        r_checksum = 0x100;
    }

r_buffer[r_index]=r_char;
    if(r_index == 2) //Make the length so!
    	r_length = r_buffer[r_index];

r_index++;
	prev_char = r_char;

end

void main(void)
begin
    int k, temp, ReturnToSender;
    unsigned char songnumber;
//State machine updates every ms for now
    initialize();

while(1)
    begin
        if(lcdtime >= 300)
        {
            lcdtime = 0;
            lcd_scroll();
        }
        if(mstime)
        begin

buttons();
            mstime = 0;
            switch (state)
            begin
                case(Command):

//check if there's a command. If so, we will decode it
                mode4sequence = Switch;
                timeoutcounter = 0;
                failurecount = 0;
                if(validcommand == 1)
                begin
                    validcommand = 0;
                    state = DecodeCommand;
                end
                if((releaseflag == 1) && (validcommand == 0) && (mode == 0x02)) //the button was released
                begin
                	releaseflag = 0;
                    state = button_release;
                end
                break;

case(DecodeCommand):
	                //We must decode the command! If statements galore!
	                t_buffer[0] = header1; //0xff
	                t_buffer[1] = header2; //0x55
                    if((mode == 0x02) || (commandtype == current))
                    {
                       length = 0x03;
                    }
                    else
                    begin
                        length = 7; //Otherwise length is 7 bytes, cause it's a mode 4 command
                    end
	                t_buffer[2] = length;
	                t_buffer[3] = mode;
                    if(mode == 0x04)
                    {
                       mode4flag = 1;
                    }
	                t_buffer[4] = 0x00; //Beginning of command
	                if(commandtype == play)
	                    t_buffer[5] = play;
	                if(commandtype == volup)
	                    t_buffer[5] = volup;
	                if(commandtype == voldown)
	                    t_buffer[5] = voldown;
	                if(commandtype == skipfwd)
	                    t_buffer[5] = skipfwd;
	                if(commandtype == skipback)
	                    t_buffer[5] = skipback;
	                if(commandtype == album)
	                   t_buffer[5] = album;
	                if(commandtype == title)
	                   t_buffer[5] = title;
                    if (commandtype == artist)
	                   t_buffer[5] = artist;

if((mode == 0x04) && (commandtype != current)) //We need to send ipod the current song
	               begin
	                   t_buffer[6] = (currentsong >> 24) & 0xff ; //& with 0xFF cause we're cautious people!
	                   t_buffer[7] = (currentsong >> 16) & 0xff;
	                   t_buffer[8] = (currentsong >> 8) & 0xff;
	                   t_buffer[9] = currentsong & 0xff;
	                   param_length = 4; //Mode 4 and Mode 2 have different lengths
	               end
	                for (index = 2; index < 6 + param_length; index ++) { //for checksum
	                    checksum = checksum + t_buffer[index];

}

checksum = (0x100 - checksum & 0xff);
	                t_buffer[6+param_length] = (char) checksum & 0xff; //as a char */
	                param_length = 0; //We always reset to Mode 2 commands
	                state = Send;
                break;

case(Send):
	                stopflag = 0;
	                timeoutcounter = 0;

if (mode == 0x02)
	                begin
						puts_int();
						commandtype = 0;
						state = Command;
	                end

//Otherwise, the command is going to depend on
                    //switching the iPod into Mode 4 zone
                    //So, first we switch
                    else
                    begin
                    	//Switch to Mode 4
                        if((mode4sequence == Switch))
                        begin
                           for(k=0; k<16; k++)
                           begin
                                //t_buffer_temp holds original mode4 command
                                t_buffer_temp[k] = t_buffer[k];
                                t_buffer[k] = switchmode[k];
                           end
                           tempchecksum = checksum;
                           checksum = 0xF8; //Mode switching checksum
                           //Now send the sucker
                           stopflag = 0;
                           puts_int();
                           state = Receive; //Now we receive a response
                        end

//Now we gotta get the current song
                        if(mode4sequence == GetTrack)
                        begin
                           for(k = 0; k<16; k++)
                           begin
                               //Put in the current command!
                               t_buffer[k] = currenttrackcommand[k];
                           end
                           checksum = 0xDB; //Current track checksum
                           stopflag = 0;
                           puts_int();
                           state = Receive; //Now we receive a response
                        end

//Now we send the command we wanted to send!
                        if(mode4sequence == UseTrack)
                        begin
                           for (k=0; k<16; k++)
                           begin
                               t_buffer[k] = t_buffer_temp[k];
                               //Bring back the real command
                           end
                           //Placing the current song into the command
                           //& with 0xFF cause we're SCARED!
                           t_buffer[6] = (currentsong >> 24) & 0xff;
                           t_buffer[7] = (currentsong >> 16) & 0xff;
                           t_buffer[8] = (currentsong >> 8) & 0xff;
                           t_buffer[9] = currentsong & 0xff;

//recreating the checksum
                           for (index = 2; index < 10; index ++)
                           begin
                               checksum = checksum + t_buffer[index];
                           end
                           checksum = (0x100-checksum)&0xFF;
                           t_buffer[10] = (char)checksum;
                           //Now we transmit the command we wanted!
                           stopflag = 0;
                           puts_int();
                           state = Receive;
                        end
                        //Switch back to mode 2
                        if(mode4sequence == SwitchtoMode2)
                        begin
                           for(k=0; k<16; k++)
                           begin
                               t_buffer[k] = switchback[k];
                           end
                           checksum = 0xFA; //This is the checksum
                           stopflag = 0;
                           puts_int();
                           state = Receive;
                        end
                    end
                break;

case(Receive):
                    //Before we can receive, we need to wait for transmission to complete
                    while(!t_ready){};

if(mode4sequence == SwitchtoMode2)
                    begin
                        //Success!
                        failurecount = 0;
                        mode4sequence = Switch; //Originally Switch
                        state = Command;
                    end

if(mode4sequence == Switch)
                    begin
                        if(timeoutcounter >= 1000) {
                        	mode4sequence = GetTrack;
                        	state = Send;
                            timeoutcounter = 0;
                      	}
                    end

timeoutcounter ++;
                    //Base case: timeoutcounter = 1000 or we failed 5x
                    if(timeoutcounter >= 2000 || failurecount >= 5)
                    begin
                        failurecount = 0;
                        timeoutcounter = 0;
                        if(mode4sequence != SwitchtoMode2)
                        begin
                            //Try to bring it back to initial conditions
                            mode4sequence = SwitchtoMode2;
                            state = Send;
                        end
                        else
                        begin
                            //Looks like all hope is lost.
                            mode4sequence = Switch;
                            state = Command;

end
                    end

//Otherwise, we're still waiting to receive stuff
                    if(r_ready)
                    begin
                        //r_index holds the last thing
                        //What did we receive? Depends on the sequence
                        if(mode4sequence == UseTrack)
                        begin
                            //Check for success
                            if((r_buffer[4] == 0x00) && ((r_buffer[5] != 0) || (r_buffer[5] != 1)))
                            begin

failurecount = 0;
                                //the string is null terminated and starts at r_buffer[6]
                                lcd_clear();
                                lcd_gotoxy(0,0);
                                lcd_putsf("Num ");
                                ltoa(currentsong+1,&songnumber);
                                lcd_puts(&songnumber);
                                lcd_putsf(" - ");
                                //Declare artist, album, or title
                                if(r_buffer[5] == 0x21)
                                    lcd_putsf("Title ");
                                if(r_buffer[5] == 0x23)
                                    lcd_putsf("Artist");
                                if(r_buffer[5] ==0x25)
                                    lcd_putsf("Album ");

lcdbufferlength = r_index - 8;
                                lcdstart = 0;
                                for(k=6; k< 6+lcdbufferlength; k++)
                                {
                                    lcdbuffer[k-6] = r_buffer[k];
                                }
                                lcdbufferlength = lcdbufferlength+1;
                                lcdbuffer[lcdbufferlength-1] = ' ';
                                lcdbuffer[lcdbufferlength] = ' ';
                                lcdbufferlength = lcdbufferlength + 1;
                                state = Send;
                                mode4sequence = SwitchtoMode2;
                            end
                            else
                            begin
                            //Failure!
                                failurecount ++;
                                state = Send;
                            end
                        end
                        if(mode4sequence == GetTrack)
                        begin
                            if((r_buffer[3] == 0x04) && (r_buffer[4]==0x00) && (r_buffer[5] == 0x1f))
                            begin
                                failurecount = 0;
                                currentsong = r_buffer[6];
                                currentsong = (currentsong << 8) | r_buffer[7];
                                currentsong = (currentsong << 8) | r_buffer[8];
                                currentsong = (currentsong << 8) | r_buffer[9];
                                state = Send;
                                mode4sequence = UseTrack;

end
                            else //FAILURE!
                            begin
                                failurecount++;
                                state = Send;
                            end
                        end
                        gets_int(); //Start listening for the Serial TX again!
                    end
                break;

case(button_release): //Send a button release;

t_buffer[0] = header1; //0xff
	                t_buffer[1] = header2; //0x55
	                t_buffer[2] = length;  //0x03 at the moment (not always true)
	                t_buffer[3] = 0x02; //This is the mode we support right now. TWO
	                t_buffer[4] = 0x00; //Beginning of command
                    t_buffer[5] = 0x00; //button release command
                    checksum = 0xFB;
	                t_buffer[6] = 0xFB; //as a char, should be 0xfb here

state= Send;
                break;
            end
        end
    end
end

void buttons(void) {
    press = ~PINA;

if((press != lastpress) && (lastpress == 0)) { // Start debouncing
        debouncecounter++;
        lastpress = press;
    }
    if((press == lastpress) && (lastpress != 0)) //Held button
        debouncecounter ++;
    if ((press != lastpress) && (lastpress != 0)) { //Released button
    	releaseflag = 1;
        validcommand = 0;
        debouncecounter = 0;
        lastpress = 0;
        press = 0;
    }
    if((debouncecounter >= 40) && (lastpress != 0)) { //40ms
        //we have a solid press
        validcommand = 1;
        debouncecounter = -460; //To account for a .5 second holding time, Vol+
        switch(press) {
            case(0x01):
                //Play
                commandtype = play;
                mode = 0x02;
            break;
            case(0x02):
                commandtype = volup;
                mode = 0x02;
            break;
            case(0x04):
                commandtype = voldown;
                mode = 0x02;
            break;
            case(0x08):
                commandtype = skipfwd;
                mode = 0x02;
            break;
            case(0x10):
                commandtype = skipback;
                mode = 0x02;
            break;
            case(0x20):
                commandtype = album;
                mode = 0x04;
            break;
            case(0x40):
                commandtype = title;
                mode = 0x04;
            break;
            case(0x80):
                commandtype = artist;
                mode = 0x04;
            break;
            default:
            	commandtype = 0;
            break;
        }
    }
}

//Set it all up
void initialize(void)
begin
    DDRA = 0x00;	// PORT A is an input - button switches for now
    DDRB = 0xff; //PORTB LED output

PORTB = 0xff; //LEDs off for our sanity

//serial setup for debugging using printf, etc.
    UCSRB = 0x18 ;
    UBRRL = 51 ; //set the oscillator, we need 19200 baud for iPod comm.

//set up timer 0
    OCR0=249;	   			//1 mSec
    TIMSK=2;	   			//turn on timer 0 cmp-match ISR
    TCCR0=0b00001011;		//prescalar to 64  and Clr-on-match

lcd_init(16);      	//initialize the display
    lcd_clear();
    lcd_gotoxy(0,0);
    lcd_putsf("start");

//crank up the ISRs
    #asm
      sei
    #endasm
    gets_int();   //Start listening on the serial port
end

void puts_int(void) {
	t_ready=0;
	t_index=0;
	stopflag =0;
	if (t_buffer[0]>0)
	begin
		putchar(t_buffer[0]);
		UCSRB.5=1;
	end
}

void gets_int(void) {
    r_ready = 0;
    r_index = 0;
    r_length = 0xF5;
    UCSRB.7 = 1;
}

void lcd_scroll(void){
    unsigned char displaybuffer[16];
    int lcd_index;
    lcd_gotoxy(0,1);
    lcd_putsf("                "); //We clear it for scrolling
    lcd_gotoxy(0,1);
    lcd_index=0;
    while(lcd_index<15)
    {
    	displaybuffer[lcd_index] = lcdbuffer[((lcdstart + lcd_index)%lcdbufferlength)];
        if(lcd_index>=lcdbufferlength) //Prevents repeating of small strings
        {
        	displaybuffer[lcd_index] = ' ';
        }
        lcd_index++;
    }
    displaybuffer[15] = 0x00;
    lcd_puts(&displaybuffer[0]);
    if(lcdbufferlength>16) //Prevents scrolling of small strings
	    lcdstart = (lcdstart+1);

}

Edit summary

Note: By editing this page you agree to license your content under the following license: CC Attribution-Noncommercial-Share Alike 4.0 International