;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; loggingmic1.asm
; microphone signal undergoes ADC (in the tiny26L) and is stored in 1M atmel flash memory, it can be accessed later.
;
; (c) Stacy DeRuiter, 2005
; 
;
;
.include "tn26def.inc"

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Pin Definitions Section
;
.equ txpin = PA2; transmit pin
.equ rxpin = PA1; receive pin
.equ micpin = PA0; Mic data in pin (ADC0)
.equ ledpin = PA7; LED pin (to indicate start of recording)
.equ buttonpin = PA6; button to start recording or data return
.equ sopin = PB1; serial data out pin (to FLASH memory) DO NOT change which pins si/so are if you are going to use USI
.equ sipin = PB0; serial data in pin (from FLASH memory) 
.equ sckpin = PB2; SCK pin to FLASH memory (clock sync btw tiny26 and FLASH)
.equ cspin = PB3; chip select pin for FLASH memory (to select the FLASH mem. for operation)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Variable Declarations
;
.def bitcnt = R16; bit counter
.def temp = R17; temporary storage
.def temp1 = R18; temporary storage
.def txbyte = R19; transmit byte
.def rxbyte = R20; receive byte
.def pagecnt = R21; page counter (keeping track of which page of the flash memory you are writing on)
.def buffcnt = r22; buffer loop counter (keeping track of number of bytes written to flash memory buffer)
.def temp2 = r23 ; temp storage
;
;.def which_mode = R21; stores which mode we are currently in


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Interrupt Handlers
;
.cseg


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Program memory:
;
.org 0
rjmp init ; let's start by running init


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Utility functions
; these can be used by any code

;
; putchar
; assumes no line driver (doesn't invert bits)
;this is just Neil's putchar, but with PORTB changed to PORTA 
;(since the tiny26 has both A and B and our tx/rx pins are on PORTA)
;
.equ sb = 1; number of stop bits
putchar:
    ldi bitcnt, 9+sb; 1+8+sb
    com txbyte; invert everything
    sec; set start bit
    putchar0:
        brcc putchar1; if carry set
        sbi PORTA, txpin; send a '0'
        rjmp putchar2; else
    putchar1:
         cbi PORTA, txpin; send a '1'
         nop ; even out timing
    putchar2:
         rcall bitdelay; one bit delay
         rcall bitdelay
         lsr txbyte; get next bit
         dec bitcnt; if not all bits sent
         brne putchar0; send next bit
    ret;
;
; getchar
; assumes no line driver (doesn't invert bits)
;
getchar:
    ldi bitcnt,9 ; 8 data bit + 1 stop bit
    getchar1:
        sbis PINA, rxpin ; wait for start bit
        rjmp getchar1
    rcall bitdelay ; 0.5 bit delay
    getchar2:
        rcall bitdelay ; 1 bit delay
        rcall bitdelay ;
        clc ; clear carry
        sbis PINA, rxpin ; if RX pin high skip
            sec ; otherwise set carry
        dec bitcnt
        breq getchar3 ; return if all bits read
        ror rxbyte ; otherwise shift bit into receive byte
        rjmp getchar2 ; go get next bit
    getchar3:
        ret
        
;
; print
; prints a null-terminated string
;
print:
    print_loop:
        lpm
        mov txbyte,R0
        cpi txbyte,0
        breq return
        rcall putchar
        inc zl
        rjmp print_loop
    return:
        ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Mode-specific functions
;

; hello world 
hello_mode:
    sbi PORTA, txpin; init comm pin
    sbi DDRA, txpin
    hw_loop:
        rcall getchar
        inc rxbyte
        mov txbyte, rxbyte
        rcall putchar
        rjmp hw_loop
    ret


; Recording Mode
record_mode:
	; main data-logging (recording) program
	;
	;	
	;initialize communication between ATtiny26 and Atmel 1Mbit FLASH memory
	;set the from-FLASH input pin and the button pin as input, and to-FLASH, SCK, CS, and led pins as outputs  
   	;
   	cbi PORTB, sopin ; set the serial-out-from-FLASH pin (to ATtiny26 from FLASH) as an input
   	cbi DDRB, sopin ;  "
   	;
	sbi PORTA, buttonpin ; set the button pin (button push starts recording) as an input with internal pull-up resistor
   	cbi DDRA, buttonpin ;  "
   	;
	cbi PORTB, sipin ; set the serial-in-to-FLASH pin (from ATtiny26 to FLASH) as an output
   	sbi DDRB, sipin ;  "
   	;
	cbi PORTB, sckpin ; set the sck pin as an output
   	sbi DDRB, sckpin ;  "
   	;
	sbi PORTB, cspin ; set the chip select pin as an output; when it is low the FLASH is listening
   	sbi DDRB, cspin ;  "
   	;
	cbi PORTA, ledpin ; set the ledpin as an output
   	sbi DDRA, ledpin ;  "
	;
    sbi PORTA, txpin    ;init comm pin
    sbi DDRA, txpin
   	;
   	; wait for button to be pushed to start recording
	;
	waitloop:
           sbic PINA, buttonpin ; check for button; if button is pushed, exit loop, flash LED, and start recording
           rjmp waitloop
    sbi PORTA, ledpin ; flash the led to indicate recording is about to start
    rcall long_print_delay
    cbi PORTA, ledpin ; turn off the led 
	;
   	; initiate the A/D converter of the ATtiny26 for input on AD0 (PA0)
   	;
   	cbi ADMUX, REFS0  ; setting REFS0 = 0 and REFS1 = 1 sets the ADC to use internal...(next line) 
	sbi ADMUX, REFS1  ; ...Vref = 2.56V as the reference voltage 
   	cbi ADMUX, ADLAR  ; right-adjust bits in ADC output data bytes (make sure left-adj is off)
   	sbi ADCSRA, ADEN   ; enable the A/D
   	cbi ADCSRA, ADFR   ; set ADC for single-shot measurement (turn off free running mode)
   	cbi ADCSRA, ADIE   ; disable A/D interrupt
   	sbi ADCSRA, ADPS2  ; set ADC prescaler for input clock=tinyclock/32 (so ADC clock cycles at 16MHz/32 = 500kHz)... 
   	cbi ADCSRA, ADPS1  ; " (the ADC clock can run much faster, but we only want audio samples at 10kHz, so only need...
   	sbi ADCSRA, ADPS0  ; " one every 1600 tiny26 clock cycles (=every 50 ADC cycles at /32, and ADC takes 13 ADC cycles.)
	;   	
	cbi ADMUX, MUX4   ; setting MUX0, MUX1,...MUX4 = 0 in the ADMUX register tells the ADC...
   	cbi ADMUX, MUX3   ; to use a single input from PB0 (ADC0).  With other settings the ADC...
	cbi ADMUX, MUX2   ; can use the difference between two adjacent pins, or the difference...
   	cbi ADMUX, MUX1   ; between two pins multiplied by some gain factor, as input.
   	cbi ADMUX, MUX0   ; "  
;
; main recording loop (recording continues until memory is full.  This code has no way to stop recording.)
;
;
; convert input from the microphone to digital
;
sbi ADCSRA, ADSC ; start the first conversion
adloop1up:
   sbic ADCSRA, ADSC ; loop until complete
   rjmp adloop1up
;	
;adc_delay; want a delay of 12 ADC clock cycles = 384 tiny26 cycles before next sample.   
;adc_delay_loop:
;will not put this loop in the code for now.  Problem:  initiating writing to the flash (needs to be
;done every 264 data bytes sent) takes some cycles, and writing a page takes up to 20ms.  That will
;royally screw up the sampling frequency.  For right now, just not worrying about it.      
;
; send high byte of the conversion to the FLASH memory chip
;memory has 264 byte pages, so can send 264 conversions to buffer and then have to write a page. 
;This serial transfer uses the Universal Serial Interface of the ATtiny26 (see ATtiny26 datasheet).
;
;the flash_loop writes a byte to the FLASH buffer.  It should repeat 264 times, then wait for the
;flash memory to write the page from the buffer to the real memory.
;
;the page_loop controls which page the flash is writing to, and it should loop from 0 to 511. 
;After 511 pages have been written the memory will be full.
;
ldi pagecnt, 0 ; start writing on page 0, and write on all the pages till they are gone
page_loop1:
   ;        
   cbi PORTB, cspin; select the flash memory (make it start listening)
   ;	   
   ;Tell the flash to write to memory through its buffer
   ;
   ldi txbyte, 0x82 ; 82H is the 8-bit opcode telling the flash to write to memory through the buffer
   out USIDR,txbyte  
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;	
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop1:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop1
   in txbyte,USIDR
   ;Tell the flash the page address to write to (and the buffer address, but for us, that is just 0)
   ;
   mov temp, pagecnt ; this line + the next line store the most significant bit of pagecnt in the last bit of temp
   LSR temp      ; and the first 7 bits of temp are zeros
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   mov temp1, pagecnt ; this line + the next line stores the 7 least sig. bits of pagecnt in temp1 
   LSL temp1    ; and the last bit of temp1 is zero
   ;
   mov txbyte, temp ; sending the first of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop2:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop2
   in txbyte,USIDR	
   ;
   mov txbyte, temp1 ; sending the second of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop3:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop3	
   in txbyte,USIDR
   ;
   in txbyte, 0 ; sending the third of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop4:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop4
   in txbyte,USIDR	
   ldi buffcnt, 255; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so do the following loop 264 times before writing a page to flash memory
   flash_loop: 
      ;Tell the flash to write the ADC data byte into its buffer 
      in txbyte , ADCH ; save high byte of adc conversion as txbyte	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop5:
         out USICR,txbyte
         sbis USISR,USIOIF
         rjmp Transfer_loop5
   in txbyte,USIDR
      dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loop; so that you will exit the loop after buffcnt = 255 runs through the loop
ldi buffcnt, 6; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so do the following loop 7 more times before writing a page to flash memory
   flash_loop2: 
      ;Tell the flash to write the ADC data byte into its buffer 
      in txbyte , ADCH ; save high byte of adc conversion as txbyte	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop5a:
         out USICR,txbyte
         sbis USISR,USIOIF
         rjmp Transfer_loop5a
   in txbyte,USIDR
      dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loop2; so that you will exit the loop after buffcnt = 8 runs through the loop
   sbi PORTB, cspin  ; deselect the flash memory (tell it to stop listening and write its page from buffer to memory)
   ;
   ; wait for the flash memory to be ready (wait the amt of time it takes to write a page to memory) - it would be better
   ; to use a busy/ready signal from the flash memory, but atmel 1M flash in the package we have doesn't have a ready/busy
   ; pin and I don't want to use the complicated other option which involves serial com to the attiny13...hence the timer
   ;
   ldi temp, 5
   out TCCR0, temp ; this command sets the timer clock to tinyclock/1024 by storing 00000101=5 to the TCCR0 register
   ldi temp, 0     ; 
   out TCNT0, temp      ; start the timer (IS THIS RIGHT?) by "writing" TCNT0 ??
   timer_loop:
      in temp, TCNT0  ; store the current timer value in "temp"
	  ldi temp1, 167  ; store 167 in "temp1"
	  cp temp, temp1     ; we want to wait till the timer reaches 167 - compare timer # with 157
      brlt timer_loop   ; stay in this loop as long as timer is less than 167
   ldi temp, 0         ; this command, with the next one, stops the timer 
   out TCCR0, temp     ; by storing 00000000 in the TCCR0 register
   inc pagecnt       ;  ok, we wrote one page to flash, so increase the page number so as to write on the next page next time  	             ;  through the loop.
   ldi temp, 255     ; store 255 in temp register
   cpse pagecnt,temp    ; if we have already written the first 256 the memory pages (there are 0,1,2,...511) then pagecnt will 		     ; be 256 and 
	             ; we should exit the loop by skipping the next line.
   rjmp page_loop1    ; stay in the loop if pagecnt is NOT= 255
;

ldi pagecnt, 0 ; now we do the second half of the memory pages...
page_loop2:
   ;        
   cbi PORTB, cspin; select the flash memory (make it start listening)
   ;	   
   ;Tell the flash to write to memory through its buffer
   ;
   ldi txbyte, 0x82 ; 82H is the 8-bit opcode telling the flash to write to memory through the buffer
   out USIDR,txbyte  
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;	
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop6:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop6
	     in txbyte,USIDR
   ;Tell the flash the page address to write to (and the buffer address, but for us, that is just 0)
   ;
   mov temp, pagecnt ; this line + the next line store the most significant bit of pagecnt in the last bit of temp
   LSR temp      ; and the first 6 bits of temp are zeros
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   ORI temp, 2   ; and the second to last bit of temp has to be 1 (since we are in 2nd half of mem pages) 
   mov temp1, pagecnt ; this line + the next line stores the 7 least sig. bits of pagecnt in temp1 
   LSL temp1    ; and the last bit of temp1 is zero
   mov txbyte, temp ; sending the first of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop7:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop7	
      in txbyte,USIDR
   ;
   mov txbyte, temp1 ; sending the second of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop8:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop8	
      in txbyte,USIDR
   ;
   in txbyte, 0 ; sending the third of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop9:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop9
	     in txbyte,USIDR	
   ldi buffcnt, 255; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so do the following loop 264 times before writing a page to flash memory
   flash_loopb: 
      ;Tell the flash to write the ADC data byte into its buffer 
      in txbyte , ADCH ; save high byte of adc conversion as txbyte	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop10:
         out USICR,txbyte
         sbis USISR,USIOIF
         rjmp Transfer_loop10
		    in txbyte,USIDR
      dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loopb; so that you will exit the loop after buffcnt = 264 runs through the loop
ldi buffcnt, 6; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so do the following loop 7 more times before writing a page to flash memory
   flash_loopb2: 
      ;Tell the flash to write the ADC data byte into its buffer 
      in txbyte , ADCH ; save high byte of adc conversion as txbyte	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop10b:
         out USICR,txbyte
         sbis USISR,USIOIF
         rjmp Transfer_loop10b
   in txbyte,USIDR
      dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loopb2; so that you will exit the loop after buffcnt = 6 runs through the loop
   sbi PORTB, cspin  ; deselect the flash memory (tell it to stop listening and write its page from buffer to memory)
   ;
   ; wait for the flash memory to be ready (wait the amt of time it takes to write a page to memory) - it would be better
   ; to use a busy/ready signal from the flash memory, but atmel 1M flash in the package we have doesn't have a ready/busy
   ; pin and I don't want to use the complicated other option which involves serial com to the attiny13...hence the timer
   ;
   ldi temp, 5
   out TCCR0, temp ; this command sets the timer clock to tinyclock/1024 by storing 00000101=5 to the TCCR0 register
   ldi temp, 0     ; 
   out TCNT0, temp      ; start the timer (IS THIS RIGHT?) by "writing" TCNT0 ??
   timer_loop2:
      in temp, TCNT0  ; store the current timer value in "temp"
	  ldi temp1, 167  ; store 167 in "temp1"
	  cp temp, temp1     ; we want to wait till the timer reaches 167 - compare timer # with 157
      brlt timer_loop2   ; stay in this loop as long as timer is less than 167
   ldi temp, 0         ; this command, with the next one, stops the timer 
   out TCCR0, temp     ; by storing 00000000 in the TCCR0 register
   inc pagecnt       ;  ok, we wrote one page to flash, so increase the page number so as to write on the next page next time  	             ;  through the loop.
   ldi temp, 255     ; store 255 in temp register
   cpse pagecnt,temp    ; if we have already written the first 256 the memory pages (there are 0,1,2,...511) then pagecnt will 		     ; be 256 and 
	             ; we should exit the loop by skipping the next line.
   rjmp page_loop2    ; stay in the loop if pagecnt is NOT= 255
sbi PORTA, ledpin ; flash the led to indicate recording is done
rcall long_print_delay
cbi PORTA, ledpin ; turn off the led 
ldi txbyte, 8
rcall putchar
;
; When memory is full, go to sleep
;cbi ADCSRA, ADEN   ; disable the A/D
;ldi temp, 128   ; load 1000 0000=128 into temp
;out SREG, temp     ; enable interrupts in general by setting the I bit (bit 7) in SREG
;ldi temp, 51    ; load 00110011 into temp
;out MCUCR, temp ; enable sleep mode, select "power down" sleep mode, ... 
                ; ... and set the processor to wake up on the rising edge of INT0 pin
;ldi temp, 64    ; load 0100 0000 into temp
;out GIMSK, temp ; enable the INT0 external interrupt by setting the INT0 bit in GIMSK
;SLEEP           ; g'night, tiny26! (puts the chip into sleep mode)
;
;
;
; wait for (positive) signal on external interrupt pin - when signal is detected for at least 2us,wake up and start offload 
;
; Recovering Data from Memory and sending it to a computer through the serial port
;
;
;first, we just want to turn off the interrupt to make sure the chip will not go back to sleep while we are getting its data...
;ldi temp, 0        ; load 0 into temp
;out SREG, temp     ; turn off the external interrupt by clearing bit 7 (1st bit ) of SREG
;out GIMSK, temp    ; and clearing bit 6 (2nd bit) of GIMSK
;
; now we will get the data from the memory - first, we will get a byte from memory,
; then send it out serially to the external computer using putchar, then get another byte...
; keep doing that until all the bytes in memory are read
;
;wait for button to offload data
waitloop2:
   sbic PINA, buttonpin ; check for button; if button is pushed, exit loop, flash LED, and start recording
   rjmp waitloop2

cbi PORTB, sopin ; set the serial-out-from-FLASH pin (to ATtiny26 from FLASH) as an input
cbi DDRB, sopin ;  "
;
sbi PORTA, buttonpin ; set the button pin (button push starts recording) as an input with internal pull-up resistor
cbi DDRA, buttonpin ;  "
;
cbi PORTB, sipin ; set the serial-in-to-FLASH pin (from ATtiny26 to FLASH) as an output
sbi DDRB, sipin ;  "
;
cbi PORTB, sckpin ; set the sck pin as an output
sbi DDRB, sckpin ;  "
;
sbi PORTB, cspin ; set the chip select pin as an output; when it is low the FLASH is listening
sbi DDRB, cspin ;  "
;
cbi PORTA, ledpin ; set the ledpin as an output
sbi DDRA, ledpin ;  "  
;
sbi PORTA, txpin    ;init comm pin
sbi DDRA, txpin
;
cbi PORTB, cspin ; select the flash memory (tell it to start listening)
;
;Tell the flash to write to read memory page by page
;
ldi pagecnt,0; first page to read from is page 0
page_loop1m:
   ldi txbyte, 210 ; D2H(=210 in decimal) is the 8-bit opcode telling the flash to write to memory through the buffer
   out USIDR,txbyte  
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;	
   ;The transfer loop below repeats 8 times to send all 8 bytes of the opcode
   ;
   Transfer_loop1m:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop1m
	     in txbyte,USIDR
   ;Tell the flash the page address to write to (and the buffer address, but for us, that is just 0)
   ;
   mov temp, pagecnt ; this line + the next line store the most significant bit of pagecnt in the last bit of temp
   LSR temp      ; and the first 7 bits of temp are zeros
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   mov temp1, pagecnt ; this line + the next line stores the 7 least sig. bits of pagecnt in temp1 
   LSL temp1    ; and the last bit of temp1 is zero
   ;
   mov txbyte, temp ; sending the first of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop2m:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop2m	
      in txbyte,USIDR
   ;
   mov txbyte, temp1 ; sending the second of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop3m:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop3m	
      in txbyte,USIDR
   ;
   in txbyte, 0 ; sending the third of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop4m:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop4m
	     in txbyte,USIDR	
   ldi buffcnt, 255; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so we have to read 264 pages of flash memory
   flash_loopm: 
      ;get a byte from flash memory 
      ldi txbyte , 0 ; dummy byte to send to flash memory	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop5m:
         out USICR,txbyte ; honestly I am not sure just how the USI works -
         sbis USISR,USIOIF; see the USI documentation in the tiny26 data sheet
         rjmp Transfer_loop5m
      in txbyte, USIDR; store the transmission byte from flash memory as rxbyte
      rcall putchar   ; send the byte (just gotten from flash) out to the computer
	  dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loopm; so that you will exit the loop after buffcnt = 255 runs through the loop
ldi buffcnt, 6; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so do the following loop 7 more times and you'll have read one page of flash
   flash_loop2m: 
      ldi txbyte , 0 ; dummy byte to send to flash while we are getting its data	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop5am:
         out USICR,txbyte
         sbis USISR,USIOIF
         rjmp Transfer_loop5am
	  in txbyte, USIDR
      rcall putchar
      dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loop2m; so that you will exit the loop after buffcnt = 8 runs through the loop
   sbi PORTB, cspin  ; deselect the flash memory (tell it to stop listening and write its page from buffer to memory)
   inc pagecnt       ;  ok, we got one page from flash, so increase the page number so as to write on the next page next time  	             ;  through the loop.
   ldi temp, 255     ; store 255 in temp register
   cpse pagecnt,temp    ; if we have already written the first 256 of the memory pages (there are 0,1,2,...511) then pagecnt will 		     ; be 256 and 
	             ; we should exit the loop by skipping the next line.
   rjmp page_loop1m    ; stay in the loop if pagecnt is NOT= 255
;
ldi pagecnt, 0 ; now we do the second half of the memory pages...
page_loop2m:
   ldi txbyte, 210 ; D2H(=210 in decimal) is the 8-bit opcode telling the flash to write to memory through the buffer
   out USIDR,txbyte  
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;	
   ;The transfer loop below repeats 8 times to send all 8 bytes of the opcode
   ;
   Transfer_loop1mb:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop1mb
   ;Tell the flash the page address to write to (and the buffer address, but for us, that is just 0)
   ;
   mov temp, pagecnt ; this line + the next line store the most significant bit of pagecnt in the last bit of temp
   LSR temp      ; and the first 7 bits of temp are zeros (for a minute)
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   LSR temp      ;
   ORI temp, 2   ; now the second to last bit in temp is a 1 (2nd half of pages)
   mov temp1, pagecnt ; this line + the next line stores the 7 least sig. bits of pagecnt in temp1 
   LSL temp1    ; and the last bit of temp1 is zero
   ;
   mov txbyte, temp ; sending the first of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop2mb:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop2mb	
   ;
   mov txbyte, temp1 ; sending the second of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop3mb:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop3mb	
   ;
   in txbyte, 0 ; sending the third of 3 bytes needed to specify the address...
   out USIDR,txbyte   ; 
   ldi txbyte,(1<<USIOIF) 
   out USISR,txbyte
   ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
   ;		
   ;The transfer loop below repeats 8 times to send all 8 bytes of data
   ;
   Transfer_loop4mb:
      out USICR,txbyte
      sbis USISR,USIOIF
      rjmp Transfer_loop4mb	
   ldi buffcnt, 255; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so we have to read 264 pages of flash memory
   flash_loopmb: 
      ;get a byte from flash memory 
      ldi txbyte , 0 ; dummy byte to send to flash memory	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop5mb:
         out USICR,txbyte ; honestly I am not sure just how the USI works -
         sbis USISR,USIOIF; see the USI documentation in the tiny26 data sheet
         rjmp Transfer_loop5mb
      in txbyte, USIDR; store the transmission byte from flash memory as rxbyte
      rcall putchar   ; send the byte (just gotten from flash) out to the computer
	  dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loopmb; so that you will exit the loop after buffcnt = 255 runs through the loop
ldi buffcnt, 6; there are 264 bytes in each page of flash (and 264 bytes in the flash buffer)
   ;                 so do the following loop 7 more times and you'll have read one page of flash
   flash_loop2mb: 
      ldi txbyte , 0 ; dummy byte to send to flash while we are getting its data	   
      out USIDR,txbyte
      ldi txbyte,(1<<USIOIF)
      out USISR,txbyte
      ldi txbyte,(1<<USIWM0)+(1<<USICS1)+(1<<USICLK)+(1<<USITC)
      ;
      ;The transfer loop below repeats 8 times (until all 8 bytes of data are sent)
      ;
      Transfer_loop5amb:
         out USICR,txbyte
         sbis USISR,USIOIF
         rjmp Transfer_loop5amb
	  in txbyte, USIDR
      rcall putchar
      dec buffcnt    ; each time you go through this loop, decrease the buffer count...
      brne flash_loop2mb; so that you will exit the loop after buffcnt = 8 runs through the loop
   sbi PORTB, cspin  ; deselect the flash memory (tell it to stop listening and write its page from buffer to memory)
   inc pagecnt       ;  ok, we got one page from flash, so increase the page number so as to write on the next page next time  	             ;  through the loop.
   ldi temp, 255     ; store 255 in temp register
   cpse pagecnt,temp    ; if we have already written the first 256 of the memory pages (there are 0,1,2,...511) then pagecnt will 		     ; be 256 and 
	             ; we should exit the loop by skipping the next line.
   rjmp page_loop2m    ; stay in the loop if pagecnt is NOT= 255

sbi PORTA, ledpin ; flash the led to indicate transfer is done
rcall long_print_delay
cbi PORTA, ledpin ; turn off the led 
;
;wait for button push to go to sleep
;waitloop2:
;   sbic PINB, buttonpin ; check for button; if button is pushed, exit loop, flash LED, and start recording
;   rjmp waitloop2
;sbi PORTA, ledpin ; flash the led to indicate "I'm going to sleep"
;rcall long_print_delay
;cbi PORTA, ledpin ; turn off the led 
;
; go to sleep
;cbi ADCSRA, ADEN   ; disable the A/D
;ldi temp, 128   ; load 1000 0000=128 into temp
;out SREG, temp     ; enable interrupts in general by setting the I bit (bit 7) in SREG
;ldi temp, 51    ; load 00110011 into temp
;out MCUCR, temp ; enable sleep mode, select "power down" sleep mode, ... 
                ; ... and set the processor to wake up on the rising edge of INT0 pin
;ldi temp, 64    ; load 0100 0000 into temp
;out GIMSK, temp ; enable the INT0 external interrupt by setting the INT0 bit in GIMSK
;SLEEP           ; g'night, tiny26! (puts the chip into sleep mode)
;
; wait for (positive) signal on external interrupt pin - when signal is detected for at least 2us,wake up ready to record
;
;
;first, we just want to turn off the interrupt to make sure the chip will not go back to sleep while we are getting its data...
;ldi temp, 0        ; load 0 into temp
;out SREG, temp     ; turn off the external interrupt by clearing bit 7 (1st bit ) of SREG
;out GIMSK, temp    ; and clearing bit 6 (2nd bit) of GIMSK
;  wait for the signal to record...
rjmp record_mode
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Operating System functions
; 
;

;
; bit delay
.equ b = 14 ; 9600 bps 5V found with Jesse's bdetect program modified for the tiny26
bitdelay:
    ldi temp, b
    bitloop:
        dec temp
        brne bitloop
    ret
    
;
; print_delay
; delay between printed lines
;
.equ delay = 200
print_delay:
    ldi temp1, delay
    charloop1:
        ldi temp, delay
        charloop0:
            dec temp
            brne charloop0
        dec temp1
        brne charloop1
    ret
;;
.equ delay2 = 64
long_print_delay:
   ldi temp2, delay
   charloop2:
      ldi temp1, delay
      charloop1a:
         ldi temp, delay
         charloop0a:
            dec temp
            brne charloop0a
         dec temp1
         brne charloop1a
      dec temp2
      brne charloop2
   ret


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Memory
;

; string to print
;
print_string:
   .db "porpoises say hallo",13,10,0

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; init: main entry point for the program
; pick a mode to work in, and go do it.
;
init:
    ldi temp, low(RAMEND) ; set stack pointer to top of RAM
    out SP, temp
	ldi temp, 0; 
	ldi temp1, 1;
	out CKSEL3, temp ; set the clock frequency to 8MHz (default is CKSEL=0001, 1MHz)
    out CKSEL2, temp1;
	out CKSEL1, temp ;
	out CKSEL0, temp ;
	rjmp record_mode


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;