video

Appendix 2: Video Code

//Gustavo Bitdinger - gbb7

//Rangarajan Rajagopalan - rr234

//ECE 476 Final Project - Weatherdog

//Mon. May 2, 2005

#pragma regalloc- //I allocate the registers myself

#pragma optsize- //optimize for speed

#include <Mega32.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <delay.h>

#include <string.h>

//cycles = 63.625 * 16 Note NTSC is 63.55

//but this line duration makes each frame exactly 1/60 sec

//which is nice for keeping a realtime clock

#define lineTime 1018

#define begin {

#define end }

//screen line definitions

#define ScreenTop 30

#define ScreenBot 230

#define width 126

#define length 99

#define inner_top 11

#define inner_bottom 76

//NOTE that v1 to v8 and i must be in registers!

#define LCDwidth 16

//define some states

#define PLAY 0

#define WAIT1 1

#define WAIT2 2

#pragma regalloc+

//video synchronizationvariables

char syncON, syncOFF;

int LineCount;

unsigned char keyboard_input; //input from EITHER keyboard or PC

char screen[1600], t, ts[10], temp_string[2];

//some strings to print to the TV

char program_string[] = "WEATHERDOG";

char copyright_string[] = "C.2005";

char input_string[] = "SEARCH@ICAO@CODE:@";

char result_temperature[] = "TEMP@DEG@F@@@";

char result_humidity[] = "HUMID@PERCENT";

char result_wind[] = "WIND MPH@@@@@";

char result_visibility[] = "VISIBILITY@MI";

char blankStr[] = " ";

char blankStr1[] = " ";

char blankStr2[] = " ";

char small_blankStr[] = "@@@@@@@@@";

char searching[] = "SEARCHING";

int index; //index of where cursor for input search is

int index1; //index for where cursor of return value from PC is

unsigned char blank_clear; //a state variable that decides what on the screen has been cleared on a PC return of data

unsigned char done_clear; //indicates that all screen clearing has been finished

unsigned char from_pc; //indicates if input over SPI is from keyboard or PC

unsigned char tv_position; //indicates which parameter returned by the PC is being output to the TV

unsigned char not_displayed; //indicates if a character is unknown and thus not to be displayed

//Point plot lookup table

//One bit masks

flash char pos[8]={0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01};

//define some character bitmaps

//5x7 characters

flash char bitmap[41][7]={

//0

0b01110000,

0b10001000,

0b10011000,

0b10101000,

0b11001000,

0b10001000,

0b01110000,

//1

0b00100000,

0b01100000,

0b00100000,

0b01110000,

//2

0b01110000,

0b10001000,

0b00001000,

0b00010000,

0b00100000,

0b01000000,

0b11111000,

//3

0b11111000,

0b00010000,

0b00100000,

0b00010000,

0b00001000,

0b10001000,

0b01110000,

//4

0b00010000,

0b00110000,

0b01010000,

0b10010000,

0b11111000,

0b00010000,

//5

0b11111000,

0b10000000,

0b11110000,

0b00001000,

0b10001000,

0b01110000,

//6

0b01000000,

0b10000000,

0b11110000,

0b10001000,

0b01110000,

//7

0b11111000,

0b00001000,

0b00010000,

0b00100000,

0b01000000,

0b10000000,

//8

0b01110000,

0b10001000,

0b01110000,

0b10001000,

0b01110000,

//9

0b01110000,

0b10001000,

0b01111000,

0b00001000,

0b00010000,

//A

0b01110000,

0b10001000,

0b11111000,

0b10001000,

//B

0b11110000,

0b10001000,

0b11110000,

0b10001000,

0b11110000,

//C

0b01110000,

0b10001000,

0b10000000,

0b10001000,

0b01110000,

//D

0b11110000,

0b10001000,

0b11110000,

//E

0b11111000,

0b10000000,

0b11111000,

0b10000000,

0b11111000,

//F

0b11111000,

0b10000000,

0b11111000,

0b10000000,

//G

0b01110000,

0b10001000,

0b10000000,

0b10011000,

0b10001000,

0b01110000,

//H

0b10001000,

0b11111000,

0b10001000,

//I

0b01110000,

0b00100000,

0b01110000,

//J

0b00111000,

0b00010000,

0b10010000,

0b01100000,

//K

0b10001000,

0b10010000,

0b10100000,

0b11000000,

0b10100000,

0b10010000,

0b10001000,

//L

0b10000000,

0b11111000,

//M

0b10001000,

0b11011000,

0b10101000,

0b10001000,

//N

0b10001000,

0b11001000,

0b10101000,

0b10011000,

0b10001000,

//O

0b01110000,

0b10001000,

0b01110000,

//P

0b11110000,

0b10001000,

0b11110000,

0b10000000,

//Q

0b01110000,

0b10001000,

0b10101000,

0b10010000,

0b01101000,

//R

0b11110000,

0b10001000,

0b11110000,

0b10100000,

0b10010000,

0b10001000,

//S

0b01111000,

0b10000000,

0b01110000,

0b00001000,

0b11110000,

//T

0b11111000,

0b00100000,

//U

0b10001000,

0b01110000,

//V

0b10001000,

0b01010000,

0b00100000,

//W

0b10001000,

0b10101000,

0b01010000,

//X

0b10001000,

0b01010000,

0b00100000,

0b01010000,

0b10001000,

//Y

0b10001000,

0b01010000,

0b00100000,

//Z

0b11111000,

0b00001000,

0b00010000,

0b00100000,

0b01000000,

0b10000000,

0b11111000,

//figure1

0b01110000,

0b00100000,

0b01110000,

0b10101000,

0b00100000,

0b01010000,

0b10001000,

//figure2

0b01110000,

0b10101000,

0b01110000,

0b00100000,

0b01010000,

0b10001000,

//<space> = ']'

0b00000000,

//.

0b00000000,

0b01000100,

0b00000000,

//:

0b00000000,

0b01000100,

0b00000000,

0b01000100,

0b00000000

};

//================================

//3x5 font numbers, then letters

//packed two per definition for fast

//copy to the screen at x-position divisible by 4

flash char smallbitmap[39][5]={

//0

0b11101110,

0b10101010,

0b11101110,

//1

0b01000100,

0b11001100,

0b01000100,

0b11101110,

//2

0b11101110,

0b00100010,

0b11101110,

0b10001000,

0b11101110,

//3

0b11101110,

0b00100010,

0b11101110,

0b00100010,

0b11101110,

//4

0b10101010,

0b11101110,

0b00100010,

//5

0b11101110,

0b10001000,

0b11101110,

0b00100010,

0b11101110,

//6

0b11001100,

0b10001000,

0b11101110,

0b10101010,

0b11101110,

//7

0b11101110,

0b00100010,

0b01000100,

0b10001000,

//8

0b11101110,

0b10101010,

0b11101110,

0b10101010,

0b11101110,

//9

0b11101110,

0b10101010,

0b11101110,

0b00100010,

0b01100110,

//:

0b00000000,

0b01000100,

0b00000000,

0b01000100,

0b00000000,

0b11101110,

0b00000000,

0b11101110,

0b00000000,

//blank

0b00000000,

//A

0b11101110,

0b10101010,

0b11101110,

0b10101010,

//B

0b11001100,

0b10101010,

0b11101110,

0b10101010,

0b11001100,

//C

0b11101110,

0b10001000,

0b11101110,

//D

0b11001100,

0b10101010,

0b11001100,

//E

0b11101110,

0b10001000,

0b11101110,

0b10001000,

0b11101110,

//F

0b11101110,

0b10001000,

0b11101110,

0b10001000,

//G

0b11101110,

0b10001000,

0b10101010,

0b11101110,

//H

0b10101010,

0b11101110,

0b10101010,

//I

0b11101110,

0b01000100,

0b11101110,

//J

0b00100010,

0b10101010,

0b11101110,

//K

0b10001000,

0b10101010,

0b11001100,

0b10101010,

//L

0b10001000,

0b11101110,

//M

0b10101010,

0b11101110,

0b10101010,

//N

0b00000000,

0b11001100,

0b10101010,

//O

0b01000100,

0b10101010,

0b01000100,

//P

0b11101110,

0b10101010,

0b11101110,

0b10001000,

//Q

0b01000100,

0b10101010,

0b11101110,

0b01100110,

//R

0b11101110,

0b10101010,

0b11001100,

0b11101110,

0b10101010,

//S

0b11101110,

0b10001000,

0b11101110,

0b00100010,

0b11101110,

//T

0b11101110,

0b01000100,

//U

0b10101010,

0b11101110,

//V

0b10101010,

0b01000100,

//W

0b10101010,

0b11101110,

0b10101010,

//X

0b00000000,

0b10101010,

0b01000100,

0b10101010,

//Y

0b10101010,

0b01000100,

//Z

0b11101110,

0b00100010,

0b01000100,

0b10001000,

0b11101110

};

//=================================//plot one point

//at x,y with color 1=white 0=black 2=invert

#pragma warn-

void video_pt(char x, char y, char c)

begin

#asm

; i=(x>>3) + ((int)y<<4) ; the byte with the pixel in it

push r16

ldd r30,y+2 ;get x

lsr r30

lsr r30 ;divide x by 8

ldd r12,y+1 ;get y

lsl r12 ;mult y by 16

clr r13

lsl r12

rol r13

lsl r12

rol r13

lsl r12

rol r13

add r12, r30 ;add in x/8

;v2 = screen[i]; r5

;v3 = pos[x & 7]; r6

;v4 = c r7

ldi r30,low(_screen)

ldi r31,high(_screen)

add r30, r12

adc r31, r13

ld r5,Z ;get screen byte

ldd r26,y+2 ;get x

ldi r27,0

andi r26,0x07 ;form x & 7

ldi r30,low(_pos*2)

ldi r31,high(_pos*2)

add r30,r26

adc r31,r27

lpm r6,Z

ld r16,y ;get c

;if (v4==1) screen[i] = v2 | v3 ;

;if (v4==0) screen[i] = v2 & ~v3;

;if (v4==2) screen[i] = v2 ^ v3 ;

cpi r16,1

brne tst0

or r5,r6

tst0:

cpi r16,0

brne tst2

com r6

and r5,r6

tst2:

cpi r16,2

brne writescrn

eor r5,r6

writescrn:

ldi r30,low(_screen)

ldi r31,high(_screen)

add r30, r12

adc r31, r13

st Z, r5 ;write the byte back to the screen

pop r16

#endasm

end

#pragma warn+

//=================================// put a big character on the screen

// c is index into bitmap

void video_putchar(char x, char y, char c)

begin

v7 = x;

for (v6=0;v6<7;v6++)

begin

v1 = bitmap[c][v6];

v8 = y+v6;

video_pt(v7, v8, (v1 & 0x80)==0x80);

video_pt(v7+1, v8, (v1 & 0x40)==0x40);

video_pt(v7+2, v8, (v1 & 0x20)==0x20);

video_pt(v7+3, v8, (v1 & 0x10)==0x10);

video_pt(v7+4, v8, (v1 & 0x08)==0x08);

end

//=================================// put a string of big characters on the screen

void video_puts(char x, char y, char *str)

begin

char i ;

for (i=0; str[i]!=0; i++)

begin

if (str[i]>=0x30 && str[i]<0x3a) begin //a number

video_putchar(x,y,str[i]-0x30);

end

else if (str[i] == 32) begin //a space

video_putchar(x,y,38);

end

else if (str[i] == 8) begin //a backspace

video_putchar(x,y,38);

end

else if (str[i] == 46) begin //a ':'

video_putchar(x,y,39);

end

else if (str[i] == 58) begin //a '.'

video_putchar(x,y,40);

end

else if (str[i]>=65 && str[i]<=90) begin //an alphabetical character

video_putchar(x,y,str[i]-0x40+9);

end

else begin //undefined

not_displayed = 1;

end

x = x+6;

end

//=================================// put a small character on the screen - special mode

// x-cood must be divisible by 4

// c is index into bitmap

void video_smallchar(char x, char y, char c)

begin

char mask;

i=((int)x>>3) + ((int)y<<4) ;

if (x == (x & 0xf8)) mask = 0x0f; //f8

else mask = 0xf0;

screen[i] = (screen[i] & mask) | (smallbitmap[c][0] & ~mask);

screen[i+16] = (screen[i+16] & mask) | (smallbitmap[c][1] & ~mask);

screen[i+32] = (screen[i+32] & mask) | (smallbitmap[c][2] & ~mask);

screen[i+48] = (screen[i+48] & mask) | (smallbitmap[c][3] & ~mask);

screen[i+64] = (screen[i+64] & mask) | (smallbitmap[c][4] & ~mask);

end

//=================================// put a string of small characters on the screen

// x-cood must be divisible by 4

void video_putsmalls(char x, char y, char *str)

begin

char i ;

for (i=0; str[i]!=0; i++)

begin

if (str[i]>=0x30 && str[i]<=0x3a) begin //a number

video_smallchar(x,y,str[i]-0x30);

end

else if (str[i] == ' ') begin //a space

video_smallchar(x,y,12);

end

else begin //an alphabetical character

video_smallchar(x,y,str[i]-0x40+12);

end

x = x+4;

end

//=================================//plot a line

//at x1,y1 to x2,y2 with color 1=white 0=black 2=invert

//NOTE: this function requires signed chars

//Code is from David Rodgers,

//"Procedural Elements of Computer Graphics",1985

void video_line(char x1, char y1, char x2, char y2, char c)

begin

int e;

signed char dx,dy,j, temp;

signed char s1,s2, xchange;

signed char x,y;

x = x1;

y = y1;

dx = cabs(x2-x1);

dy = cabs(y2-y1

);

s1 = csign(x2-x1);

s2 = csign(y2-y1);

xchange = 0;

if (dy>dx)

begin

temp = dx;

dx = dy;

dy = temp;

xchange = 1;

end

e = ((int)dy<<1) - dx;

for (j=0; j<=dx; j++)

begin

video_pt(x,y,c) ;

if (e>=0)

begin

if (xchange==1) x = x + s1;

else y = y + s2;

e = e - ((int)dx<<1);

end

if (xchange==1) y = y + s2;

else x = x + s1;

e = e + ((int)dy<<1);

end

//=================================//return the value of one point

//at x,y with color 1=white 0=black 2=invert

char video_set(char x, char y)

begin

//The following construction

//detects exactly one bit at the x,y location

i=((int)x>>3) + ((int)y<<4) ;

return ( screen[i] & 1<<(7-(x & 0x7)));

end

//=================================//This is the sync generator and raster generator. It MUST be entered from

//sleep mode to get accurate timing of the sync pulses

#pragma warn-

interrupt [TIM1_COMPA] void t1_cmpA(void) begin

SPCR = 0b01000000;

//start the Horizontal sync pulse

PORTD = syncON;

//update the curent scanline number

LineCount ++ ;

//begin inverted (Vertical) synch after line 247

if (LineCount==248) begin

syncON = 0b00100000;

syncOFF = 0;

end

//back to regular sync after line 250

if (LineCount==251) begin

syncON = 0;

syncOFF = 0b00100000;

end

//start new frame after line 262

if (LineCount==263)

begin

LineCount = 1;

end

delay_us(2); //adjust to make 5 us pulses

//end sync pulse

PORTD= syncOFF;

if (LineCount<ScreenBot && LineCount>=ScreenTop)

begin

//compute byte index for beginning of the next line

//left-shift 4 would be individual lines

// <<3 means line-double the pixels

//The 0xfff8 truncates the odd line bit

//i=(LineCount-ScreenTop)<<3 & 0xfff8; //

#asm

push r16

lds r12, _LineCount

lds r13, _Linecount+1

ldi r16, 30

sub r12, r16

ldi r16,0

sbc r13, r16

lsl r12

rol r13

lsl r12

rol r13

lsl r12

rol r13

mov r16,r12

andi r16,0xf0

mov r12,r16

pop r16

#endasm

//load 16 registers with screen info

#asm

push r14

push r15

push r16

push r17

push r18

push r19

push r26

push r27

ldi r26,low(_screen) ;base address of screen

ldi r27,high(_screen)

add r26,r12 ;offset into screen (add i)

adc r27,r13

ld r4,x+ ;load 16 registers and inc pointer

ld r5,x+

ld r6,x+

ld r7,x+

ld r8,x+

ld r9,x+

ld r10,x+

ld r11,x+

ld r12,x+

ld r13,x+

ld r14,x+

ld r15,x+

ld r16,x+

ld r17,x+

ld r18,x+

ld r19,x

pop r27

pop r26

#endasm

delay_us(4); //adjust to center image on screen

//blast 16 bytes to the screen

#asm

;but first a macro to make the code shorter

;the macro takes a register number as a parameter

;and dumps its bits serially to portD.6

;the nop can be eliminated to make the display narrower

.macro videobits ;regnum

BST @0,7

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,6

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,5

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,4

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,3

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,2

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,1

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

BST @0,0

IN R30,0x12

BLD R30,6

nop

OUT 0x12,R30

.endm

videobits r4 ;video line -- byte 1

videobits r5 ;byte 2

videobits r6 ;byte 3

videobits r7 ;byte 4

videobits r8 ;byte 5

videobits r9 ;byte 6

videobits r10 ;byte 7

videobits r11 ;byte 8

videobits r12 ;byte 9

videobits r13 ;byte 10

videobits r14 ;byte 11

videobits r15 ;byte 12

videobits r16 ;byte 13

videobits r17 ;byte 14

videobits r18 ;byte 15

videobits r19 ;byte 16

clt ;clear video after the last pixel on the line

IN R30,0x12

BLD R30,6

OUT 0x12,R30

pop r19

pop r18

pop r17

pop r16

pop r15

pop r14

#endasm

end

#pragma warn+

//=================================// Initializations

void initialize(void) begin

//init timer 1 to generate sync

OCR1A = lineTime; //One NTSC line

TCCR1B = 9; //full speed; clear-on-match

TCCR1A = 0x00; //turn off pwm and oc lines

TIMSK = 0x10; //enable interrupt T1 cmp

//init ports

DDRD = 0x60; //video out and switches

//D.5 is sync:1000 ohm + diode to 75 ohm resistor

//D.6 is video:330 ohm + diode to 75 ohm resistor

//initialize synch constants

LineCount = 1;

syncON = 0b00000000;

syncOFF = 0b00100000;

//init software timer

t=0;

//enable sleep mode

MCUCR = 0b10000000; //VIDEO ONLY

//Print "WEATHERDOG"

video_puts(3,3,program_string);

//Print "C.2005"

video_puts(90,3,copyright_string);

//side lines

video_line(0,0,0,length,1);

video_line(width,0,width,length,1);

//top & bottom lines

video_line(0,0,width,0,1);

video_line(0,length,width,length,1);

video_line(0,inner_top,width,inner_top,1);

//middle line

video_line(0,34,width,34,1);

from_pc = 0;

video_putsmalls(4,16,input_string);

video_putsmalls(4,50,result_temperature);

video_putsmalls(4,60,result_humidity);

video_putsmalls(4,70,result_wind);

video_putsmalls(4,80,result_visibility);

//bit 7: interrupt enable

//bit 6: SPI enable

//bit 5: data bit order, 0:MSB first

//bit 4: master/slave select, 0:slave

//bit 3: SCK polarity

//bit 2: SCK phase

//bits 1 and 0: SCK speed; 00=CLK/4

SPCR = 0b01000000;

//bit 7: SCK

//bit 6: MISO (master in, slave out)

//bit 5: MOSI (master out, slave in)

//bit 4: !SS (slave select)

DDRB = 0x01001111;

index = 3; //start search string index at x=3

index1 = 65; //place all return values from pc at x=65

blank_clear = 0;

done_clear = 0;

tv_position = 0;

not_displayed = 0;

#asm ("sei");

end

//=================================

void main(void) begin

initialize();

while(1) begin

//stall here until next line starts

//sleep enable; mode=idle

//use sleep to make entry into sync ISR uniform time

#asm ("sleep");

if (LineCount==231) begin

if ((SPSR & 0x80)>>7) begin

//clear everything before outputing keyboard stuff

if (blank_clear == 8) begin

video_putsmalls(84,16,small_blankStr); //blank out "searching" indicator

done_clear = 1;

blank_clear = 0;

keyboard_input = SPDR;

end

else if (blank_clear == 7) begin

video_puts(56,26,blankStr); //clear second half of old search string

blank_clear = 8;

keyboard_input = SPDR;

end

else if (blank_clear == 6) begin

video_puts(65,78,blankStr); //clear old return visibility value

blank_clear =7;

keyboard_input = SPDR;

end

else if (blank_clear == 5) begin

video_puts(65,68,blankStr); //clear old return wind value

blank_clear = 6;

keyboard_input = SPDR;

end

else if (blank_clear == 4) begin

video_puts(65,58,blankStr); //clear old return humidity value

blank_clear = 5;

keyboard_input = SPDR;

end

else if (blank_clear == 3) begin

video_puts(65,48,blankStr); //clear old return temperature value

blank_clear = 4;

keyboard_input = SPDR;

end

else if (blank_clear == 2) begin //acts as a second short delay

blank_clear = 3;

keyboard_input = SPDR;

end

else if (blank_clear == 1) begin //acts as a short delay

blank_clear = 2;

keyboard_input = SPDR; //concurrently get next keyboard_input from SPI interface

end

else if (blank_clear == 0) begin

keyboard_input = SPDR; //this always happens, whether it's a keyboard input or pc input

if ((keyboard_input == ';') && (tv_position == 0)) begin //first item sent back

video_puts(3,26,blankStr); //clear first half of old search string

blank_clear = 1; //begin process of clearing stuff on screen

tv_position++; //indicates now that are going to print out the time to the TV

from_pc = 1;

index = 3;

index1 = 65;

end

else if (keyboard_input == ';') begin //subsequent item sent back

from_pc = 1;

tv_position++;

index1 = 65;

end

if (from_pc == 0) begin

temp_string[0]= keyboard_input;

temp_string[1]=0;

if (keyboard_input == 8) begin //a backspace - only do if there is something to delete.

index = index-6; //adjust search string index

video_puts(index,26,temp_string); //output the new character from the pc

end

else if (keyboard_input == 0) begin //an enter

video_putsmalls(84,16,searching); //output searching indicator

end

else begin //anything else

video_puts(index,26,temp_string); //output it

index = index+6; //adjust search string index

end

else if (keyboard_input != ';') begin //dealing with a pc input

temp_string[0] = keyboard_input;

temp_string[1] = 0;

if (tv_position == 1) begin //time

//adjustment of 62 is so that time outputs starting from left of screen

video_puts(index1-62,38,blankStr2);

video_puts(index1-62,38,temp_string);

end

else if (tv_position == 2) begin //temperature

video_puts(index1,48,temp_string);

end

else if (tv_position == 3) begin //humidity

video_puts(index1,58,temp_string);

end

else if (tv_position == 4) begin //wind

video_puts(index1,68,temp_string);

end

else if (tv_position == 5) begin //visibility

video_puts(index1,78,temp_string);

end

//catch for characters that are not displayed

if (not_displayed == 0) begin

index1 = index1+6;

end

else begin

not_displayed = 0;

end

if ((keyboard_input == 0x00) && (tv_position == 5)) begin //end of inputs from PC for a search.

from_pc = 0;

done_clear = 0;

tv_position = 0;

end

end //while

end //main

Back to Main Page