Subversion Repositories svnkaklik

Rev

Rev 409 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download

;
;    Copyright (C) 2004    John Orlando
;    
;   AVRcam: a small real-time image processing engine.

;    This program is free software; you can redistribute it and/or
;    modify it under the terms of the GNU General Public
;    License as published by the Free Software Foundation; either
;    version 2 of the License, or (at your option) any later version.

;    This program is distributed in the hope that it will be useful,
;    but WITHOUT ANY WARRANTY; without even the implied warranty of
;    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
;    General Public License for more details.

;    You should have received a copy of the GNU General Public
;    License along with this program; if not, write to the Free Software
;    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

;   For more information on the AVRcam, please contact:

;   john@jrobot.net

;   or go to www.jrobot.net for more details regarding the system.
;**********************************************************************
;       Module Name: CanInterfaceAsm.S
;       Module Date: 04/14/2004
;       Module Auth: John Orlando
;
;       Description: This module provides the low-level interface
;       to the OV6620 camera hardware.  It is responsible for
;       acquiring each pixel block (R,G,B), performing the mapping
;       into an actual color (orange, purple, etc), run-length
;       encoding the data, and storing the info off to the appropriate
;       line buffer.  This routine is synchronized with the pixel data
;       so that no polling of the camera data needs to be done (the
;       OV6620 is clocked off of the same crystal source as the mega8,
;       thus providing inherent synchronization between the two).
;
;       Revision History:
;       Date        Rel Ver.    Notes
;       4/10/2004      0.1     Module created
;       6/30/2004      1.0     Initial release for Circuit Cellar
;                              contest.
;       1/16/2005      1.4     Fixed issue with the TCCR1B register
;                              where PCLK was getting routed to the
;                              timer1 even when it wasn't needed.
;                              This caused excessive counter overflow
;                              interrupts, and caused problems.  Now,
;                              the "PCLK" pipe feeds timer1 when needed,
;                              and is turned off when it isn't needed.

#include <avr/io.h>
#include "Events.h"
                
                .extern fastEventBitmask    ; This is the flag used to indicate to the rest
                                                                        ; of the system that the line is complete
                                                                
#define HREF_INTERRUPT_ENABLE_MASK   0x80
#define HREF_INTERRUPT_DISABLE_MASK  0x7F
#define ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK  0x04
#define DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK 0xFB
#define G_PORT                                          _SFR_IO_ADDR(PINC)  
#define RB_PORT                                         _SFR_IO_ADDR(PINB)  
#define PIXEL_RUN_START_INITIAL     0x50        ; This value causes our pixel counter (TCNT1)
                                                                                                ; to overflow after 176 (horizontal) pixels

#define RED_MEM_OFFSET                          0x00
#define GREEN_MEM_OFFSET                        0x10
#define BLUE_MEM_OFFSET                         0x20

; A pixelBlock is defined as a contiguous group of 4 pixels that are combined 
; together to form a specific color.  Typically, this is formed by sampling a
; a green value, followed by a red and blue value (since we are dealing
; with Bayer color data).  We could optionally sample a second green with
; the red and average the greens, because the eye is more sensitive to
; green, but for speed we don't do this.  These three values (RGB) are then
; used as indices into the color membership lookup table (memLookup) to
; determine which color the pixelBlock maps into.  The memLookup table is
; manually generated for now (though it will hopefully be modified over
; the serial interface eventually).
;
; Here is a pixel block:
; ...G  G  G  G...  (row x)
; ...B  R  B  R...  (row x+1)
;    |  |  |  |--this is skipped 
;    |  |  |--this is skipped
;    |  |--this is sampled
;    |--this is sampled

; As pixel blocks are sampled, the red, green, and blue values are
; used to index into their respective color maps.  The color maps
; return values that can be logically ANDed together so that a 
; particular RGB triplet will result in a single bit being set
; after the AND operation.  This single bit indicates which color
; the RGB triplet represents.  It is also possible for no bits to
; be set after the AND process, indicating that the RGB triplet
; does not map to any of the colors configured in the color map.
; This isn't quite as fast as a pure RGB lookup table, but
; it then again it doesn't require 2^12 (4-bits for each color
; channel) bytes to store the lookup table.  It takes just a few
; more cycles, and only requires 48 bytes of precious RAM (16
; per color channel, since our resolution on each color channel
; is only 4-bits).  Not bad....for more information, see:
; http://www.cs.cmu.edu/~trb/papers/wirevision00.pdf for more
; information on this color segmentation technique.

; One other note: this code does depend on the colorMap residing
; at a well-defined position in memory; specifically, it mus
; start at a 256-byte boundary so that the lowest byte in the
; map is set to 0x00.  Currently, the colorMap is forced to
; start at RAM location 0x300.  This could potentially be changed
; by the developer if needed, but offsets would have to be added
; in to the colorMap look-up code below to make it work.


; These are the registers that will be used throughout this
; module for acquiring each line of pixel data
pixelCount                      = 16
pixelRunStart           = 17
lastColor               = 18
tmp1                            = 19    ; be sure to not use tmp1 and color simultaneously
tmp2                            = 20
color                   = 19
greenData               = 20
blueData                = 21
colorMapLow                     = 22
colorMapHigh            = 23
prevLineBuffLow         = 22    ; overlaps with memLookupLow (but orthogonal)
prevLineBuffHigh        = 23    ; overlaps with memLookupHigh (but orthogonal)
currLineBuffLow     = 24
currLineBuffHigh        = 25

        .section .text

; These are the global assembly function names that are accessed via other
; C functions
        .global CamIntAsm_waitForNewTrackingFrame
                .global CamIntAsm_waitForNewDumpFrame
                .global CamIntAsm_acquireDumpLine
                .global CamIntAsm_acquireTrackingLine
                .global SIG_INTERRUPT0
                .global SIG_INTERRUPT1
                .global SIG_OVERFLOW0
                .global SIG_OVERFLOW1
                
;*****************************************************************              
;       Function Name: CamIntAsm_waitForNewTrackingFrame
;       Function Description: This function is responsible for
;       going to sleep until a new frame begins (indicated by
;       VSYNC transitioning from low to high.  This will wake
;       the "VSYNC sleep" up and allow it to continue with 
;       the acquireLine function, where the system waits for
;       an "HREF sleep" that we use to synchronize with the
;       data.  
;       Inputs:  r25 - MSB of currentLineBuffer
;                r24 - LSB of currentLineBuffer
;                                r23 - MSB of colorMap
;                                r22 - LSB of colorMap
;       Outputs: none
;       NOTES: This function doesn't really return...it sorta just
;       floats into the acquireLine function after the "VSYNC sleep"
;       is awoken, then begins processing the line data.  Once
;               176 pixels are sampled (and the counter overflows), then
;               an interrupt will occur, the 'T' bit in the SREG will be
;               set, and the function will return.
;*****************************************************************
                
CamIntAsm_waitForNewTrackingFrame:
                sbi             _SFR_IO_ADDR(PORTD),PD6  ; For testing...
                cbi             _SFR_IO_ADDR(PORTD),PD6         
                sleep

;*****************************************************************
; REMEMBER...everything from here on out is critically timed to be
; synchronized with the flow of pixel data from the camera...
;*****************************************************************

CamIntAsm_acquireTrackingLine:
                brts    _cleanUp
                ;sbi            _SFR_IO_ADDR(PORTD),PD6 ; For testing...
                ;cbi            _SFR_IO_ADDR(PORTD),PD6
        
        in      tmp1,_SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actually
        ori     tmp1, 0x07                 ; feed Timer1
        out     _SFR_IO_ADDR(TCCR1B),tmp1 
                                                                                ; The line is about to start...         
                ldi     pixelCount,0                    ; Initialize the RLE stats...
                ldi             pixelRunStart,PIXEL_RUN_START_INITIAL   ; Remember, we always calculate
                                                                                                                ; the pixel run length as
                                                                                                                ; TCNT1L - pixelRunStart
                
                ldi             lastColor,0x00                          ; clear out the last color before we start
                
                mov     XH,currLineBuffHigh     ; Load the pointer to the current line
                mov             XL,currLineBuffLow              ; buffer into the X pointer regs                 
                
                mov     ZH,colorMapHigh         ; Load the pointers to the membership
                mov             ZL,colorMapLow                  ; lookup tables (ZL and YL will be overwritten
                mov     YH,colorMapHigh                 ; as soon as we start reading data) to Z and Y
                
                in              tmp1, _SFR_IO_ADDR(TIMSK)                       ; enable TIMER1 to start counting
                ori             tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK       ; external PCLK pulses and interrupt on 
                out             _SFR_IO_ADDR(TIMSK),tmp1                        ; overflow
                
                ldi     tmp1,PIXEL_RUN_START_INITIAL    ; set up the TCNT1 to overflow (and
                ldi     tmp2,0xFF                                               ; interrupts) after 176 pixels          
                out     _SFR_IO_ADDR(TCNT1H),tmp2               
                out     _SFR_IO_ADDR(TCNT1L),tmp1                               
                
                mov             YL,colorMapLow          
                
                in              tmp1, _SFR_IO_ADDR(GICR)        ; enable the HREF interrupt...remember, we
                                                                                        ; only use this interrupt to synchronize
                                                                                        ; the beginning of the line
                ori     tmp1, HREF_INTERRUPT_ENABLE_MASK
                out             _SFR_IO_ADDR(GICR), tmp1
                
;*******************************************************************************************
;   Track Frame handler 
;*******************************************************************************************            
                
_trackFrame:            
                sbi             _SFR_IO_ADDR(PORTD),PD6
                sleep   ; ...And we wait...
                
        ; Returning from the interrupt/sleep wakeup will consume
        ; 14 clock cycles (7 to wakeup from idle sleep, 3 to vector, and 4 to return)   

        ; Disable the HREF interrupt
                cbi             _SFR_IO_ADDR(PORTD),PD6
                in              tmp1, _SFR_IO_ADDR(GICR)
                andi    tmp1, HREF_INTERRUPT_DISABLE_MASK
                out             _SFR_IO_ADDR(GICR), tmp1
                
        ; A couple of NOPs are needed here to sync up the pixel data...the number (2)
        ; of NOPs was determined emperically by trial and error.
                nop
                nop
_acquirePixelBlock:                                                     ;                                                       Clock Cycle Count
                in              ZL,RB_PORT                              ; sample the red value (PINB)           (1)
                in              YL,G_PORT                               ; sample the green value (PINC)         (1)
                andi    YL,0x0F                                 ; clear the high nibble                         (1)
                ldd             color,Z+RED_MEM_OFFSET          ; lookup the red membership                     (2)
                in              ZL,RB_PORT                              ; sample the blue value (PINB)          (1)
                ldd             greenData,Y+GREEN_MEM_OFFSET; lookup the green membership               (2)
                ldd             blueData,Z+BLUE_MEM_OFFSET      ; lookup the blue membership            (2)
                and             color,greenData                         ; mask memberships together                     (1)
                and             color,blueData                          ; to produce the final color            (1)
                brts    _cleanUpTrackingLine            ; if some interrupt routine has         (1...not set)
                                                                                        ; come in and set our T flag in 
                                                                                        ; SREG, then we need to hop out
                                                                                        ; and blow away this frames data (common cleanup)                                                                       
                cp              color,lastColor                 ; check to see if the run continues     (1)
                breq    _acquirePixelBlock              ;                                                                       (2...equal)
                                                                                        ;                                                                       ___________
                                                                                        ;                                                               16 clock cycles                 
                                                                                        ; (16 clock cycles = 1 uS = 1 pixelBlock time)
                
                ; Toggle the debug line to indicate a color change
                sbi     _SFR_IO_ADDR(PORTD),PD6
                nop
                cbi             _SFR_IO_ADDR(PORTD),PD6
                
                mov             tmp2,pixelRunStart                              ; get the count value of the
                                                                                                ; current pixel run
                in              pixelCount,_SFR_IO_ADDR(TCNT1L) ; get the current TCNT1 value 
                mov     pixelRunStart,pixelCount                ; reload pixelRunStart for the
                                                                                                ; next run
                sub             pixelCount,tmp2                         ; pixelCount = TCNT1L - pixelRunStart
                                                                                
                st              X+,lastColor                    ; record the color run in the current line buffer
                st              X+,pixelCount                   ; with its length
                mov             lastColor,color                 ; set lastColor so we can figure out when it changes
                
                nop                                                             ; waste one more cycle for a total of 16
                rjmp    _acquirePixelBlock      
                
; _cleanUpTrackingLine is used to write the last run length block off to the currentLineBuffer so
; that all 176 pixels in the line are accounted for.
_cleanUpTrackingLine:           
                ldi             pixelCount,0xFF         ; the length of the last run is ALWAYS 0xFF minus the last
                sub             pixelCount,pixelRunStart        ; pixelRunStart
                
                inc             pixelCount                              ; increment pixelCount since we actually need to account
                                                                                ; for the overflow of TCNT1
                                                                                
                st              X+,color                                ; record the color run in the current line buffer
                st              X,pixelCount            
                rjmp    _cleanUp
                
_cleanUpDumpLine:               
                ; NOTE: If serial data is received, to interrupt the tracking of a line, we'll
                ; get a EV_SERIAL_DATA_RECEIVED event, and the T bit set so we will end the
                ; line's processing...however, the PCLK will keep on ticking for the rest of
                ; the frame/line, which will cause the TCNT to eventually overflow and
                ; interrupt us, generating a EV_ACQUIRE_LINE_COMPLETE event.  We don't want
                ; this, so we need to actually turn off the PCLK counting each time we exit
                ; this loop, and only turn it on when we begin acquiring lines....
        ; NOT NEEDED FOR NOW...
                ;in             tmp1, _SFR_IO_ADDR(TIMSK)                       ; disable TIMER1 to stop counting
                ;andi   tmp1, DISABLE_PCLK_TIMER1_OVERFLOW_BITMASK      ; external PCLK pulses
                ;out            _SFR_IO_ADDR(TIMSK),tmp1

_cleanUp:
        ; Disable the external clocking of the Timer1 counter 
        in      tmp1, _SFR_IO_ADDR(TCCR1B)
        andi    tmp1, 0xF8
        out     _SFR_IO_ADDR(TCCR1B),tmp1
                
                ; Toggle the debug line to indicate the line is complete
                sbi     _SFR_IO_ADDR(PORTD),PD6
                cbi             _SFR_IO_ADDR(PORTD),PD6
                clt                             ; clear out the T bit since we have detected
                                                ; the interruption and are exiting to handle it
_exit:
                ret
                
;*****************************************************************              
;       Function Name: CamIntAsm_waitForNewDumpFrame
;       Function Description: This function is responsible for
;       going to sleep until a new frame begins (indicated by
;       VSYNC transitioning from low to high.  This will wake
;       the "VSYNC sleep" up and allow it to continue with 
;       acquiring a line of pixel data to dump out to the UI.
;       Inputs:  r25 - MSB of currentLineBuffer
;                r24 - LSB of currentLineBuffer
;                                r23 - MSB of prevLineBuffer
;                                r22 - LSB of prevLineBuffer
;       Outputs: none
;       NOTES: This function doesn't really return...it sorta just
;       floats into the acquireDumpLine function after the "VSYNC sleep"
;       is awoken.
;*****************************************************************              
CamIntAsm_waitForNewDumpFrame:
                sbi             _SFR_IO_ADDR(PORTD),PD6  ; For testing...
                cbi             _SFR_IO_ADDR(PORTD),PD6
                sleep

;*****************************************************************
; REMEMBER...everything from here on out is critically timed to be
; synchronized with the flow of pixel data from the camera...
;*****************************************************************

CamIntAsm_acquireDumpLine:
                brts    _cleanUp
                ;sbi            _SFR_IO_ADDR(PORTD),PD6 ; For testing...
                ;cbi            _SFR_IO_ADDR(PORTD),PD6
                
                mov     XH,currLineBuffHigh     ; Load the pointer to the current line
                mov             XL,currLineBuffLow              ; buffer into the X pointer regs

                mov             YH,prevLineBuffHigh             ; Load the pointer to the previous line
                mov             YL,prevLineBuffLow      ; buffer into the Y pointer regs
                
                ldi     tmp1,PIXEL_RUN_START_INITIAL    ; set up the TCNT1 to overflow (and
                ldi     tmp2,0xFF                                               ; interrupts) after 176 pixels          
                out     _SFR_IO_ADDR(TCNT1H),tmp2               
                out     _SFR_IO_ADDR(TCNT1L),tmp1               
                
        in      tmp1, _SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actually
        ori     tmp1, 0x07                 ; feed Timer1
        out     _SFR_IO_ADDR(TCCR1B),tmp1
        nop
        
                in              tmp1, _SFR_IO_ADDR(TIMSK)                       ; enable TIMER1 to start counting
                ori             tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK       ; external PCLK pulses and interrupt on 
                out             _SFR_IO_ADDR(TIMSK),tmp1                        ; overflow                      
                
                in              tmp1, _SFR_IO_ADDR(GICR)        ; enable the HREF interrupt...remember, we
                                                                                        ; only use this interrupt to synchronize
                                                                                        ; the beginning of the line
                ori     tmp1, HREF_INTERRUPT_ENABLE_MASK
                out             _SFR_IO_ADDR(GICR), tmp1
                
;*******************************************************************************************
;   Dump Frame handler 
;*******************************************************************************************            
                
_dumpFrame:             
                sbi             _SFR_IO_ADDR(PORTD),PD6
                sleep   ; ...And we wait...

                cbi             _SFR_IO_ADDR(PORTD),PD6
                in              tmp1, _SFR_IO_ADDR(GICR)                        ; disable the HREF interrupt
                andi    tmp1, HREF_INTERRUPT_DISABLE_MASK       ; so we don't get interrupted
                out             _SFR_IO_ADDR(GICR), tmp1                        ; while dumping the line
        
                nop             ; Remember...if we ever remove the "cbi" instruction above,
                                ; we need to add two more NOPs to cover this
    
; Ok...the following loop needs to run in 8 clock cycles, so we can get every
; pixel in the line...this shouldn't be a problem, since the PCLK timing was
; reduced by a factor of 2 whenever we go to dump a line (this is to give us
; enough time to do the sampling and storing of the pixel data).  In addition,
; it is assumed that we will have to do some minor processing on the data right
; before we send it out, like mask off the top 4-bits of each, and then pack both
; low nibbles into a single byte for transmission...we just don't have time to
; do that here (only 8 instruction cycles :-)  )
_sampleDumpPixel:
                in              tmp1,G_PORT                             ; sample the G value                                    (1)
                in              tmp2,RB_PORT                    ; sample the R/B value                                  (1)
                st              X+,tmp1                                 ; store to the currLineBuff and inc ptrs(2)
                st              Y+,tmp2                                 ; store to the prevLineBuff and inc ptrs(2)
                brtc    _sampleDumpPixel                ; loop back unless flag is set                  (2...if not set)
                                                                                ;                                                                       ___________
                                                                                ;                                                                       8 cycles normally
                                                                                                                                                        
                ; if we make it here, it means the T flag is set, and we must have been interrupted
                ; so we need to exit (what if we were interrupted for serial? should we disable it?)
                rjmp    _cleanUpDumpLine

;***********************************************************
;       Function Name: <interrupt handler for External Interrupt0> 
;       Function Description: This function is responsible
;       for handling a rising edge on the Ext Interrupt 0.  This
;       routine simply returns, since we just want to wake up
;       whenever the VSYNC transitions (meaning the start of a new
;       frame).
;       Inputs:  none
;       Outputs: none
;***********************************************************
SIG_INTERRUPT0:
; This will wake us up when VSYNC transitions high...we just want to return
                reti
                
;***********************************************************
;       Function Name: <interrupt handler for External Interrupt1> 
;       Function Description: This function is responsible
;       for handling a falling edge on the Ext Interrupt 1.  This
;       routine simply returns, since we just want to wake up
;       whenever the HREF transitions (meaning the pixels 
;       are starting after VSYNC transitioned, and we need to
;       start acquiring the pixel blocks
;       Inputs:  none
;       Outputs: none
;***********************************************************    
SIG_INTERRUPT1:
; This will wake us up when HREF transitions high...we just want to return
                reti
                
;***********************************************************
;       Function Name: <interrupt handler for Timer0 overflow>
;       Function Description: This function is responsible
;       for handling the Timer0 overflow (hooked up to indicate
;       when we have reached the number of HREFs required in a
;       single frame).  We set the T flag in the SREG to
;       indicate to the _acquirePixelBlock routine that it needs
;       to exit, and then set the appropriate action to take in
;       the eventList of the Executive module.
;       Inputs:  none
;       Outputs: none
;   Note: Originally, the HREF pulses were also going to
;   be counted by a hardware counter, but it didn't end up
;   being necessary
;***********************************************************
;SIG_OVERFLOW0:
;               set                             ; set the T bit in SREG
;               lds             tmp1,eventBitmask
;               ori             tmp1,EV_ACQUIRE_FRAME_COMPLETE
;               sts             eventBitmask,tmp1
;               reti
                
;***********************************************************
;       Function Name: <interrupt handler for Timer1 overflow>
;       Function Description: This function is responsible
;       for handling the Timer1 overflow (hooked up to indicate
;       when we have reached the end of a line of pixel data,
;       since PCLK is hooked up to overflow TCNT1 after 176 
;       pixels).  This routine generates an acquire line complete
;       event in the fastEventBitmask, which is streamlined for
;       efficiency reasons.
;***********************************************************
SIG_OVERFLOW1:                          
                lds             tmp1,fastEventBitmask                   ; set a flag indicating
                ori             tmp1,FEV_ACQUIRE_LINE_COMPLETE  ; a line is complete
                sts             fastEventBitmask,tmp1
                set             ; set the T bit in SREG 
                ;sbi            _SFR_IO_ADDR(PORTD),PD6 ; For testing...
                ;cbi            _SFR_IO_ADDR(PORTD),PD6 ; For testing...

                reti

; This is the default handler for all interrupts that don't
; have handler routines specified for them.
        .global __vector_default              
__vector_default:
        reti

        .end