Rev 151 | Blame | 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 datapixelCount = 16pixelRunStart = 17lastColor = 18tmp1 = 19 ; be sure to not use tmp1 and color simultaneouslytmp2 = 20color = 19greenData = 20blueData = 21colorMapLow = 22colorMapHigh = 23prevLineBuffLow = 22 ; overlaps with memLookupLow (but orthogonal)prevLineBuffHigh = 23 ; overlaps with memLookupHigh (but orthogonal)currLineBuffLow = 24currLineBuffHigh = 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),PD6sleep;*****************************************************************; 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),PD6in tmp1,_SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actuallyori tmp1, 0x07 ; feed Timer1out _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 - pixelRunStartldi lastColor,0x00 ; clear out the last color before we startmov XH,currLineBuffHigh ; Load the pointer to the current linemov XL,currLineBuffLow ; buffer into the X pointer regsmov ZH,colorMapHigh ; Load the pointers to the membershipmov ZL,colorMapLow ; lookup tables (ZL and YL will be overwrittenmov YH,colorMapHigh ; as soon as we start reading data) to Z and Yin tmp1, _SFR_IO_ADDR(TIMSK) ; enable TIMER1 to start countingori tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses and interrupt onout _SFR_IO_ADDR(TIMSK),tmp1 ; overflowldi tmp1,PIXEL_RUN_START_INITIAL ; set up the TCNT1 to overflow (andldi tmp2,0xFF ; interrupts) after 176 pixelsout _SFR_IO_ADDR(TCNT1H),tmp2out _SFR_IO_ADDR(TCNT1L),tmp1mov YL,colorMapLowin tmp1, _SFR_IO_ADDR(GICR) ; enable the HREF interrupt...remember, we; only use this interrupt to synchronize; the beginning of the lineori tmp1, HREF_INTERRUPT_ENABLE_MASKout _SFR_IO_ADDR(GICR), tmp1;*******************************************************************************************; Track Frame handler;*******************************************************************************************_trackFrame:sbi _SFR_IO_ADDR(PORTD),PD6sleep ; ...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 interruptcbi _SFR_IO_ADDR(PORTD),PD6in tmp1, _SFR_IO_ADDR(GICR)andi tmp1, HREF_INTERRUPT_DISABLE_MASKout _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.nopnop_acquirePixelBlock: ; Clock Cycle Countin 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 changesbi _SFR_IO_ADDR(PORTD),PD6nopcbi _SFR_IO_ADDR(PORTD),PD6mov tmp2,pixelRunStart ; get the count value of the; current pixel runin pixelCount,_SFR_IO_ADDR(TCNT1L) ; get the current TCNT1 valuemov pixelRunStart,pixelCount ; reload pixelRunStart for the; next runsub pixelCount,tmp2 ; pixelCount = TCNT1L - pixelRunStartst X+,lastColor ; record the color run in the current line bufferst X+,pixelCount ; with its lengthmov lastColor,color ; set lastColor so we can figure out when it changesnop ; waste one more cycle for a total of 16rjmp _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 lastsub pixelCount,pixelRunStart ; pixelRunStartinc pixelCount ; increment pixelCount since we actually need to account; for the overflow of TCNT1st X+,color ; record the color run in the current line bufferst X,pixelCountrjmp _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 counterin tmp1, _SFR_IO_ADDR(TCCR1B)andi tmp1, 0xF8out _SFR_IO_ADDR(TCCR1B),tmp1; Toggle the debug line to indicate the line is completesbi _SFR_IO_ADDR(PORTD),PD6cbi _SFR_IO_ADDR(PORTD),PD6clt ; 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),PD6sleep;*****************************************************************; 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),PD6mov XH,currLineBuffHigh ; Load the pointer to the current linemov XL,currLineBuffLow ; buffer into the X pointer regsmov YH,prevLineBuffHigh ; Load the pointer to the previous linemov YL,prevLineBuffLow ; buffer into the Y pointer regsldi tmp1,PIXEL_RUN_START_INITIAL ; set up the TCNT1 to overflow (andldi tmp2,0xFF ; interrupts) after 176 pixelsout _SFR_IO_ADDR(TCNT1H),tmp2out _SFR_IO_ADDR(TCNT1L),tmp1in tmp1, _SFR_IO_ADDR(TCCR1B) ; Enable the PCLK line to actuallyori tmp1, 0x07 ; feed Timer1out _SFR_IO_ADDR(TCCR1B),tmp1nopin tmp1, _SFR_IO_ADDR(TIMSK) ; enable TIMER1 to start countingori tmp1, ENABLE_PCLK_TIMER1_OVERFLOW_BITMASK ; external PCLK pulses and interrupt onout _SFR_IO_ADDR(TIMSK),tmp1 ; overflowin tmp1, _SFR_IO_ADDR(GICR) ; enable the HREF interrupt...remember, we; only use this interrupt to synchronize; the beginning of the lineori tmp1, HREF_INTERRUPT_ENABLE_MASKout _SFR_IO_ADDR(GICR), tmp1;*******************************************************************************************; Dump Frame handler;*******************************************************************************************_dumpFrame:sbi _SFR_IO_ADDR(PORTD),PD6sleep ; ...And we wait...cbi _SFR_IO_ADDR(PORTD),PD6in tmp1, _SFR_IO_ADDR(GICR) ; disable the HREF interruptandi tmp1, HREF_INTERRUPT_DISABLE_MASK ; so we don't get interruptedout _SFR_IO_ADDR(GICR), tmp1 ; while dumping the linenop ; 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 returnreti;***********************************************************; 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 returnreti;***********************************************************; 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 indicatingori tmp1,FEV_ACQUIRE_LINE_COMPLETE ; a line is completests fastEventBitmask,tmp1set ; 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