umsetzen für win-avr

[pebisoft]

hallo, kann einer mal dieses program umsetzen in winavr. es soll zeichen mit dem AVR auf dem bildschirm darstellen (fbas). da wenig c-code drin ist (das meiste sind zeichen ),müsste es eigentlich für einen c-pro. nicht schwer sein. es ist für viele interessant.
:

//video gen
//D.5 is sync:1000 ohm + diode to 75 ohm resistor
//D.6 is video:330 ohm + diode to 75 ohm resistor
                    
#include <Mega163.h>   
#include <stdio.h>

//cycles = 63.625 * 8 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 509
 
#define begin {
#define end   }
#define ScreenTop 30
#define ScreenBot 230
#define T0reload 256-60

//NOTE that the first line of CHARs must be in registers!
char syncON, syncOFF, v1, v2, v3, v4, v5, v6, v7, v8; 
int i,LineCount, time;
char ballx, bally, dx, dy;
char screen[800], t, ts[10], temp; 

flash char bitmap[13][8]={ 
	//0
    0b00000000,
	0b00111000,
	0b01000100,
	0b01000100,
	0b01000100,
	0b01000100,
	0b01000100,
	0b00111000,
	//1
	0b00000000,
	0b00010000,
	0b00110000,
	0b01010000,
	0b00010000,
	0b00010000,
	0b00010000,
	0b01111100,  
	//2
	0b00000000,
	0b00011100,
	0b00100010,
	0b00000010,
	0b00000100,
	0b00001000,
	0b00010000,
	0b00111110,
    //3
	0b00000000,
	0b00011100,
	0b00100010,
	0b00000010,
	0b00011100,
	0b00000010,
	0b00100010,
	0b00011100,
	//4
	0b00000000,
	0b00001110,
	0b00010010,
	0b00100010,
	0b00111111,
	0b00000010,
	0b00000010,
	0b00000010,
	//5
	0b00000000,
	0b00111100,
	0b00100000,
	0b00100000,
	0b00011100,
	0b00000010,
	0b00000010,
	0b00111100,
	//6
	0b00000000,
	0b00010000,
	0b00100000,
	0b00100000,
	0b00111100,
	0b00100010,
	0b00100010,
	0b00011100,
	//7
	0b00000000,
	0b00111111,
	0b00000001,
	0b00000001,
	0b00000010,
	0b00000010,
	0b00000100,
	0b00000100,
	//8
	0b00000000,
	0b00011110,
	0b00100001,
	0b00100001,
	0b00011110,
	0b00100001,
	0b00100001,
	0b00011110,
	//9
	0b00000000,
	0b00011110,
	0b00100001,
	0b00100001,
	0b00011110,
	0b00000001,
	0b00000001,
	0b00000010,
	//C
	0b00000000,
	0b00011110,
	0b00100000,
	0b00100000,
	0b00100000,
	0b00100000,
	0b00100000,
	0b00011110,
	//U
	0b00000000,
	0b01000010,
	0b01000010,
	0b01000010,
	0b01000010,
	0b01000010,
	0b01000010,
	0b00111100,
	//E
	0b00000000,
	0b00111111,
	0b00100000,
	0b00100000,
	0b00111111,
	0b00100000,
	0b00100000,
	0b00111111};


//This is the sync generator. It MUST be entered from 
//sleep mode to get accurate timing of the sync pulses
//At 8 MHz, all of the sync logic fits in the 5 uSec sync
//pulse
interrupt [TIM1_COMPA] void t1_cmpA(void)  
begin 
  //start the Horizontal sync pulse    
  PORTD = syncON;     
  //count timer 0 at 1/usec
  TCNT0=0;
  //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 
  //end sync pulse
  PORTD = syncOFF;  
end  

// put a character on the screen
// x-cood must be on divisible by 8 x position
void video_putchar(char x, char y, char c)  
begin
	i=((int)x>>3) + ((int)y<<3) ; 
	screen[i] = bitmap[c][0]; 
   	screen[i+8] = bitmap[c][1];
    screen[i+16] = bitmap[c][2];
    screen[i+24] = bitmap[c][3];
   	screen[i+32] = bitmap[c][4]; 
    screen[i+40] = bitmap[c][5];
    screen[i+48] = bitmap[c][6];
    screen[i+56] = bitmap[c][7];
end

// set up the ports and timers
void main(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 = 0xf0;		//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
   
  //init timer 0 to 1/uSec  
  TCCR0 = 2;
  
  //initialize synch constants 
  LineCount = 1;
  syncON = 0b00000000;
  syncOFF = 0b00100000;  
  
  //side lines
  for (i=0;i<799;i=i+8) 
  begin
     screen[i]=0b10000000; 
     screen[i+7]=0b00000001;
  end
  //top line & bottom lines
  for (i=0;i<8;i++) 
  begin
     screen[i]=0b11111111; 
     screen[i+792]=0b11111111;
     screen[i+88]=0b11111111; 
     screen[i+712]=0b11111111;
  end
  
  //initial ball to middle of screen
  ballx=32;
  bally=50; 
  dx = 1;
  dy = 2; 
  //The following odd construction 
  //sets exactly one bit at the x,y location
  i=((int)ballx>>3) + ((int)bally<<3) ; 
  screen[i] = 1<<(7-(ballx & 0x7)) ;
  
  //init software timer
  t=0;
  time=0;  
  
  //enable sleep mode
  MCUCR = 0b01000000;
  #asm ("sei");
  
  //The following loop executes once/video line during lines
  //1-230, then does all of the frame end processing
  while(1)
  begin
  
    //precompute pixel index for next line
    if (LineCount<ScreenBot && LineCount>=ScreenTop) 
    begin 
       //left-shift 3 would be individual lines
       // <<2 means line-double the pixels 
       //The 0xfff8 truncates the odd line bit
       i=(LineCount-ScreenTop)<<2 & 0xfff8;; 
       
   end
   
   //stall here until next line starts
    //sleep enable; mode=idle  
    //use sleep to make entry into sync ISR uniform time  
       
    #asm ("sleep"); 
     
    //Put code here to execute once/line
    //During the active portion of a line;
    //--TCNT1 goes from about 130 to about 480 
    //--Usable lines 1 to about 240
    
    if (LineCount<ScreenBot && LineCount>ScreenTop) 
    begin
      //load the pixels into registers
      v1 = screen[i]; 
      v2 = screen[i+1];
      v3 = screen[i+2];
      v4 = screen[i+3]; 
      v5 = screen[i+4]; 
      v6 = screen[i+5];
      v7 = screen[i+6];
      v8 = screen[i+7];
        
      //now blast them out to the screen
        PORTD.6=v1 & 0b10000000; 
        PORTD.6=v1 & 0b01000000;
        PORTD.6=v1 & 0b00100000; 
        PORTD.6=v1 & 0b00010000;
        PORTD.6=v1 & 0b00001000; 
        PORTD.6=v1 & 0b00000100;
        PORTD.6=v1 & 0b00000010; 
        PORTD.6=v1 & 0b00000001;
        
        PORTD.6=v2 & 0b10000000; 
        PORTD.6=v2 & 0b01000000;
        PORTD.6=v2 & 0b00100000; 
        PORTD.6=v2 & 0b00010000;
        PORTD.6=v2 & 0b00001000; 
        PORTD.6=v2 & 0b00000100;
        PORTD.6=v2 & 0b00000010; 
        PORTD.6=v2 & 0b00000001; 
        
        PORTD.6=v3 & 0b10000000; 
        PORTD.6=v3 & 0b01000000;
        PORTD.6=v3 & 0b00100000; 
        PORTD.6=v3 & 0b00010000;
        PORTD.6=v3 & 0b00001000; 
        PORTD.6=v3 & 0b00000100;
        PORTD.6=v3 & 0b00000010; 
        PORTD.6=v3 & 0b00000001; 
            
        PORTD.6=v4 & 0b10000000; 
        PORTD.6=v4 & 0b01000000;
        PORTD.6=v4 & 0b00100000; 
        PORTD.6=v4 & 0b00010000;
        PORTD.6=v4 & 0b00001000; 
        PORTD.6=v4 & 0b00000100;
        PORTD.6=v4 & 0b00000010; 
        PORTD.6=v4 & 0b00000001; 
             
        PORTD.6=v5 & 0b10000000; 
        PORTD.6=v5 & 0b01000000;
        PORTD.6=v5 & 0b00100000; 
        PORTD.6=v5 & 0b00010000;
        PORTD.6=v5 & 0b00001000; 
        PORTD.6=v5 & 0b00000100;
        PORTD.6=v5 & 0b00000010; 
        PORTD.6=v5 & 0b00000001;
             
        PORTD.6=v6 & 0b10000000; 
        PORTD.6=v6 & 0b01000000;
        PORTD.6=v6 & 0b00100000; 
        PORTD.6=v6 & 0b00010000;
        PORTD.6=v6 & 0b00001000; 
        PORTD.6=v6 & 0b00000100;
        PORTD.6=v6 & 0b00000010; 
        PORTD.6=v6 & 0b00000001; 
            
        PORTD.6=v7 & 0b10000000; 
        PORTD.6=v7 & 0b01000000;
        PORTD.6=v7 & 0b00100000; 
        PORTD.6=v7 & 0b00010000;
        PORTD.6=v7 & 0b00001000; 
        PORTD.6=v7 & 0b00000100;
        PORTD.6=v7 & 0b00000010; 
        PORTD.6=v7 & 0b00000001;
             
        PORTD.6=v8 & 0b10000000; 
        PORTD.6=v8 & 0b01000000;
        PORTD.6=v8 & 0b00100000; 
        PORTD.6=v8 & 0b00010000;
        PORTD.6=v8 & 0b00001000; 
        PORTD.6=v8 & 0b00000100;
        PORTD.6=v8 & 0b00000010; 
        PORTD.6=v8 & 0b00000001;  
      
        PORTD.6=0 ; 
    end
    
    //The following code executes during the vertical blanking
    //Code here can be as long as  63 uSec/line
    //For a total of 30 lines x 63.5 uSec/line x 8 cycles/uSec 
    // Every 60 uSec or so, you should insert a "sleep"
    //command so that the timer 1 ISR happens at a regular interval,
    //but it may not matter to most TVs
    
    if (LineCount==231)
    begin 
    	//erase old ball 
    	i=((int)ballx>>3) + ((int)bally<<3) ;
    	temp = screen[i]; 
  		screen[i] = temp ^ (1<<(7-(ballx & 0x7))); 
  		
  		//get new x
  		ballx = ballx + dx ;
    	if (ballx>61) dx = -1;
    	if (ballx<2) dx = 1;
    	//if (PIND.0==0) dx=dx*2;
    	
    	//get new y
    	bally = bally + dy ;
    	if (bally>86) dy = -1;
    	if (bally<14) dy = 1;
    	//if (PIND.1==0) dy=dy*2;
    		
    	// write new ball
    	i=((int)ballx>>3) + ((int)bally<<3) ;
    	temp =  screen[i]; 
  		screen[i] = temp | (1<<(7-(ballx & 0x7)));
    
    //	#asm ("sleep"); 
        
       if (t++ > 59)
       begin  
        t=0;
        time++;
        
        //Print "CU-ECE476" 
        video_putchar(0,2,10);
        video_putchar(1*8,2,11);
        video_putchar(2*8,2,12);
    	video_putchar(3*8,2,10);
        video_putchar(4*8,2,12);
        video_putchar(5*8,2,4);
    	video_putchar(6*8,2,7);
        video_putchar(7*8,2,6);
        //make a dash
  		i=(16>>3) + (6<<3) ; 
  		screen[i] = screen[i] | 1<<(7-(16 & 0x7)) ;
    	
    	//print the time
        sprintf(ts,"%05i",time);
        video_putchar(0,90,ts[0]-0x30);
        video_putchar(1*8,90,ts[1]-0x30);
        video_putchar(2*8,90,ts[2]-0x30);
    	video_putchar(3*8,90,ts[3]-0x30);
    	video_putchar(4*8,90,ts[4]-0x30);
       end  
        
      
    end
    
  end  //while
end  //main

mfg pebisoft

[PicNick]

Hi, pebi ! Richtige Begeisterung löst der Thread ja scheinbar nicht aus. Ich hab mir das mal Interessehalber angeschaut und den Winavr gefragt, was er davon hält.
Im Prinzip sieht er ja kaum syntaktische Probleme, is ja schließlich auch C. Wieso brauchst du Hilfe ?
Wo hast du das her ? Für (von) welchen Compiler is das ?

Zur Sache: Hast du das Zeugs schon mal laufen gesehen ? Und wie sieht das aus ? Die Sequenz, wo er die Pixeln rausbläst, kommt mir, (je nach "1" oder "0") unregelmäßig vor, müßt man noch genau behirnen.

Wo ich als ungeübter WInAvr und Atmel unsicher bin, ist die Einstellung des Timers und wie er (welchen) Sleep mode einsetzt, damit das ganze funzt.
Ein voller ASCII-Zeichengenerator würde halt ganz schön Platz brauchen,
da sollt man einen externen EPROM schießen.
laß hören ! mfg robert

[pebisoft]

hallo, diese programm läuft auf einem meg163 und stellt ein video-signal in der fbas-form dar. also fbas-signale (buchstaben) mit einem AVR auf dem bildschirm darstellen/anzeigen. habe ich aus einem englischen forum. das fernsehbild war im forum zusehen, weis aber nicht mehr welches es ist.
da ich im bascom-forum ähnliches mit dem AVR16 schon dargestellt und veröffentlicht habe (album,persönliche galerie/pebisoft) interessiert mich diese umsetzung. diese lässt sich eigentlich nur in asm darstellen, wenn es auch mit winavr ginge käme mir das entgegen.
das signal d5/d6 läuft je über einen widerstand und wird nach dem widerstand wieder zusammgeführt zum eingang fbas und als bild dargestellt.
mfg pebisoft

[PicNick]

Alles klar, (erinnert mich an die ZX81 Zeit)
Es sind ja folgende Dinge zu tun
1 das eigentliche Spiel, oder was das Werkel halt tun soll.
2 das Vorbereiten der nächsten Zeile
3 und dann halt das eigentliche rausshiften der s/w Pixel nach dem horz.Sync
Prinzipiell macht der C das Ganze um nix schlechter als der Assembler, (er läßt sich ja in die Karten gucken) grad', daß man im Assembler ein paar (wenige) Dinge etwas mehr auf den Zweck zuschneidern und dadurch optimieren kann.
bei 1 u. 2 bist du in eine höheren Sprache sicher in Summe besser dran, da krachen dir sonst die Finger.
3 ist zeitkritisch und wahrscheinlich mit inline assembler gut zu unterstützen.
Konkret: ich häng mal das, was ich hab, hier rein. is ja egal, übersetzen kann man es zumindest flagfrei, die Logik hab ich nicht überprüft, ich würde das sicher anders lösen, ich kenn mich ja.
Wenn du dich mit WinAvr auskennst, den Timer richtig aufsetzen kannst du wahrscheinlich eh besser.
Ob die Zeiten hint und vorn auch reichen, hab ich nicht nachgerechnet.
egal, schau mal rein mfg robert

[Kjion]

@PicNick

Wenn dein WinAVR da nicht meckert ists aber komisch. Ich hab mal angefangen das ganze umzusetzen, allerdings gibts da ein Problem:

PORTD.6=v5 & 0b10000000;
PORTD.6=v5 & 0b01000000;
PORTD.6=v5 & 0b00100000;
PORTD.6=v5 & 0b00010000;
PORTD.6=v5 & 0b00001000;
PORTD.6=v5 & 0b00000100;
PORTD.6=v5 & 0b00000010;
PORTD.6=v5 & 0b00000001;

Wie Zeitkritisch sind diese Dinger ?? Bzw. wie schaut der Assemblercode der dazu generiert wird aus. Das muss man nämlich in WinAVR anders lösen. Ansonsten ist aber kein Problem, musste eingentlich nicht viel ändern...

MfG Kjion

[PicNick]

Wo hast du das her ? fbas.c ?
Du hast recht, da weigert er sich.
Um den erzeugten asm code zu überprüfen, hab ich eine für diese Formulierung passende struktur reingeschrieben (muster). Aber im Asm Code hab ich gesehen, is auch nicht besser (bzw. gleich) als der dann in fbas.c
Schleifen-konstrukte in jeglicher Form sind wesenrlich mieser, der Spaghetti-Code schaut saumäßig aus, is aber am schnellsten.
mfg robert

[Kjion]

Ich war nur zu spät mit dem posten, hatte deinen letzten Beitrag noch gar nicht gesehen. Es bezog sich auf die ursprüngliche Variante...

Der Code von dir sieht schon wesentlich besser aus...

MfG Kjion

[pebisoft]

hallo, vielen dank für die mühe, die übersetzung in winavr läuft 100%.
das bild ist noch nicht da. werde weiter dran arbeiten.
mfg pebisoft

[pebisoft]

hallo, ich habe am 15.1 schon einmal die frage gestellt mit einem programm für den atmega32, dieses müsste funktionell gehen.
kannst du das mal prüfen. ich glaube dieses für den m132 hat total andere zeiten für die sync.
mfg pebisoft

[PicNick]

Hi, pebi !
Ich muß mir das Programm funktionell einmal reinziehen und kann dann hoffentlich ein bißchen gescheiter mitreden.
Ich hab da das RNBFRA1.2-Board, muß mal schauen, ob ich da eine Teststellung für Video ohne Lötkolben hinkriege.
Dann kann ich auch mit dem Oszi u. Monitor mal gucken, was da eigentlich rauskommt.
Ich hätt mir wohl doch den ZX oder den Spectrum aufheben sollen.
mfg robert