Subversion Repositories svnkaklik

Compare Revisions

Ignore whitespace Rev 409 → Rev 410

/programy/C/avr/AVRcam/CamInterfaceAsm.S
0,0 → 1,490
;
; 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