pc_lnk.elf:     file format elf32-msp430

SYMBOL TABLE:
0000e000 l    d  .text	00000000 .text
00000200 l    d  .data	00000000 .data
00000202 l    d  .bss	00000000 .bss
0000ffe0 l    d  .vectors	00000000 .vectors
00000000 l    d  .stab	00000000 .stab
00000000 l    d  .stabstr	00000000 .stabstr
00000056 l       *ABS*	00000000 DCOCTL
00000057 l       *ABS*	00000000 BCSCTL1
00000058 l       *ABS*	00000000 BCSCTL2
00000053 l       *ABS*	00000000 BCSCTL3
00000128 l       *ABS*	00000000 FCTL1
0000012a l       *ABS*	00000000 FCTL2
0000012c l       *ABS*	00000000 FCTL3
00000054 l       *ABS*	00000000 EPCTL
0000012e l       *ABS*	00000000 TA0IV
00000160 l       *ABS*	00000000 TA0CTL
00000170 l       *ABS*	00000000 TA0R
00000162 l       *ABS*	00000000 TA0CCTL0
00000164 l       *ABS*	00000000 TA0CCTL1
00000172 l       *ABS*	00000000 TA0CCR0
00000174 l       *ABS*	00000000 TA0CCR1
00000166 l       *ABS*	00000000 TA0CCTL2
00000176 l       *ABS*	00000000 TA0CCR2
0000011e l       *ABS*	00000000 TA1IV
00000180 l       *ABS*	00000000 TA1CTL
00000182 l       *ABS*	00000000 TA1CCTL0
00000184 l       *ABS*	00000000 TA1CCTL1
00000190 l       *ABS*	00000000 TAR1
00000192 l       *ABS*	00000000 TA1CCR0
00000194 l       *ABS*	00000000 TA1CCR1
00000020 l       *ABS*	00000000 P1IN
00000021 l       *ABS*	00000000 P1OUT
00000022 l       *ABS*	00000000 P1DIR
00000023 l       *ABS*	00000000 P1IFG
00000024 l       *ABS*	00000000 P1IES
00000025 l       *ABS*	00000000 P1IE
00000026 l       *ABS*	00000000 P1SEL
00000027 l       *ABS*	00000000 P1REN
00000028 l       *ABS*	00000000 P2IN
00000029 l       *ABS*	00000000 P2OUT
0000002a l       *ABS*	00000000 P2DIR
0000002b l       *ABS*	00000000 P2IFG
0000002c l       *ABS*	00000000 P2IES
0000002d l       *ABS*	00000000 P2IE
0000002e l       *ABS*	00000000 P2SEL
0000002f l       *ABS*	00000000 P2REN
00000059 l       *ABS*	00000000 CACTL1
0000005a l       *ABS*	00000000 CACTL2
0000005b l       *ABS*	00000000 CAPD
00000060 l       *ABS*	00000000 UCA0CTL0
00000061 l       *ABS*	00000000 UCA0CTL1
00000062 l       *ABS*	00000000 UCA0BR0
00000063 l       *ABS*	00000000 UCA0BR1
00000064 l       *ABS*	00000000 UCA0MCTL
00000065 l       *ABS*	00000000 UCA0STAT
00000066 l       *ABS*	00000000 UCA0RXBUF
00000067 l       *ABS*	00000000 UCA0TXBUF
0000005d l       *ABS*	00000000 UCA0ABCTL
0000005e l       *ABS*	00000000 UCA0IRTCTL
0000005f l       *ABS*	00000000 UCA0IRRCTL
00000068 l       *ABS*	00000000 UCB0CTL0
00000069 l       *ABS*	00000000 UCB0CTL1
0000006a l       *ABS*	00000000 UCB0BR0
0000006b l       *ABS*	00000000 UCB0BR1
0000006c l       *ABS*	00000000 UCB0I2CIE
0000006d l       *ABS*	00000000 UCB0STAT
0000006e l       *ABS*	00000000 UCB0RXBUF
0000006f l       *ABS*	00000000 UCB0TXBUF
00000118 l       *ABS*	00000000 UCB0I2COA
0000011a l       *ABS*	00000000 UCB0I2CSA
00000048 l       *ABS*	00000000 ADC10DTC0
00000049 l       *ABS*	00000000 ADC10DTC1
0000004a l       *ABS*	00000000 ADC10AE0
000001b0 l       *ABS*	00000000 ADC10CTL0
000001b2 l       *ABS*	00000000 ADC10CTL1
000001b4 l       *ABS*	00000000 ADC10MEM
000001bc l       *ABS*	00000000 ADC10SA
000010c0 l       *ABS*	00000000 TLV_CHECKSUM
000010f6 l       *ABS*	00000000 TLV_DCO_30_TAG
000010f7 l       *ABS*	00000000 TLV_DCO_30_LEN
000010da l       *ABS*	00000000 TLV_ADC12_1_TAG
000010db l       *ABS*	00000000 TLV_ADC12_1_LEN
000010f8 l       *ABS*	00000000 CALDCO_16MHZ
000010f9 l       *ABS*	00000000 CALBC1_16MHZ
000010fa l       *ABS*	00000000 CALDCO_12MHZ
000010fb l       *ABS*	00000000 CALBC1_12MHZ
000010fc l       *ABS*	00000000 CALDCO_8MHZ
000010fd l       *ABS*	00000000 CALBC1_8MHZ
000010fe l       *ABS*	00000000 CALDCO_1MHZ
000010ff l       *ABS*	00000000 CALBC1_1MHZ
00000120 l       *ABS*	00000000 WDTCTL
00000000 l       *ABS*	00000000 IE1
00000002 l       *ABS*	00000000 IFG1
00000001 l       *ABS*	00000000 IE2
00000003 l       *ABS*	00000000 IFG2
00000000 l    df *ABS*	00000000 main.c
0000e39c l       .text	00000000 Letext
00000000 l    df *ABS*	00000000 interchip.c
0000e538 l       .text	00000000 Letext
00000000 l    df *ABS*	00000000 memcmp.c
0000e568 l       .text	00000000 Letext
00000000 l    df *ABS*	00000000 strstr.c
0000e5b6 l       .text	00000000 Letext
00000000 l    df *ABS*	00000000 strncmp.c
0000e5e6 l       .text	00000000 Letext
00000002 g       *ABS*	00000000 __data_size
0000e460 g     F .text	000000d8 send_string
0000e5e8 g       .text	00000000 _etext
00000003 g       *ABS*	00000000 __bss_size
0000e5e6  w      .text	00000000 __stop_progExec__
0000e030 g       .text	00000000 _unexpected_1_
0000e030  w      .text	00000000 vector_ffe0
0000e08c g     F .text	00000056 sys_init
0000e104 g     F .text	0000000e tx_232_char
0000e030  w      .text	00000000 vector_ffec
0000e030  w      .text	00000000 vector_fff0
0000e5e8 g       *ABS*	00000000 __data_load_start
0000e030 g       .text	00000000 __dtors_end
0000e112 g     F .text	00000028 tx_232_str
0000e030  w      .text	00000000 vector_fffc
0000e046 g       .text	00000000 vector_ffe4
0000ffe0 g     O .vectors	00000020 InterruptVectors
0000e39c g     F .text	000000c4 get_string
0000e01c  w      .text	00000000 __do_clear_bss
0000e568 g     F .text	0000004e strstr
00000200 g     O .data	00000002 rxbuflength
0000e0e2 g     F .text	00000022 init_UART_232
0000e5b6 g     F .text	00000030 strncmp
0000e030  w      .text	00000000 vector_ffe2
0000e030  w      .text	00000000 vector_ffe8
0000e034  w      .text	00000000 _unexpected_
0000e030  w      .text	00000000 vector_fffa
0000e538 g     F .text	00000030 memcmp
0000e046 g     F .text	00000018 P1_VEC
0000e000  w      .text	00000000 _reset_vector__
0000e030 g       .text	00000000 __ctors_start
0000e00a  w      .text	00000000 __do_copy_data
00000202 g       .bss	00000000 __bss_start
0000e036 g       .text	00000000 vector_ffee
0000e030  w      .text	00000000 vector_fff4
0000e1b4 g     F .text	000001e8 main
0000e030  w      .text	00000000 vector_fff8
0000e030  w      .text	00000000 vector_fff2
00010000 g       .vectors	00000000 _vectors_end
0000e030  w      .text	00000000 vector_ffe6
0000e05e g     F .text	0000002e delay
0000e036 g     F .text	00000010 RX_VEC
0000e000  w      .text	00000000 __init_stack
0000e030 g       .text	00000000 __dtors_start
0000e030 g       .text	00000000 __ctors_end
00000300 g       *ABS*	00000000 __stack
00000202 g       .data	00000000 _edata
00000205 g       .bss	00000000 _end
00000202 g     O .bss	00000002 flags
0000e030  w      .text	00000000 vector_fff6
0000e004  w      .text	00000000 __low_level_init
0000e02c  w      .text	00000000 __jump_to_main
00000200 g       .data	00000000 __data_start
0000e030  w      .text	00000000 vector_ffea
00000204 g     O .bss	00000001 rx_char


Disassembly of section .text:

0000e000 <__init_stack>:
    e000:	31 40 00 03 	mov	#768,	r1	;#0x0300

0000e004 <__low_level_init>:
    e004:	b2 40 80 5a 	mov	#23168,	&0x0120	;#0x5a80
    e008:	20 01 

0000e00a <__do_copy_data>:
    e00a:	3f 40 02 00 	mov	#2,	r15	;#0x0002
    e00e:	0f 93       	tst	r15		
    e010:	05 24       	jz	$+12     	;abs 0xe01c
    e012:	2f 83       	decd	r15		
    e014:	9f 4f e8 e5 	mov	-6680(r15),512(r15);0xe5e8(r15), 0x0200(r15)
    e018:	00 02 
    e01a:	fb 23       	jnz	$-8      	;abs 0xe012

0000e01c <__do_clear_bss>:
    e01c:	3f 40 03 00 	mov	#3,	r15	;#0x0003
    e020:	0f 93       	tst	r15		
    e022:	04 24       	jz	$+10     	;abs 0xe02c
    e024:	1f 83       	dec	r15		
    e026:	cf 43 02 02 	mov.b	#0,	514(r15);r3 As==00, 0x0202(r15)
    e02a:	fc 23       	jnz	$-6      	;abs 0xe024

0000e02c <__jump_to_main>:
    e02c:	30 40 b4 e1 	br	#0xe1b4	

0000e030 <__ctors_end>:
    e030:	30 40 34 e0 	br	#0xe034	

0000e034 <_unexpected_>:
    e034:	00 13       	reti			

0000e036 <RX_VEC>:
/**
This is called once for every RS232 character that comes in 
*/
interrupt (USCIAB0RX_VECTOR) RX_VEC(void)
   {
   dint(); //no nesting!
    e036:	32 c2       	dint			
   //P1OUT^=LED_GRN;
   rx_char = UCA0RXBUF;
    e038:	d2 42 66 00 	mov.b	&0x0066,&0x0204	
    e03c:	04 02 
   flags |= RXCHAR_RDY;
    e03e:	a2 d3 02 02 	bis	#2,	&0x0202	;r3 As==10
   //LPM3_EXIT;
   eint();
    e042:	32 d2       	eint			
   }
    e044:	00 13       	reti			

0000e046 <P1_VEC>:
These interrupts are caused by external pin events on handshake lines 
*/

// Port 1 interripts : The arbiter is talking to us
interrupt (PORT1_VECTOR) P1_VEC(void)
   {
    e046:	0f 12       	push	r15		
   dint();
    e048:	32 c2       	dint			
   if(P1IFG & ARB_RX) //The arbiter is sending us a string
    e04a:	e2 b3 23 00 	bit.b	#2,	&0x0023	;r3 As==10
    e04e:	02 24       	jz	$+6      	;abs 0xe054
      {
      flags |= ARBITER_RDY;
    e050:	92 d3 02 02 	bis	#1,	&0x0202	;r3 As==01
      //LPM3_EXIT;
      //We need to grab that byte!
      }
   P1IFG=0x00;
    e054:	c2 43 23 00 	mov.b	#0,	&0x0023	;r3 As==00
   eint();
    e058:	32 d2       	eint			
   }
    e05a:	3f 41       	pop	r15		
    e05c:	00 13       	reti			

0000e05e <delay>:
Delay function.
*/
void delay(unsigned int d) 
   {
   int i;
   for (i = 0; i<d; i++) 
    e05e:	0e 43       	clr	r14		
    e060:	0e 9f       	cmp	r15,	r14	
    e062:	13 2c       	jc	$+40     	;abs 0xe08a
      {
      nop();
    e064:	03 43       	nop			
      nop();
    e066:	03 43       	nop			
      nop();
    e068:	03 43       	nop			
      nop();
    e06a:	03 43       	nop			
      nop();
    e06c:	03 43       	nop			
      nop();
    e06e:	03 43       	nop			
      nop();
    e070:	03 43       	nop			
      nop();
    e072:	03 43       	nop			
      nop();
    e074:	03 43       	nop			
      nop();
    e076:	03 43       	nop			
      nop();
    e078:	03 43       	nop			
      nop();
    e07a:	03 43       	nop			
      nop();
    e07c:	03 43       	nop			
      nop();
    e07e:	03 43       	nop			
      nop();
    e080:	03 43       	nop			
      nop();
    e082:	03 43       	nop			
Delay function.
*/
void delay(unsigned int d) 
   {
   int i;
   for (i = 0; i<d; i++) 
    e084:	1e 53       	inc	r14		
    e086:	0e 9f       	cmp	r15,	r14	
    e088:	ed 2b       	jnc	$-36     	;abs 0xe064
      nop();
      nop();
      nop();
      nop();
      }
   }
    e08a:	30 41       	ret			

0000e08c <sys_init>:
Set up the system
*/
void sys_init()
   {

    WDTCTL = WDTCTL_INIT;               //Init watchdog timer
    e08c:	b2 40 80 5a 	mov	#23168,	&0x0120	;#0x5a80
    e090:	20 01 
    
    P1OUT  = P1OUT_INIT;                //Init output data of port1
    e092:	f2 40 05 00 	mov.b	#5,	&0x0021	;#0x0005
    e096:	21 00 
    P2OUT  = P2OUT_INIT;                //Init output data of port2
    e098:	c2 43 29 00 	mov.b	#0,	&0x0029	;r3 As==00
    P3OUT  = P3OUT_INIT;
    e09c:	f2 42 19 00 	mov.b	#8,	&0x0019	;r2 As==11

    P1SEL  = P1SEL_INIT;                //Select port or module -function on port1
    e0a0:	c2 43 26 00 	mov.b	#0,	&0x0026	;r3 As==00
    P2SEL  = P2SEL_INIT;                //Select port or module -function on port2
    e0a4:	c2 43 2e 00 	mov.b	#0,	&0x002e	;r3 As==00
    P3SEL  = P3SEL_INIT;
    e0a8:	f2 40 30 00 	mov.b	#48,	&0x001b	;#0x0030
    e0ac:	1b 00 

    P1DIR  = P1DIR_INIT;                //Init port direction register of port1
    e0ae:	f2 40 f9 ff 	mov.b	#-7,	&0x0022	;#0xfff9
    e0b2:	22 00 
    P2DIR  = P2DIR_INIT;                //Init port direction register of port2
    e0b4:	f2 43 2a 00 	mov.b	#-1,	&0x002a	;r3 As==11
    P3DIR  = P3DIR_INIT;
    e0b8:	f2 40 db ff 	mov.b	#-37,	&0x001a	;#0xffdb
    e0bc:	1a 00 

    P1IES  = P1IES_INIT;                //init port interrupts
    e0be:	e2 43 24 00 	mov.b	#2,	&0x0024	;r3 As==10
    P2IES  = P2IES_INIT;
    e0c2:	c2 43 2c 00 	mov.b	#0,	&0x002c	;r3 As==00

    P1IE   = P1IE_INIT;
    e0c6:	e2 43 25 00 	mov.b	#2,	&0x0025	;r3 As==10
    P2IE   = P2IE_INIT;
    e0ca:	c2 43 2d 00 	mov.b	#0,	&0x002d	;r3 As==00
    
    BCSCTL1 = CALBC1_8MHZ;                    // Set DCO
    e0ce:	d2 42 fd 10 	mov.b	&0x10fd,&0x0057	
    e0d2:	57 00 
    
    DCOCTL = CALDCO_8MHZ;
    e0d4:	d2 42 fc 10 	mov.b	&0x10fc,&0x0056	
    e0d8:	56 00 
    
    BCSCTL3 = LFXT1S_2;
    e0da:	f2 40 20 00 	mov.b	#32,	&0x0053	;#0x0020
    e0de:	53 00 
   }
    e0e0:	30 41       	ret			

0000e0e2 <init_UART_232>:


void init_UART_232()
   {
   UCA0CTL1 |= UCSWRST;  //halt state machine
    e0e2:	d2 d3 61 00 	bis.b	#1,	&0x0061	;r3 As==01
   UCA0CTL1 = UCSSEL_2;                      // SMCLK
    e0e6:	f2 40 80 ff 	mov.b	#-128,	&0x0061	;#0xff80
    e0ea:	61 00 
   //UCA0BR1 = 0x3;
   
   //UCA0BR0 = 0x82;                           // 9600 from 16Mhz
   //UCA0BR1 = 0x6;
   
   UCA0BR0=0x45; UCA0BR1=0x00; //9600 from 8
    e0ec:	f2 40 45 00 	mov.b	#69,	&0x0062	;#0x0045
    e0f0:	62 00 
    e0f2:	c2 43 63 00 	mov.b	#0,	&0x0063	;r3 As==00
   
   UCA0MCTL = UCBRS_2;                       
    e0f6:	e2 42 64 00 	mov.b	#4,	&0x0064	;r2 As==10
   UCA0CTL1 &= ~UCSWRST;                     // **Initialize USCI state machine**
    e0fa:	d2 c3 61 00 	bic.b	#1,	&0x0061	;r3 As==01
   IE2 |= UCA0RXIE;
    e0fe:	d2 d3 01 00 	bis.b	#1,	&0x0001	;r3 As==01
   }
    e102:	30 41       	ret			

0000e104 <tx_232_char>:
   
void tx_232_char(char c)
   {  
    e104:	4e 4f       	mov.b	r15,	r14	
   while ((IFG2 & UCA0TXIFG) == 0); // USART0 TX buffer ready?
    e106:	e2 b3 03 00 	bit.b	#2,	&0x0003	;r3 As==10
    e10a:	fd 27       	jz	$-4      	;abs 0xe106
   UCA0TXBUF = c;
    e10c:	c2 4e 67 00 	mov.b	r14,	&0x0067	
   }
    e110:	30 41       	ret			

0000e112 <tx_232_str>:

void tx_232_str(char *str, unsigned char length)
   {
    e112:	0b 12       	push	r11		
    e114:	0a 12       	push	r10		
    e116:	09 12       	push	r9		
    e118:	09 4f       	mov	r15,	r9	
    e11a:	4a 4e       	mov.b	r14,	r10	
   unsigned char i;
   //int length=strlen(str);
   //tx_232_char(0x00); //sync on this
   for(i=0; i<length; i++)
    e11c:	4b 43       	clr.b	r11		
    e11e:	4b 9e       	cmp.b	r14,	r11	
    e120:	08 2c       	jc	$+18     	;abs 0xe132
      tx_232_char(str[i]);
    e122:	4f 4b       	mov.b	r11,	r15	
    e124:	0f 59       	add	r9,	r15	
    e126:	6f 4f       	mov.b	@r15,	r15	
    e128:	b0 12 04 e1 	call	#0xe104	
void tx_232_str(char *str, unsigned char length)
   {
   unsigned char i;
   //int length=strlen(str);
   //tx_232_char(0x00); //sync on this
   for(i=0; i<length; i++)
    e12c:	5b 53       	inc.b	r11		
    e12e:	4b 9a       	cmp.b	r10,	r11	
    e130:	f8 2b       	jnc	$-14     	;abs 0xe122
      tx_232_char(str[i]);
   }
    e132:	39 41       	pop	r9		
    e134:	3a 41       	pop	r10		
    e136:	3b 41       	pop	r11		
    e138:	30 41       	ret			
    e13a:	1b 5b 33 32 	add	12851(r11),r11	;0x3233(r11)
    e13e:	6d 28       	jnc	$+220    	;abs 0xe21a
    e140:	31 31       	jn	$+612    	;abs 0xe3a4
    e142:	35 2e       	jc	$-916    	;abs 0xddae
    e144:	32 2d       	jc	$+614    	;abs 0xe3aa
    e146:	38 2d       	jc	$+626    	;abs 0xe3b8
    e148:	31 20       	jnz	$+100    	;abs 0xe1ac
    e14a:	58 4f 4e 2f 	mov.b	12110(r15),r8	;0x2f4e(r15)
    e14e:	58 4f 46 46 	mov.b	17990(r15),r8	;0x4646(r15)
    e152:	29 20       	jnz	$+84     	;abs 0xe1a6
    e154:	45 43       	clr.b	r5		
    e156:	48 4f       	mov.b	r15,	r8	
    e158:	20 4f       	br	@r15		
    e15a:	46 46       	mov.b	r6,	r6	
    e15c:	0d 0a       	.word	0x0a0d;	????	
    e15e:	00 47       	br	r7		
    e160:	69 6e       	addc.b	@r14,	r9	
    e162:	67 65       	addc.b	@r5,	r7	
    e164:	72 20       	jnz	$+230    	;abs 0xe24a
    e166:	54 65 72 6d 	addc.b	28018(r5),r4	;0x6d72(r5)
    e16a:	69 6e       	addc.b	@r14,	r9	
    e16c:	61 6c       	addc.b	@r12,	r1	
    e16e:	20 52       	add	#4,	r0	;r2 As==10
    e170:	65 61       	addc.b	@r1,	r5	
    e172:	64 79       	subc.b	@r9,	r4	
    e174:	0d 0a       	.word	0x0a0d;	????	
    e176:	1b 5b 33 30 	add	12339(r11),r11	;0x3033(r11)
    e17a:	6d 00       	.word	0x006d;	????	
    e17c:	50 43       	br	#1		;r3 As==01
    e17e:	4c 00       	.word	0x004c;	????	
    e180:	72 65       	addc.b	@r5+,	r2	
    e182:	62 6f       	addc.b	@r15,	r2	
    e184:	6f 74       	subc.b	@r4,	r15	
    e186:	00 65       	addc	r5,	r0	
    e188:	63 68       	.word	0x6863;	????	Illegal as 2-op instr
    e18a:	6f 20       	jnz	$+224    	;abs 0xe26a
    e18c:	6f 6e       	addc.b	@r14,	r15	
    e18e:	00 45       	br	r5		
    e190:	63 68       	.word	0x6863;	????	Illegal as 2-op instr
    e192:	6f 20       	jnz	$+224    	;abs 0xe272
    e194:	69 73       	subc.b	#2,	r9	;r3 As==10
    e196:	20 4f       	br	@r15		
    e198:	4e 0d       	.word	0x0d4e;	????	
    e19a:	0a 00       	.word	0x000a;	????	
    e19c:	65 63       	addc.b	#2,	r5	;r3 As==10
    e19e:	68 6f       	addc.b	@r15,	r8	
    e1a0:	20 6f       	addc	@r15,	r0	
    e1a2:	66 66       	addc.b	@r6,	r6	
    e1a4:	00 45       	br	r5		
    e1a6:	63 68       	.word	0x6863;	????	Illegal as 2-op instr
    e1a8:	6f 20       	jnz	$+224    	;abs 0xe288
    e1aa:	69 73       	subc.b	#2,	r9	;r3 As==10
    e1ac:	20 4f       	br	@r15		
    e1ae:	46 46       	mov.b	r6,	r6	
    e1b0:	0d 0a       	.word	0x0a0d;	????	
	...

0000e1b4 <main>:
   
/**
Main function.
*/
int main(void) 
   {
    e1b4:	31 40 60 02 	mov	#608,	r1	;#0x0260
   #define BUFFER_SIZE 80
   unsigned char interchip[BUFFER_SIZE],rxbuf[BUFFER_SIZE];
   unsigned int loop,length=0,rxbuflength=0, echo=0;
    e1b8:	0b 43       	clr	r11		
    e1ba:	09 43       	clr	r9		
   
   
   sys_init();
    e1bc:	b0 12 8c e0 	call	#0xe08c	
   P3OUT &= ~LED_OFF; //turn LED on
    e1c0:	f2 c2 19 00 	bic.b	#8,	&0x0019	;r2 As==11
   memset(interchip, 0, BUFFER_SIZE-1);
    e1c4:	3e 40 4f 00 	mov	#79,	r14	;#0x004f
    e1c8:	0f 41       	mov	r1,	r15	
    e1ca:	cf 43 00 00 	mov.b	#0,	0(r15)	;r3 As==00, 0x0000(r15)
    e1ce:	1f 53       	inc	r15		
    e1d0:	1e 83       	dec	r14		
    e1d2:	fb 23       	jnz	$-8      	;abs 0xe1ca
   memset(rxbuf, 0, BUFFER_SIZE-1); 
    e1d4:	3e 40 4f 00 	mov	#79,	r14	;#0x004f
    e1d8:	0a 41       	mov	r1,	r10	
    e1da:	3a 50 50 00 	add	#80,	r10	;#0x0050
    e1de:	0f 4a       	mov	r10,	r15	
    e1e0:	cf 43 00 00 	mov.b	#0,	0(r15)	;r3 As==00, 0x0000(r15)
    e1e4:	1f 53       	inc	r15		
    e1e6:	1e 83       	dec	r14		
    e1e8:	fb 23       	jnz	$-8      	;abs 0xe1e0
   

   
   init_UART_232();
    e1ea:	b0 12 e2 e0 	call	#0xe0e2	

   delay(0x00FF);
    e1ee:	3f 40 ff 00 	mov	#255,	r15	;#0x00ff
    e1f2:	b0 12 5e e0 	call	#0xe05e	
   delay(0xFFFF);
    e1f6:	3f 43       	mov	#-1,	r15	;r3 As==11
    e1f8:	b0 12 5e e0 	call	#0xe05e	
   
   delay(0xFFFF);
    e1fc:	3f 43       	mov	#-1,	r15	;r3 As==11
    e1fe:	b0 12 5e e0 	call	#0xe05e	
   
   
   tx_232_char('\r'); //XON resumes data transfers
    e202:	7f 40 0d 00 	mov.b	#13,	r15	;#0x000d
    e206:	b0 12 04 e1 	call	#0xe104	
   tx_232_char('\n'); //XON resumes data transfers
    e20a:	7f 40 0a 00 	mov.b	#10,	r15	;#0x000a
    e20e:	b0 12 04 e1 	call	#0xe104	
   
   tx_232_str("\e[32m(115.2-8-1 XON/XOFF) ECHO OFF\r\n", 36); //Send the byte out
    e212:	7e 40 24 00 	mov.b	#36,	r14	;#0x0024
    e216:	3f 40 3a e1 	mov	#-7878,	r15	;#0xe13a
    e21a:	b0 12 12 e1 	call	#0xe112	
   tx_232_str("Ginger Terminal Ready\r\n\e[30m", 28); //Send the byte out   
    e21e:	7e 40 1c 00 	mov.b	#28,	r14	;#0x001c
    e222:	3f 40 5f e1 	mov	#-7841,	r15	;#0xe15f
    e226:	b0 12 12 e1 	call	#0xe112	
   
   flags=0;
    e22a:	82 43 02 02 	mov	#0,	&0x0202	;r3 As==00
   P2IFG=0x00;
    e22e:	c2 43 2b 00 	mov.b	#0,	&0x002b	;r3 As==00
   P1IFG=0x00;
    e232:	c2 43 23 00 	mov.b	#0,	&0x0023	;r3 As==00
   
   P3OUT |= LED_OFF; //turn LED off;
    e236:	f2 d2 19 00 	bis.b	#8,	&0x0019	;r2 As==11
   eint();
    e23a:	32 d2       	eint			
   tx_232_char(XON); //XON resumes data transfers
    e23c:	7f 40 11 00 	mov.b	#17,	r15	;#0x0011
    e240:	b0 12 04 e1 	call	#0xe104	
   
   while (1)            //main loop, never ends...
      {
      loop = 0;
      
      if(flags & ARBITER_RDY) //Arbiter has something to say
    e244:	92 b3 02 02 	bit	#1,	&0x0202	;r3 As==01
    e248:	25 24       	jz	$+76     	;abs 0xe294
         {         
         tx_232_char(XOFF); //XOFF stops data transfer momentarily
    e24a:	7f 40 13 00 	mov.b	#19,	r15	;#0x0013
    e24e:	b0 12 04 e1 	call	#0xe104	
         dint();         
    e252:	32 c2       	dint			
         loop = 1;
         P3OUT &= ~LED_OFF; //turn on LED
    e254:	f2 c2 19 00 	bic.b	#8,	&0x0019	;r2 As==11
         //tx_232_char(0x0); //sync bit
         
         
         //memset(rxbuf, 0, BUFFER_SIZE-1); 02-25-2010
         length = get_string(rxbuf);
    e258:	0f 4a       	mov	r10,	r15	
    e25a:	b0 12 9c e3 	call	#0xe39c	
    e25e:	4e 4f       	mov.b	r15,	r14	
    e260:	8e 11       	sxt	r14		
         P1IFG &= ~ARB_RX;
    e262:	e2 c3 23 00 	bic.b	#2,	&0x0023	;r3 As==10
         flags &= ~ARBITER_RDY;
    e266:	92 c3 02 02 	bic	#1,	&0x0202	;r3 As==01
         
         //delay(0xF);               //THIS DELAY IS OPTIMAZATION SENSITIVE! ADJUST ACCORDINGLY IF COMMUNICATIONS BREAKS DOWN (make longer)
         //send_byte(0x01);
         
         rxbuf[length-1] = '\r';
    e26a:	0f 41       	mov	r1,	r15	
    e26c:	0f 5e       	add	r14,	r15	
    e26e:	ff 40 0d 00 	mov.b	#13,	79(r15)	;#0x000d, 0x004f(r15)
    e272:	4f 00 
         rxbuf[length] = '\n';
    e274:	0f 4e       	mov	r14,	r15	
    e276:	0f 51       	add	r1,	r15	
    e278:	ff 40 0a 00 	mov.b	#10,	80(r15)	;#0x000a, 0x0050(r15)
    e27c:	50 00 
         length += 1;
    e27e:	1e 53       	inc	r14		
         tx_232_str(rxbuf, length); //Send the string out
    e280:	0f 4a       	mov	r10,	r15	
    e282:	b0 12 12 e1 	call	#0xe112	
          
         
         eint();
    e286:	32 d2       	eint			
         tx_232_char(XON); //XON resumes data transfers
    e288:	7f 40 11 00 	mov.b	#17,	r15	;#0x0011
    e28c:	b0 12 04 e1 	call	#0xe104	
         P3OUT |= LED_OFF; //turn LED off;         
    e290:	f2 d2 19 00 	bis.b	#8,	&0x0019	;r2 As==11
         }
         
      if(flags & RXSTRING_RDY)
    e294:	a2 b2 02 02 	bit	#4,	&0x0202	;r2 As==10
    e298:	2b 24       	jz	$+88     	;abs 0xe2f0
         {
         tx_232_char(XOFF); //XOFF stops data transfer momentarily
    e29a:	7f 40 13 00 	mov.b	#19,	r15	;#0x0013
    e29e:	b0 12 04 e1 	call	#0xe104	
         dint();
    e2a2:	32 c2       	dint			
         loop = 1;
         flags &= ~RXSTRING_RDY;
    e2a4:	a2 c2 02 02 	bic	#4,	&0x0202	;r2 As==10
         //tx_232_str("\r\n",2); //newline
         if(!memcmp("PCL",interchip,3))
    e2a8:	3d 40 03 00 	mov	#3,	r13	;#0x0003
    e2ac:	0e 41       	mov	r1,	r14	
    e2ae:	3f 40 7c e1 	mov	#-7812,	r15	;#0xe17c
    e2b2:	b0 12 38 e5 	call	#0xe538	
    e2b6:	0f 93       	tst	r15		
    e2b8:	64 20       	jnz	$+202    	;abs 0xe382
            {
            if(strstr(interchip, "reboot") != NULL)
    e2ba:	3e 40 80 e1 	mov	#-7808,	r14	;#0xe180
    e2be:	0f 41       	mov	r1,	r15	
    e2c0:	b0 12 68 e5 	call	#0xe568	
    e2c4:	0f 93       	tst	r15		
    e2c6:	59 20       	jnz	$+180    	;abs 0xe37a
               {
               WDTCTL = WDTCNTCL|WDTPW;
               while(1); //reboot in 32ms
               }
            else if(strstr(interchip, "echo on") != NULL)
    e2c8:	3e 40 87 e1 	mov	#-7801,	r14	;#0xe187
    e2cc:	0f 41       	mov	r1,	r15	
    e2ce:	b0 12 68 e5 	call	#0xe568	
    e2d2:	0f 93       	tst	r15		
    e2d4:	43 24       	jz	$+136    	;abs 0xe35c
               {               
               tx_232_str("Echo is ON\r\n", 12); //Send the byte out
    e2d6:	7e 40 0c 00 	mov.b	#12,	r14	;#0x000c
    e2da:	3f 40 8f e1 	mov	#-7793,	r15	;#0xe18f
    e2de:	b0 12 12 e1 	call	#0xe112	
               echo = 1;
    e2e2:	19 43       	mov	#1,	r9	;r3 As==01
            send_string(interchip,rxbuflength+1);
            P1IFG &= ~ARB_RX; //usage of the interchip routine soils the interrupt
            }
         //memset(interchip, 0, 63);
         
         rxbuflength = 0;         
    e2e4:	0b 43       	clr	r11		
        
         eint();
    e2e6:	32 d2       	eint			
         tx_232_char(XON); //XON resumes data transfers
    e2e8:	7f 40 11 00 	mov.b	#17,	r15	;#0x0011
    e2ec:	b0 12 04 e1 	call	#0xe104	
         }
      if(flags & RXCHAR_RDY)
    e2f0:	a2 b3 02 02 	bit	#2,	&0x0202	;r3 As==10
    e2f4:	a7 27       	jz	$-176    	;abs 0xe244
         {         
         dint();
    e2f6:	32 c2       	dint			
         loop = 1;
         flags &= ~RXCHAR_RDY;
    e2f8:	a2 c3 02 02 	bic	#2,	&0x0202	;r3 As==10
         if(rx_char == '\b')  //backspaces are dumb
    e2fc:	5e 42 04 02 	mov.b	&0x0204,r14	
    e300:	7e 92       	cmp.b	#8,	r14	;r2 As==11
    e302:	1d 24       	jz	$+60     	;abs 0xe33e
            if(rxbuflength > 0)
               rxbuflength--;            
            tx_232_char('\b');
            tx_232_char(' ');
            }
         else if(rx_char == '\r');  //don't count a return in the buffer!
    e304:	7e 90 0d 00 	cmp.b	#13,	r14	;#0x000d
    e308:	05 24       	jz	$+12     	;abs 0xe314
         else                //Normal characters are nice
            {
            interchip[rxbuflength]=rx_char;
    e30a:	0f 4b       	mov	r11,	r15	
    e30c:	0f 51       	add	r1,	r15	
    e30e:	cf 4e 00 00 	mov.b	r14,	0(r15)	;0x0000(r15)
            rxbuflength++;
    e312:	1b 53       	inc	r11		
            }
         
         if(rxbuflength > 60 || (rx_char == '\r' && rxbuflength > 0)) //Did they press enter? packet too long?
    e314:	3b 90 3d 00 	cmp	#61,	r11	;#0x003d
    e318:	0f 2c       	jc	$+32     	;abs 0xe338
    e31a:	f2 90 0d 00 	cmp.b	#13,	&0x0204	;#0x000d
    e31e:	04 02 
    e320:	09 24       	jz	$+20     	;abs 0xe334
           //tx_232_char(XOFF); //XOFF stops data transfer momentarily
            flags |= RXSTRING_RDY;  //Send the string out         
            }         
         
         //option to turn on local echo for RS232 use?
         if(echo == 1)
    e322:	19 93       	cmp	#1,	r9	;r3 As==01
    e324:	02 24       	jz	$+6      	;abs 0xe32a
            tx_232_char(rx_char);                   //local echo for serial port
         eint();
    e326:	32 d2       	eint			
         }
      if(loop == 0)
    e328:	8d 3f       	jmp	$-228    	;abs 0xe244
            flags |= RXSTRING_RDY;  //Send the string out         
            }         
         
         //option to turn on local echo for RS232 use?
         if(echo == 1)
            tx_232_char(rx_char);                   //local echo for serial port
    e32a:	5f 42 04 02 	mov.b	&0x0204,r15	
    e32e:	b0 12 04 e1 	call	#0xe104	
    e332:	f9 3f       	jmp	$-12     	;abs 0xe326
    e334:	0b 93       	tst	r11		
    e336:	f5 27       	jz	$-20     	;abs 0xe322
            }
         
         if(rxbuflength > 60 || (rx_char == '\r' && rxbuflength > 0)) //Did they press enter? packet too long?
            {         
           //tx_232_char(XOFF); //XOFF stops data transfer momentarily
            flags |= RXSTRING_RDY;  //Send the string out         
    e338:	a2 d2 02 02 	bis	#4,	&0x0202	;r2 As==10
    e33c:	f2 3f       	jmp	$-26     	;abs 0xe322
         dint();
         loop = 1;
         flags &= ~RXCHAR_RDY;
         if(rx_char == '\b')  //backspaces are dumb
            {
            interchip[rxbuflength]=0;
    e33e:	0f 4b       	mov	r11,	r15	
    e340:	0f 51       	add	r1,	r15	
    e342:	cf 43 00 00 	mov.b	#0,	0(r15)	;r3 As==00, 0x0000(r15)
            if(rxbuflength > 0)
    e346:	0b 93       	tst	r11		
    e348:	01 24       	jz	$+4      	;abs 0xe34c
               rxbuflength--;            
    e34a:	3b 53       	add	#-1,	r11	;r3 As==11
            tx_232_char('\b');
    e34c:	7f 42       	mov.b	#8,	r15	;r2 As==11
    e34e:	b0 12 04 e1 	call	#0xe104	
            tx_232_char(' ');
    e352:	7f 40 20 00 	mov.b	#32,	r15	;#0x0020
    e356:	b0 12 04 e1 	call	#0xe104	
    e35a:	dc 3f       	jmp	$-70     	;abs 0xe314
            else if(strstr(interchip, "echo on") != NULL)
               {               
               tx_232_str("Echo is ON\r\n", 12); //Send the byte out
               echo = 1;
               }
            else if(strstr(interchip, "echo off") != NULL)
    e35c:	3e 40 9c e1 	mov	#-7780,	r14	;#0xe19c
    e360:	0f 41       	mov	r1,	r15	
    e362:	b0 12 68 e5 	call	#0xe568	
    e366:	0f 93       	tst	r15		
    e368:	bd 27       	jz	$-132    	;abs 0xe2e4
               {               
               tx_232_str("Echo is OFF\r\n", 13); //Send the byte out              
    e36a:	7e 40 0d 00 	mov.b	#13,	r14	;#0x000d
    e36e:	3f 40 a5 e1 	mov	#-7771,	r15	;#0xe1a5
    e372:	b0 12 12 e1 	call	#0xe112	
               echo = 0;               
    e376:	09 43       	clr	r9		
    e378:	b5 3f       	jmp	$-148    	;abs 0xe2e4
         //tx_232_str("\r\n",2); //newline
         if(!memcmp("PCL",interchip,3))
            {
            if(strstr(interchip, "reboot") != NULL)
               {
               WDTCTL = WDTCNTCL|WDTPW;
    e37a:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e37e:	20 01 
               while(1); //reboot in 32ms
    e380:	ff 3f       	jmp	$+0      	;abs 0xe380
               echo = 0;               
               }   
            }
         else
            {
            send_string(interchip,rxbuflength+1);
    e382:	4f 4b       	mov.b	r11,	r15	
    e384:	5f 53       	inc.b	r15		
    e386:	4e 4f       	mov.b	r15,	r14	
    e388:	0f 41       	mov	r1,	r15	
    e38a:	b0 12 60 e4 	call	#0xe460	
            P1IFG &= ~ARB_RX; //usage of the interchip routine soils the interrupt
    e38e:	e2 c3 23 00 	bic.b	#2,	&0x0023	;r3 As==10
    e392:	a8 3f       	jmp	$-174    	;abs 0xe2e4
         
         }
         //LPM3; //(going to sleep ruins the DCO calibration!)         //Go to sleep, when we wake, something has happened
         
      }
   }
    e394:	31 50 a0 00 	add	#160,	r1	;#0x00a0
    e398:	30 40 e6 e5 	br	#0xe5e6	

0000e39c <get_string>:
#define INTERCHIP_TIMEOUT 500000


/////////////////////////////////////////////////////////////////////////////////////////////////
char get_string(char *str)
{
    e39c:	0b 12       	push	r11		
    e39e:	0a 12       	push	r10		
    e3a0:	09 12       	push	r9		
    e3a2:	09 4f       	mov	r15,	r9	
unsigned int pos,i,length;
unsigned char byte=0;
    e3a4:	4d 43       	clr.b	r13		
unsigned long timeout=0;
    e3a6:	0b 43       	clr	r11		
    e3a8:	0c 43       	clr	r12		

P1DIR &= ~ARB_CLK; //make sure the clock is an INPUT
    e3aa:	e2 c2 22 00 	bic.b	#4,	&0x0022	;r2 As==10

while((P1IN & ARB_RX) == ARB_RX)   //Does the chip still want to talk to us? A timeout wouldn't be bad
    e3ae:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e3b2:	0b 24       	jz	$+24     	;abs 0xe3ca
   {
   timeout++;
    e3b4:	1b 53       	inc	r11		
    e3b6:	0c 63       	adc	r12		
   if(timeout == INTERCHIP_TIMEOUT) //about 1 second or so
    e3b8:	3b 90 20 a1 	cmp	#-24288,r11	;#0xa120
    e3bc:	03 20       	jnz	$+8      	;abs 0xe3c4
    e3be:	3c 90 07 00 	cmp	#7,	r12	;#0x0007
    e3c2:	3f 24       	jz	$+128    	;abs 0xe442
    e3c4:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e3c8:	f5 23       	jnz	$-20     	;abs 0xe3b4
      WDTCTL = WDTCNTCL|WDTPW; //well, the chip is taking a long time so reset ok
      while(1);
      }
   }

P1OUT &= ~ARB_TX; //lower the TX line to aknowledge start of reception
    e3ca:	d2 c3 21 00 	bic.b	#1,	&0x0021	;r3 As==01

WDTCTL = WDTCNTCL|WDTPW;   
    e3ce:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e3d2:	20 01 
for(i=BYTE_LENGTH; i>0; i--)
    e3d4:	3e 42       	mov	#8,	r14	;r2 As==11
   {   
   //P3OUT ^= LED_GRN;
   //delay(0xF);
   byte = byte << 1;
    e3d6:	4d 5d       	rla.b	r13		
   while((P1IN & ARB_CLK) == ARB_CLK);
    e3d8:	e2 b2 20 00 	bit.b	#4,	&0x0020	;r2 As==10
    e3dc:	fd 23       	jnz	$-4      	;abs 0xe3d8
   byte |= ((P1IN & ARB_RX) >> 1);
    e3de:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e3e2:	4f 43       	clr.b	r15		
    e3e4:	4f 63       	adc.b	r15		
    e3e6:	4d df       	bis.b	r15,	r13	
   P1OUT |= ARB_TX; //set the TX line high to show that we have the bit
    e3e8:	d2 d3 21 00 	bis.b	#1,	&0x0021	;r3 As==01
   while((P1IN & ARB_CLK) == 0);
    e3ec:	e2 b2 20 00 	bit.b	#4,	&0x0020	;r2 As==10
    e3f0:	fd 27       	jz	$-4      	;abs 0xe3ec
   P1OUT &= ~ARB_TX; //clear the TX line high to show that we are ready for the next bit      
    e3f2:	d2 c3 21 00 	bic.b	#1,	&0x0021	;r3 As==01
   }

P1OUT &= ~ARB_TX; //lower the TX line to aknowledge start of reception

WDTCTL = WDTCNTCL|WDTPW;   
for(i=BYTE_LENGTH; i>0; i--)
    e3f6:	3e 53       	add	#-1,	r14	;r3 As==11
    e3f8:	ee 23       	jnz	$-34     	;abs 0xe3d6
   P1OUT |= ARB_TX; //set the TX line high to show that we have the bit
   while((P1IN & ARB_CLK) == 0);
   P1OUT &= ~ARB_TX; //clear the TX line high to show that we are ready for the next bit      
   }
   
length = byte;
    e3fa:	4a 4d       	mov.b	r13,	r10	

for(pos=0; pos < length-1; pos++)
    e3fc:	0c 43       	clr	r12		
    e3fe:	0b 4a       	mov	r10,	r11	
    e400:	3b 53       	add	#-1,	r11	;r3 As==11
    e402:	0c 9b       	cmp	r11,	r12	
    e404:	22 2c       	jc	$+70     	;abs 0xe44a
   {
   WDTCTL = WDTCNTCL|WDTPW;
    e406:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e40a:	20 01 
   for(i=BYTE_LENGTH; i>0; i--)
    e40c:	3e 42       	mov	#8,	r14	;r2 As==11
      {
      byte = byte << 1;
    e40e:	4d 5d       	rla.b	r13		
      while((P1IN & ARB_CLK) == ARB_CLK);
    e410:	e2 b2 20 00 	bit.b	#4,	&0x0020	;r2 As==10
    e414:	fd 23       	jnz	$-4      	;abs 0xe410
      byte |= ((P1IN & ARB_RX) >> 1);
    e416:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e41a:	4f 43       	clr.b	r15		
    e41c:	4f 63       	adc.b	r15		
    e41e:	4d df       	bis.b	r15,	r13	
      P1OUT |= ARB_TX; //set the TX line high to show that we have the bit
    e420:	d2 d3 21 00 	bis.b	#1,	&0x0021	;r3 As==01
      while((P1IN & ARB_CLK) == 0);
    e424:	e2 b2 20 00 	bit.b	#4,	&0x0020	;r2 As==10
    e428:	fd 27       	jz	$-4      	;abs 0xe424
      P1OUT &= ~ARB_TX; //clear the TX line high to show that we are ready for the next bit      
    e42a:	d2 c3 21 00 	bic.b	#1,	&0x0021	;r3 As==01
length = byte;

for(pos=0; pos < length-1; pos++)
   {
   WDTCTL = WDTCNTCL|WDTPW;
   for(i=BYTE_LENGTH; i>0; i--)
    e42e:	3e 53       	add	#-1,	r14	;r3 As==11
    e430:	ee 23       	jnz	$-34     	;abs 0xe40e
      byte |= ((P1IN & ARB_RX) >> 1);
      P1OUT |= ARB_TX; //set the TX line high to show that we have the bit
      while((P1IN & ARB_CLK) == 0);
      P1OUT &= ~ARB_TX; //clear the TX line high to show that we are ready for the next bit      
      }
   str[pos] = byte;
    e432:	0f 49       	mov	r9,	r15	
    e434:	0f 5c       	add	r12,	r15	
    e436:	cf 4d 00 00 	mov.b	r13,	0(r15)	;0x0000(r15)
   P1OUT &= ~ARB_TX; //clear the TX line high to show that we are ready for the next bit      
   }
   
length = byte;

for(pos=0; pos < length-1; pos++)
    e43a:	1c 53       	inc	r12		
    e43c:	0c 9b       	cmp	r11,	r12	
    e43e:	e3 2b       	jnc	$-56     	;abs 0xe406
    e440:	04 3c       	jmp	$+10     	;abs 0xe44a
while((P1IN & ARB_RX) == ARB_RX)   //Does the chip still want to talk to us? A timeout wouldn't be bad
   {
   timeout++;
   if(timeout == INTERCHIP_TIMEOUT) //about 1 second or so
      {
      WDTCTL = WDTCNTCL|WDTPW; //well, the chip is taking a long time so reset ok
    e442:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e446:	20 01 
      while(1);
    e448:	ff 3f       	jmp	$+0      	;abs 0xe448
      while((P1IN & ARB_CLK) == 0);
      P1OUT &= ~ARB_TX; //clear the TX line high to show that we are ready for the next bit      
      }
   str[pos] = byte;
   }
P1OUT |= ARB_TX;
    e44a:	d2 d3 21 00 	bis.b	#1,	&0x0021	;r3 As==01

WDTCTL = WDTHOLD|WDTPW;
    e44e:	b2 40 80 5a 	mov	#23168,	&0x0120	;#0x5a80
    e452:	20 01 
return length;   
    e454:	4f 4a       	mov.b	r10,	r15	
    e456:	8f 11       	sxt	r15		
}
    e458:	39 41       	pop	r9		
    e45a:	3a 41       	pop	r10		
    e45c:	3b 41       	pop	r11		
    e45e:	30 41       	ret			

0000e460 <send_string>:

/////////////////////////////////////////////////////////////////////////////////////////////////
char send_string( char *str, unsigned char length)
{
    e460:	0b 12       	push	r11		
    e462:	0a 12       	push	r10		
    e464:	0a 4f       	mov	r15,	r10	
unsigned int pos,i;
unsigned char byte=0;
unsigned long timeout=0;
    e466:	0c 43       	clr	r12		
    e468:	0d 43       	clr	r13		

//first see if the chip wants to talk to us first so we don't fight
if((P1IN & ARB_RX) == 0)
    e46a:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e46e:	02 20       	jnz	$+6      	;abs 0xe474
   return false;
    e470:	0f 43       	clr	r15		
    e472:	5f 3c       	jmp	$+192    	;abs 0xe532

//lower the TX pin and wait for a response
P1DIR |= ARB_CLK;  //turn the clock into an output, idle high
    e474:	e2 d2 22 00 	bis.b	#4,	&0x0022	;r2 As==10
P1OUT &= ~ARB_TX; //lower the flag to let the other chip know we want to talk to it!
    e478:	d2 c3 21 00 	bic.b	#1,	&0x0021	;r3 As==01

while((P1IN & ARB_RX) == ARB_RX)
    e47c:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e480:	0b 24       	jz	$+24     	;abs 0xe498
   {
   timeout++;
    e482:	1c 53       	inc	r12		
    e484:	0d 63       	adc	r13		
   if(timeout == INTERCHIP_TIMEOUT) //about 1 second or so 
    e486:	3c 90 20 a1 	cmp	#-24288,r12	;#0xa120
    e48a:	03 20       	jnz	$+8      	;abs 0xe492
    e48c:	3d 90 07 00 	cmp	#7,	r13	;#0x0007
    e490:	4c 24       	jz	$+154    	;abs 0xe52a
    e492:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e496:	f5 23       	jnz	$-20     	;abs 0xe482
      WDTCTL = WDTCNTCL|WDTPW; //well, the chip is taking a long time so reset ok
   }

WDTCTL = WDTCNTCL|WDTPW;
    e498:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e49c:	20 01 
//The other chip has acknowledged us, start sending data   
byte = length;
    e49e:	4d 4e       	mov.b	r14,	r13	
for(i=BYTE_LENGTH; i>0; i--)
    e4a0:	3c 42       	mov	#8,	r12	;r2 As==11
   {
   while((P1IN & ARB_RX) == ARB_RX);   //wouldn't be a bad idea for a timeout here
    e4a2:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e4a6:	fd 23       	jnz	$-4      	;abs 0xe4a2
   P1OUT |= (ARB_TX & ((0x80&byte) >> 7));  // latch output data MSB first
    e4a8:	4f 4d       	mov.b	r13,	r15	
    e4aa:	4f 5f       	rla.b	r15		
    e4ac:	4f 43       	clr.b	r15		
    e4ae:	4f 6f       	rlc.b	r15		
    e4b0:	c2 df 21 00 	bis.b	r15,	&0x0021	
   P1OUT &= ~ARB_CLK;                        //lower the clock
    e4b4:	e2 c2 21 00 	bic.b	#4,	&0x0021	;r2 As==10
   while((P1IN & ARB_RX) == 0);               //wait for the RX line to come high to show the other chip has the bit
    e4b8:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e4bc:	fd 27       	jz	$-4      	;abs 0xe4b8
   P1OUT |= ARB_CLK;                         //raise the clock
    e4be:	e2 d2 21 00 	bis.b	#4,	&0x0021	;r2 As==10
   P1OUT &= ~ARB_TX;                         //clear the TX line
    e4c2:	d2 c3 21 00 	bic.b	#1,	&0x0021	;r3 As==01
   byte = byte << 1;
    e4c6:	4d 5d       	rla.b	r13		
   }

WDTCTL = WDTCNTCL|WDTPW;
//The other chip has acknowledged us, start sending data   
byte = length;
for(i=BYTE_LENGTH; i>0; i--)
    e4c8:	3c 53       	add	#-1,	r12	;r3 As==11
    e4ca:	eb 23       	jnz	$-40     	;abs 0xe4a2
   }

//while((P1IN & ARB_RX) == 0);   //wait for the other chip to go idle
//return true;
//send_byte(length);
for(pos=0; pos < length-1; pos++)
    e4cc:	4b 4e       	mov.b	r14,	r11	
    e4ce:	0e 43       	clr	r14		
    e4d0:	1b 93       	cmp	#1,	r11	;r3 As==01
    e4d2:	21 24       	jz	$+68     	;abs 0xe516
   {
   WDTCTL = WDTCNTCL|WDTPW;
    e4d4:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e4d8:	20 01 
   byte = str[pos];    
    e4da:	0f 4a       	mov	r10,	r15	
    e4dc:	0f 5e       	add	r14,	r15	
    e4de:	6d 4f       	mov.b	@r15,	r13	
   for(i=BYTE_LENGTH; i>0; i--)
    e4e0:	3c 42       	mov	#8,	r12	;r2 As==11
      {
      while((P1IN & ARB_RX) == ARB_RX);   //wouldn't be a bad idea for a timeout here
    e4e2:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e4e6:	fd 23       	jnz	$-4      	;abs 0xe4e2
      P1OUT |= (ARB_TX & ((0x80&byte) >> 7));  // latch output data MSB first
    e4e8:	4f 4d       	mov.b	r13,	r15	
    e4ea:	4f 5f       	rla.b	r15		
    e4ec:	4f 43       	clr.b	r15		
    e4ee:	4f 6f       	rlc.b	r15		
    e4f0:	c2 df 21 00 	bis.b	r15,	&0x0021	
      P1OUT &= ~ARB_CLK;                        //lower the clock
    e4f4:	e2 c2 21 00 	bic.b	#4,	&0x0021	;r2 As==10
      while((P1IN & ARB_RX) == 0);               //wait for the RX line to come high to show the other chip has the bit
    e4f8:	e2 b3 20 00 	bit.b	#2,	&0x0020	;r3 As==10
    e4fc:	fd 27       	jz	$-4      	;abs 0xe4f8
      P1OUT |= ARB_CLK;                         //raise the clock
    e4fe:	e2 d2 21 00 	bis.b	#4,	&0x0021	;r2 As==10
      P1OUT &= ~ARB_TX;                         //clear the TX line
    e502:	d2 c3 21 00 	bic.b	#1,	&0x0021	;r3 As==01
      byte = byte << 1;
    e506:	4d 5d       	rla.b	r13		
//send_byte(length);
for(pos=0; pos < length-1; pos++)
   {
   WDTCTL = WDTCNTCL|WDTPW;
   byte = str[pos];    
   for(i=BYTE_LENGTH; i>0; i--)
    e508:	3c 53       	add	#-1,	r12	;r3 As==11
    e50a:	eb 23       	jnz	$-40     	;abs 0xe4e2
   }

//while((P1IN & ARB_RX) == 0);   //wait for the other chip to go idle
//return true;
//send_byte(length);
for(pos=0; pos < length-1; pos++)
    e50c:	1e 53       	inc	r14		
    e50e:	0f 4b       	mov	r11,	r15	
    e510:	3f 53       	add	#-1,	r15	;r3 As==11
    e512:	0e 9f       	cmp	r15,	r14	
    e514:	df 2b       	jnc	$-64     	;abs 0xe4d4
      P1OUT &= ~ARB_TX;                         //clear the TX line
      byte = byte << 1;
      }      
   }
   
P1DIR &= ~ARB_CLK;  //turn the clock into an input and let it float
    e516:	e2 c2 22 00 	bic.b	#4,	&0x0022	;r2 As==10
P1OUT |= ARB_TX | ARB_CLK; // set the TX line back to IDLE
    e51a:	f2 d0 05 00 	bis.b	#5,	&0x0021	;#0x0005
    e51e:	21 00 
WDTCTL = WDTHOLD|WDTPW;
    e520:	b2 40 80 5a 	mov	#23168,	&0x0120	;#0x5a80
    e524:	20 01 

return true;
    e526:	1f 43       	mov	#1,	r15	;r3 As==01
    e528:	04 3c       	jmp	$+10     	;abs 0xe532

while((P1IN & ARB_RX) == ARB_RX)
   {
   timeout++;
   if(timeout == INTERCHIP_TIMEOUT) //about 1 second or so 
      WDTCTL = WDTCNTCL|WDTPW; //well, the chip is taking a long time so reset ok
    e52a:	b2 40 08 5a 	mov	#23048,	&0x0120	;#0x5a08
    e52e:	20 01 
    e530:	b0 3f       	jmp	$-158    	;abs 0xe492
P1DIR &= ~ARB_CLK;  //turn the clock into an input and let it float
P1OUT |= ARB_TX | ARB_CLK; // set the TX line back to IDLE
WDTCTL = WDTHOLD|WDTPW;

return true;
}
    e532:	3a 41       	pop	r10		
    e534:	3b 41       	pop	r11		
    e536:	30 41       	ret			

0000e538 <memcmp>:
    e538:	0b 12       	push	r11		
    e53a:	0b 4d       	mov	r13,	r11	
    e53c:	0d 93       	tst	r13		
    e53e:	0a 24       	jz	$+22     	;abs 0xe554
    e540:	0c 4f       	mov	r15,	r12	
    e542:	0d 4e       	mov	r14,	r13	
    e544:	6e 4d       	mov.b	@r13,	r14	
    e546:	1d 53       	inc	r13		
    e548:	6f 4c       	mov.b	@r12,	r15	
    e54a:	1c 53       	inc	r12		
    e54c:	4f 9e       	cmp.b	r14,	r15	
    e54e:	04 20       	jnz	$+10     	;abs 0xe558
    e550:	3b 53       	add	#-1,	r11	;r3 As==11
    e552:	f8 23       	jnz	$-14     	;abs 0xe544
    e554:	0c 43       	clr	r12		
    e556:	05 3c       	jmp	$+12     	;abs 0xe562
    e558:	5c 4c ff ff 	mov.b	-1(r12),r12	;0xffff(r12)
    e55c:	5f 4d ff ff 	mov.b	-1(r13),r15	;0xffff(r13)
    e560:	0c 8f       	sub	r15,	r12	
    e562:	0f 4c       	mov	r12,	r15	
    e564:	3b 41       	pop	r11		
    e566:	30 41       	ret			

0000e568 <strstr>:
    e568:	0b 12       	push	r11		
    e56a:	0a 12       	push	r10		
    e56c:	09 12       	push	r9		
    e56e:	08 12       	push	r8		
    e570:	0b 4f       	mov	r15,	r11	
    e572:	0a 4e       	mov	r14,	r10	
    e574:	69 4e       	mov.b	@r14,	r9	
    e576:	1a 53       	inc	r10		
    e578:	49 93       	tst.b	r9		
    e57a:	15 24       	jz	$+44     	;abs 0xe5a6
    e57c:	08 4a       	mov	r10,	r8	
    e57e:	18 83       	dec	r8		
    e580:	18 53       	inc	r8		
    e582:	c8 93 00 00 	tst.b	0(r8)		;0x0000(r8)
    e586:	fc 23       	jnz	$-6      	;abs 0xe580
    e588:	08 8a       	sub	r10,	r8	
    e58a:	6f 4b       	mov.b	@r11,	r15	
    e58c:	1b 53       	inc	r11		
    e58e:	4f 93       	tst.b	r15		
    e590:	0c 24       	jz	$+26     	;abs 0xe5aa
    e592:	4f 99       	cmp.b	r9,	r15	
    e594:	fa 23       	jnz	$-10     	;abs 0xe58a
    e596:	0d 48       	mov	r8,	r13	
    e598:	0e 4a       	mov	r10,	r14	
    e59a:	0f 4b       	mov	r11,	r15	
    e59c:	b0 12 b6 e5 	call	#0xe5b6	
    e5a0:	0f 93       	tst	r15		
    e5a2:	f3 23       	jnz	$-24     	;abs 0xe58a
    e5a4:	3b 53       	add	#-1,	r11	;r3 As==11
    e5a6:	0f 4b       	mov	r11,	r15	
    e5a8:	01 3c       	jmp	$+4      	;abs 0xe5ac
    e5aa:	0f 43       	clr	r15		
    e5ac:	38 41       	pop	r8		
    e5ae:	39 41       	pop	r9		
    e5b0:	3a 41       	pop	r10		
    e5b2:	3b 41       	pop	r11		
    e5b4:	30 41       	ret			

0000e5b6 <strncmp>:
    e5b6:	0b 12       	push	r11		
    e5b8:	0b 4f       	mov	r15,	r11	
    e5ba:	0d 93       	tst	r13		
    e5bc:	02 20       	jnz	$+6      	;abs 0xe5c2
    e5be:	0d 43       	clr	r13		
    e5c0:	0f 3c       	jmp	$+32     	;abs 0xe5e0
    e5c2:	6f 4e       	mov.b	@r14,	r15	
    e5c4:	1e 53       	inc	r14		
    e5c6:	6c 4b       	mov.b	@r11,	r12	
    e5c8:	4c 9f       	cmp.b	r15,	r12	
    e5ca:	06 20       	jnz	$+14     	;abs 0xe5d8
    e5cc:	1b 53       	inc	r11		
    e5ce:	4c 93       	tst.b	r12		
    e5d0:	f6 27       	jz	$-18     	;abs 0xe5be
    e5d2:	3d 53       	add	#-1,	r13	;r3 As==11
    e5d4:	f6 23       	jnz	$-18     	;abs 0xe5c2
    e5d6:	f3 3f       	jmp	$-24     	;abs 0xe5be
    e5d8:	4d 4c       	mov.b	r12,	r13	
    e5da:	5f 4e ff ff 	mov.b	-1(r14),r15	;0xffff(r14)
    e5de:	0d 8f       	sub	r15,	r13	
    e5e0:	0f 4d       	mov	r13,	r15	
    e5e2:	3b 41       	pop	r11		
    e5e4:	30 41       	ret			

0000e5e6 <__stop_progExec__>:
    e5e6:	ff 3f       	jmp	$+0      	;abs 0xe5e6
Disassembly of section .vectors:

0000ffe0 <InterruptVectors>:
    ffe0:	30 e0 30 e0 46 e0 30 e0 30 e0 30 e0 30 e0 36 e0     0.0.F.0.0.0.0.6.
    fff0:	30 e0 30 e0 30 e0 30 e0 30 e0 30 e0 30 e0 00 e0     0.0.0.0.0.0.0...