TV Bild mit AVR

Hey!

Ich schätz mal hier findest des was du suchst!!

http://www.ulrichradig.de

Gruß

PS: Ich hass die neue Suche!!!

Meinst du vielleicht das hier:
http://www.4freeboard.to/board/thread.php?threadid=26313&threadview=0&hilight=&hilightuser=0&page=1

So ähnlich.
Gab es nicht mal was, wo man zur Laufzeit den Text ändern konnte ?
Es war glaube ich ein einzelner mega8 der 35x28 oder so Textzeichen
anzeigen konnte.

Mehr Performance gibts auch fertig im DIL-28 Gehäuse ab 4,99 Euro:
http://cgi.ebay.de/TVT-MD-11T-IC-fuer-Textausgabe-auf-TV-mit-9600-Baud_W0QQitemZ5852894039QQcategoryZ12949QQssPageNameZWDVWQQrdZ1QQcmdZViewItem

Es existiert auch eine Version mit PC-Tastaturkonverter
und Echtzeit-Balkengrafik (TVT-MBKD-11), gibts auch bei eBay (ab
8,45).

Dürfte sich wohl um einen ATMEGA8/88/168 handeln.

MfG

Wolfgang

Also langsam könnte ich verstehen wenn sich jemand das ganze Forum
herunterladen will. Schließlich könnte man dann richtig suchen :/

http://www.serasidis.gr/circuits/AVR_VGA/avr_vga.htm (20x38)

http://members.ozemail.com.au/~intello/video_s_w.htm (12x20)

Hallo,
in diesem Thread findest du mein
RS232-Videoterminal mit BAS-Video-Out für AVR Mega-8
Vielleicht hilft dir das.

http://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=5880&postdays=0&postorder=asc&start=198

Gruß Jan

Danke, die letzen drei Links waren genau das was ich gesucht habe !

Ich habe mal (nur so zum Spaß) angefangen meine eigene Software zu
schreiben:
Die erste Version läuft mit 45x35 Zeichen auf einem TV, aber leider hat
der mega8 nur 1kB RAM, daher werde ich 28x35 verwenden.

mal ne dumme frage interlaced ihr die bas signale oder einfach zeilen
durchgehend?

Mein Programm ist ohne Interlace,
es kommt immer des "erste" Halbbild.
Geht halt einfacher, weil ich so die Zeilen
mit einem konstanten 64us Timerinterrupt erzeugen kann.

Gruß Jan

Meines auch:
H und VSync werden getrennt erzeugt und mit XOR verknüpft. Das ergebit
ein BAS ähnliches Timing und wird von allen TVs akzeptiert die ich
ausprobiert habe.

okay, ich habe nämlich überlegungen für eine ähnliche software. die soll
auf dem pc laufen und aus .bmp eeprom images erstellen. an den eeproms
soll für jede farbe ein d/a wandler hängen. sync etc ist in den images
schon drin...

wenn das dann ordentlich läuft werd ich versuchen gleiches mit nem
avr,sd  und ein bisschen sram zu bauen.

Ich hätte da ein fertiges QBasic Programm das aus einem BMP ein
komplettes FBAS Signal erzeugt, komplett mit Halbbilder, Farbburst
usw.
Allerdings benötigt man mindestens 17,7MHz Samplerate um ein Farbbild
zu erzeugen. Ich verwende 13,1072MHz (512kB an Daten), damit kann man
nur ein sehr gutes SW Bild erzeugen.
Ein 512kB 70nS Flash wird von einem Synchronzähler angesteuert und
liefer ein sauberes (F)BAS Signal.

Also du hast 17,7Mhz takt (4xPAL) und erzeugst damit ein fbas signal?
Kann man sich das mal anschauen? das wäre verdammt interessant.

achso 17,7mhz war konjungtiv.

mmhh ich dachte daran evtl mehrere flash/eeprom zu benutzen und mit nem
rgb/pal encoder dann ein fbas signal draus zu bauen.

Den VSync Impuls kann man stark vereinfachen (auch wenn es nicht
Normgerecht ist, lief es bisher bei allen TVs wundebar die ich
ausprobiert habe, egal ob 10cm Mini TV, 100Hz TV oder TV Karte).
Dazu erzeugt man einfach den komplett Sync Impuls dauerhaft (ca. 5
Zeilen Länge), der von den HSync Impulsen abgeschaltet wird.
Oder einfach Ausgedrückt: CSync = HSync EXOR VSync.

Dadurch wird nicht zwischen den beiden Halbbildern unterschieden, dafür
ist das ganze sehr viel einfacher.

Wichtig ist auch, dass das Signal DC mäßig eingespeist wird. Viele TVs
haben mit einer AC Kopplung Probleme.

Hallo,
Hier wird der Aufbau des TV-Signales recht gut beschrieben,
inkl. Vertikale Austastlücke mit Vor- und Nachtrabanten. (Bild 13)
Auch auf das Timing und die Pegel wird eingegegangen.

http://info.electronicwerkstatt.de/bereiche/fernsehtechnik/tvsignale/tv_4.html

Gruß Jan

hier habe ich was gefunden, allerdings für NTSC, aber als Grundlage
sicher brauchbar:
TV-Oscilloscope mit Mega32
http://www.dtweed.com/circuitcellar/caj00161.htm#2833

google nach
TV circuitcellar
oder suche bei circuitcellar.com
ich meine, dort noch mehr ähnliches gefunden zu haben.

@Bernhard
Mit der Vorderflanke synchronisiert er auf Zeile. Hier ist auch eine
gute Beschreibung:
http://www.2cool4u.ch/tv_signal_measurement/tv_signale_grundlagen/tv_signale_grundlagen.pdf#search=%22bas%20signal%22

MfG Paul

"Vor dem Spiel ist nach dem Spiel"!

Es ist doch (außer für die Zeilenzählung) völlig egal, ob Du den HSYNC
zur vorausgehenden oder zur nachfolgenden Zeile zählst. Aber es stimmt
schon: Bild und Text passen da nicht ganz (stört aber längst nicht so,
wie die kaputten 'µ' im Text ...

@Bernhard

Ja, der Text ist etwas mißverständlich an der Stelle. "Nach der 1.
Zeile" soll wohl heißen : "vor der 2. Zeile". Und nach der 625. vor
der 1.

Soll der Strahl nach oben asten,
muß man den Rücklauf dunkel tasten.
(Alte Volksweisheit) :-)))

MfG Paul

Ja, das ganze läuft wunderbar. Ich hatte es spontan begonnen, da mir die
meisten fertigen Sachen nicht gefallen haben. Die erste Version hat etwa
1 Stunde gedauert, bis das ABC auf dem TV stand.

Jetzt unterstützt das ganze viele Befehle, kann den Standard ASCII
Zeichensatz oder auch einen anderen (umschaltbar usw.)
Da die UART Daten während des Horizontalinterrups empfangen werden,
kann ich so 15625 Befehle/s, also 156,250kBaud empangen.
Das schwierigste war, den Interrupt immer gleich lange zu bekommen, so
dass alle Zeilen egal bei welchem Befehl an der gleichen stellen
beginnen.
Möglich sind so 40x25 Zeichen (eigentlich mehr, aber der mega8 hat nur
1kByte SRAM)

Das Programm läuft zu gut, das möchte ich nicht komplett
veröffentlichen. Falls du aber nicht weiterkommst, kann ich dir gerne
einzelne Ausschnitte aus dem Programm schicken.

Ich verwende das SPI Interface mit 8MHz Schiebtakt(=Pixeltakt). Damit
sind rund 420 Pixel pro Zeile möglich. Der Vorteil ist, man muss nur
alle 16 Takte ein Byte laden und ins SPDR schreiben. Die restliche Zeit
kann man nutzen um das Datenbyte noch zu verarbeiten.
Ich speichere z.B. nur den Text im SRAM und lade die Bilder der
einzelnen Buchstaben während der Ausgabe aus dem Flash.

Einen Nachteil hat das SPI Interface aber: Nachdem ein Byte übertragen
wurde, muss man einen Takt warten ehe man die nächsten Daten übertragen
kann, hier entsteht also eine kleine Lücke. Weiterhin ist der Ausgang
vom SPI während dieser Lücke auf 1, was also einen hellen Punkt
erzeugt. Daher invertiere ich das Signal.
Mit ein paar Tricks kann man das auch umgehen, aber sowas mache ich
immer erst wenn der Rest fehlerfrei läuft, da hier das Timing sehr
genau stimmen muss: Man schaltet das SPI Interface zum passenden
Zeitpunkt ab wodurch der Pin den eigentlichen Zustand annimmt, der im
PORT Register steht.

Das ganze mache ich in einer Schleife, da ich genügend Zeit übrig
habe.
Ich habe das ganze von innen nach außen aufgebaut:
Eine Schleife die genau 1 Zeile ausgibt, und anschließend auf den HSync
wartet (im Interrupt wird ein Bit gesetzt)
Da außenrum eine Schleife die einen Buchstaben ausgibt (8 Zeilen + 2
Leerzeilen für bessere Lesbarkeit)
Und um diese wiederum eine Schleife die die 25 Textzeilen ausgibt. Und
anschließend noch Leerzeilen, dann der Vsync Impuls und wieder einige
Leerzeilen. Dann beginnt das ganze wieder von vorne.

Ein Byte beinhaltet 8 nebeneinanderliegende Pixel eines Buchstabens.
Die ersten 256Bytes sind die oberste Zeile der 256 ASCII Zeichen, die
nächsten 256Bytes die zweite Zeile usw.

Das ganze ist also für die TV Darstellung optimiert.

was für einen zeichensatz benötigst du denn?

Data &H00 , &H00 , &H0E , &H01 , &H0F , &H11 , &H0F , &H00  'a
Data &H10 , &H10 , &H1E , &H11 , &H11 , &H11 , &H1E , &H00  'b
Data &H00 , &H00 , &H0E , &H11 , &H10 , &H11 , &H0E , &H00  'c
Data &H01 , &H01 , &H0F , &H11 , &H11 , &H11 , &H0F , &H00  'd
Data &H00 , &H00 , &H0E , &H11 , &H1F , &H10 , &H0E , &H00  'e
Data &H06 , &H08 , &H08 , &H1E , &H08 , &H08 , &H08 , &H00  'f
Data &H00 , &H00 , &H0F , &H11 , &H11 , &H0F , &H01 , &H0E  'g
Data &H10 , &H10 , &H1C , &H12 , &H12 , &H12 , &H12 , &H00  'h
Data &H04 , &H00 , &H04 , &H04 , &H04 , &H04 , &H04 , &H00  'i
Data &H02 , &H00 , &H06 , &H02 , &H02 , &H02 , &H12 , &H0C  'j
Data &H10 , &H10 , &H12 , &H14 , &H18 , &H14 , &H12 , &H00  'k
Data &H04 , &H04 , &H04 , &H04 , &H04 , &H04 , &H06 , &H00  'l
Data &H00 , &H00 , &H1A , &H15 , &H15 , &H11 , &H11 , &H00  'm
Data &H00 , &H00 , &H1C , &H12 , &H12 , &H12 , &H12 , &H00  'n
Data &H00 , &H00 , &H0E , &H11 , &H11 , &H11 , &H0E , &H00  'o
Data &H00 , &H00 , &H1E , &H11 , &H11 , &H11 , &H1E , &H10  'p
Data &H00 , &H00 , &H0F , &H11 , &H11 , &H11 , &H0F , &H01  'q
Data &H00 , &H00 , &H16 , &H09 , &H08 , &H08 , &H1C , &H00  'r
Data &H00 , &H00 , &H0E , &H10 , &H0E , &H01 , &H0E , &H00  's
Data &H00 , &H08 , &H1E , &H08 , &H08 , &H0A , &H04 , &H00  't
Data &H00 , &H00 , &H12 , &H12 , &H12 , &H16 , &H0A , &H00  'u
Data &H00 , &H00 , &H11 , &H11 , &H11 , &H0A , &H04 , &H00  'v
Data &H00 , &H00 , &H11 , &H11 , &H15 , &H1F , &H0A , &H00  'w
Data &H00 , &H00 , &H12 , &H12 , &H0C , &H12 , &H12 , &H00  'x
Data &H00 , &H00 , &H12 , &H12 , &H12 , &H0E , &H04 , &H18  'y
Data &H00 , &H00 , &H1E , &H02 , &H0C , &H10 , &H1E , &H00  'z

Data &H0E , &H11 , &H11 , &H1F , &H11 , &H11 , &H11 , &H00  'A
Data &H1E , &H11 , &H11 , &H1E , &H11 , &H11 , &H1E , &H00  'B
Data &H0E , &H11 , &H10 , &H10 , &H10 , &H11 , &H0E , &H00  'C
Data &H1E , &H11 , &H11 , &H11 , &H11 , &H11 , &H1E , &H00  'D
Data &H1F , &H10 , &H10 , &H1E , &H10 , &H10 , &H1F , &H00  'E
Data &H1F , &H10 , &H10 , &H1E , &H10 , &H10 , &H10 , &H00  'F
Data &H0E , &H11 , &H10 , &H17 , &H11 , &H11 , &H0F , &H00  'G
Data &H11 , &H11 , &H11 , &H1F , &H11 , &H11 , &H11 , &H00  'H
Data &H0E , &H04 , &H04 , &H04 , &H04 , &H04 , &H0E , &H00  'I
Data &H01 , &H01 , &H01 , &H01 , &H11 , &H11 , &H0E , &H00  'J
Data &H11 , &H12 , &H14 , &H18 , &H14 , &H12 , &H11 , &H00  'K
Data &H10 , &H10 , &H10 , &H10 , &H10 , &H10 , &H1F , &H00  'L
Data &H11 , &H1B , &H15 , &H11 , &H11 , &H11 , &H11 , &H00  'M
Data &H11 , &H19 , &H15 , &H13 , &H11 , &H11 , &H11 , &H00  'N
Data &H0E , &H11 , &H11 , &H11 , &H11 , &H11 , &H0E , &H00  'O
Data &H1E , &H11 , &H11 , &H1E , &H10 , &H10 , &H10 , &H00  'P
Data &H0E , &H11 , &H11 , &H11 , &H15 , &H12 , &H0D , &H00  'Q
Data &H1E , &H11 , &H11 , &H1E , &H12 , &H11 , &H11 , &H00  'R
Data &H0E , &H11 , &H10 , &H0E , &H01 , &H11 , &H0E , &H00  'S
Data &H1F , &H04 , &H04 , &H04 , &H04 , &H04 , &H04 , &H00  'T
Data &H11 , &H11 , &H11 , &H11 , &H11 , &H11 , &H0E , &H00  'U
Data &H11 , &H11 , &H11 , &H11 , &H11 , &H0A , &H04 , &H00  'V
Data &H11 , &H11 , &H15 , &H15 , &H15 , &H15 , &H0A , &H00  'W
Data &H11 , &H11 , &H0A , &H04 , &H0A , &H11 , &H11 , &H00  'X
Data &H11 , &H11 , &H11 , &H0A , &H04 , &H04 , &H04 , &H00  'Y
Data &H1E , &H02 , &H04 , &H08 , &H10 , &H10 , &H1E , &H00  'Z

Data &H0E , &H11 , &H13 , &H15 , &H19 , &H11 , &H0E , &H00  '0
Data &H04 , &H0C , &H04 , &H04 , &H04 , &H04 , &H0E , &H00  '1
Data &H0E , &H11 , &H01 , &H06 , &H08 , &H10 , &H1F , &H00  '2
Data &H0E , &H11 , &H01 , &H0E , &H01 , &H11 , &H0E , &H00  '3
Data &H02 , &H06 , &H0A , &H12 , &H1F , &H02 , &H02 , &H00  '4
Data &H1F , &H10 , &H10 , &H1E , &H01 , &H11 , &H0E , &H00  '5
Data &H06 , &H08 , &H10 , &H1E , &H11 , &H11 , &H0E , &H00  '6
Data &H1F , &H01 , &H02 , &H04 , &H08 , &H08 , &H08 , &H00  '7
Data &H0E , &H11 , &H11 , &H0E , &H11 , &H11 , &H0E , &H00  '8
Data &H0E , &H11 , &H11 , &H0F , &H01 , &H02 , &H0C , &H00  '9

Data &H00 , &H00 , &H00 , &H00 , &H00 , &H00 , &H00 , &H00  ' Space
Data &H04 , &H0E , &H0E , &H04 , &H04 , &H00 , &H04 , &H00  '!
Data &H1B , &H1B , &H12 , &H00 , &H00 , &H00 , &H00 , &H00  '
Anführungszeichen
Data &H00 , &H0A , &H1F , &H0A , &H0A , &H1F , &H0A , &H00  '#
Data &H08 , &H0E , &H10 , &H0C , &H02 , &H1C , &H04 , &H00  '$
Data &H19 , &H19 , &H02 , &H04 , &H08 , &H13 , &H13 , &H00  '%
Data &H08 , &H14 , &H14 , &H08 , &H15 , &H12 , &H0D , &H00  '&
Data &H0C , &H0C , &H08 , &H00 , &H00 , &H00 , &H00 , &H00  '
Data &H04 , &H08 , &H08 , &H08 , &H08 , &H08 , &H04 , &H00  '
Data &H08 , &H04 , &H04 , &H04 , &H04 , &H04 , &H08 , &H00  '
Data &H00 , &H0A , &H0E , &H1F , &H0E , &H0A , &H00 , &H00  '*
Data &H00 , &H04 , &H04 , &H1F , &H04 , &H04 , &H00 , &H00  '+
Data &H00 , &H00 , &H00 , &H00 , &H00 , &H0C , &H0C , &H08  ',
Data &H00 , &H00 , &H00 , &H1F , &H00 , &H00 , &H00 , &H00  '-
Data &H00 , &H00 , &H00 , &H00 , &H00 , &H0C , &H0C , &H00  '.
Data &H00 , &H01 , &H02 , &H04 , &H08 , &H10 , &H00 , &H00  '/

Wenn Du einen Linksshift durch Rechtsshift ersetzt (bzw. umgekehrt), ist
es doch richtig. Also wirklich!

Da jetzt wieder was passiert ist ist mein projekt auch wieder munter
geworden, grins. werde mal versuchen ein bild auf den screen zu
bringen, so wie es benedikt schon gemacht hat...

@benedikt: Hast du die sync signale mit nem µcom erzeugt, oder lasst du
die von dem cpld baustein erzeugen? bei nem pixeltakt von .1µsec
auflösung ist das syncronisieren ganz schön verschenkter platz...

Wiso synchronisieren ?
Der AVR erzeugt Sync und Videodaten, dadurch sind beide automatisch
synchron.

du hast weiter oben gescrieben
"Ich hätte da ein fertiges QBasic Programm das aus einem BMP ein
komplettes FBAS Signal erzeugt, komplett mit Halbbilder, Farbburst
usw...."

Ich hab mich auf dieses bezogen.

Das war ein anderes Projekt, bei dem es darum ging einfach nur ein
festes Bild zu erzeugen.

@Bernhard:

Ach, Du warst der mit dem Datensenden über SPI ... klar, dann muß das
Byte schon richtigherum sein. Normalerweise schiebt man ja Bit um Bit
aus dem Bit und setzt den Pin entsprechend. Dann hätte man nur die
Schieberichtung ändern müssen.

Jetzt mußt Du wohl doch fünf Minuten für ein PC-Programm investieren,
daß Dir die Bits umdreht.

Probiers mal mit der Tabelle hier:
Hatte n bissl langeweile, ich hoffe, die is richtig



Data &H00 , &H00 , &H70 , &H80 , &HF0 , &H88 , &HF0 , &H00
Data &H08 , &H08 , &H78 , &H88 , &H88 , &H88 , &H78 , &H00
Data &H00 , &H00 , &H70 , &H88 , &H08 , &H88 , &H70 , &H00
Data &H80 , &H80 , &HF0 , &H88 , &H88 , &H88 , &HF0 , &H00
Data &H00 , &H00 , &H70 , &H88 , &HF8 , &H08 , &H70 , &H00
Data &H60 , &H10 , &H10 , &H78 , &H10 , &H10 , &H10 , &H00
Data &H00 , &H00 , &HF0 , &H88 , &H88 , &HF0 , &H80 , &H70
Data &H08 , &H08 , &H38 , &H48 , &H48 , &H48 , &H48 , &H00
Data &H20 , &H00 , &H20 , &H20 , &H20 , &H20 , &H20 , &H00
Data &H40 , &H00 , &H60 , &H40 , &H40 , &H40 , &H48 , &H30
Data &H08 , &H08 , &H48 , &H28 , &H18 , &H28 , &H48 , &H00
Data &H20 , &H20 , &H20 , &H20 , &H20 , &H20 , &H60 , &H00
Data &H00 , &H00 , &H58 , &HA8 , &HA8 , &H88 , &H88 , &H00
Data &H00 , &H00 , &H38 , &H48 , &H48 , &H48 , &H48 , &H00
Data &H00 , &H00 , &H70 , &H88 , &H88 , &H88 , &H70 , &H00
Data &H00 , &H00 , &H78 , &H88 , &H88 , &H88 , &H78 , &H08
Data &H00 , &H00 , &HF0 , &H88 , &H88 , &H88 , &HF0 , &H80
Data &H00 , &H00 , &H68 , &H90 , &H10 , &H10 , &H38 , &H00
Data &H00 , &H00 , &H70 , &H08 , &H70 , &H80 , &H70 , &H00
Data &H00 , &H10 , &H78 , &H10 , &H10 , &H50 , &H20 , &H00
Data &H00 , &H00 , &H48 , &H48 , &H48 , &H68 , &H50 , &H00
Data &H00 , &H00 , &H88 , &H88 , &H88 , &H50 , &H20 , &H00
Data &H00 , &H00 , &H88 , &H88 , &HA8 , &HF8 , &H50 , &H00
Data &H00 , &H00 , &H48 , &H48 , &H30 , &H48 , &H48 , &H00
Data &H00 , &H00 , &H48 , &H48 , &H48 , &H70 , &H20 , &H18
Data &H00 , &H00 , &H78 , &H40 , &H30 , &H08 , &H78 , &H00

Data &H70 , &H88 , &H88 , &HF8 , &H88 , &H88 , &H88 , &H00
Data &H78 , &H88 , &H88 , &H78 , &H88 , &H88 , &H78 , &H00
Data &H70 , &H88 , &H08 , &H08 , &H08 , &H88 , &H70 , &H00
Data &H78 , &H88 , &H88 , &H88 , &H88 , &H88 , &H78 , &H00
Data &HF8 , &H08 , &H08 , &H78 , &H08 , &H08 , &HF8 , &H00
Data &HF8 , &H08 , &H08 , &H78 , &H08 , &H08 , &H08 , &H00
Data &H70 , &H88 , &H08 , &HE8 , &H88 , &H88 , &HF0 , &H00
Data &H88 , &H88 , &H88 , &HF8 , &H88 , &H88 , &H88 , &H00
Data &H70 , &H20 , &H20 , &H20 , &H20 , &H20 , &H70 , &H00
Data &H80 , &H80 , &H80 , &H80 , &H88 , &H88 , &H70 , &H00
Data &H88 , &H48 , &H28 , &H18 , &H28 , &H48 , &H88 , &H00
Data &H08 , &H08 , &H08 , &H08 , &H08 , &H08 , &HF8 , &H00
Data &H88 , &HD8 , &HA8 , &H88 , &H88 , &H88 , &H88 , &H00
Data &H88 , &H98 , &HA8 , &HC8 , &H88 , &H88 , &H88 , &H00
Data &H70 , &H88 , &H88 , &H88 , &H88 , &H88 , &H70 , &H00
Data &H78 , &H88 , &H88 , &H78 , &H08 , &H08 , &H08 , &H00
Data &H70 , &H88 , &H88 , &H88 , &HA8 , &H48 , &HB0 , &H00
Data &H78 , &H88 , &H88 , &H78 , &H48 , &H88 , &H88 , &H00
Data &H70 , &H88 , &H08 , &H70 , &H80 , &H88 , &H70 , &H00
Data &HF8 , &H20 , &H20 , &H20 , &H20 , &H20 , &H20 , &H00
Data &H88 , &H88 , &H88 , &H88 , &H88 , &H88 , &H70 , &H00
Data &H88 , &H88 , &H88 , &H88 , &H88 , &H50 , &H20 , &H00
Data &H88 , &H88 , &HA8 , &HA8 , &HA8 , &HA8 , &H50 , &H00
Data &H88 , &H88 , &H50 , &H20 , &H50 , &H88 , &H88 , &H00
Data &H88 , &H88 , &H88 , &H50 , &H20 , &H20 , &H20 , &H00
Data &H78 , &H40 , &H20 , &H10 , &H08 , &H08 , &H78 , &H00

Data &H70 , &H88 , &HC8 , &HA8 , &H98 , &H88 , &H70 , &H00
Data &H20 , &H30 , &H20 , &H20 , &H20 , &H20 , &H70 , &H00
Data &H70 , &H88 , &H80 , &H60 , &H10 , &H08 , &HF8 , &H00
Data &H70 , &H88 , &H80 , &H70 , &H80 , &H88 , &H70 , &H00
Data &H40 , &H60 , &H50 , &H48 , &HF8 , &H40 , &H40 , &H00
Data &HF8 , &H08 , &H08 , &H78 , &H80 , &H88 , &H70 , &H00
Data &H60 , &H10 , &H08 , &H78 , &H88 , &H88 , &H70 , &H00
Data &HF8 , &H80 , &H40 , &H20 , &H10 , &H10 , &H10 , &H00
Data &H70 , &H88 , &H88 , &H70 , &H88 , &H88 , &H70 , &H00
Data &H70 , &H88 , &H88 , &HF0 , &H80 , &H40 , &H30 , &H00

Data &H00 , &H00 , &H00 , &H00 , &H00 , &H00 , &H00 , &H00
Data &H20 , &H70 , &H70 , &H20 , &H20 , &H00 , &H20 , &H00
Data &HD8 , &HD8 , &H48 , &H00 , &H00 , &H00 , &H00 , &H00

Data &H00 , &H50 , &HF8 , &H50 , &H50 , &HF8 , &H50 , &H00
Data &H10 , &H70 , &H08 , &H30 , &H40 , &H38 , &H20 , &H00
Data &H98 , &H98 , &H40 , &H20 , &H10 , &HC8 , &HC8 , &H00
Data &H10 , &H28 , &H28 , &H10 , &HA8 , &H48 , &HB0 , &H00
Data &H30 , &H30 , &H10 , &H00 , &H00 , &H00 , &H00 , &H00
Data &H20 , &H10 , &H10 , &H10 , &H10 , &H10 , &H20 , &H00
Data &H10 , &H20 , &H20 , &H20 , &H20 , &H20 , &H10 , &H00
Data &H00 , &H50 , &H70 , &HF8 , &H70 , &H50 , &H00 , &H00
Data &H00 , &H20 , &H20 , &HF8 , &H20 , &H20 , &H00 , &H00
Data &H00 , &H00 , &H00 , &H00 , &H00 , &H30 , &H30 , &H10
Data &H00 , &H00 , &H00 , &HF8 , &H00 , &H00 , &H00 , &H00
Data &H00 , &H00 , &H00 , &H00 , &H00 , &H30 , &H30 , &H00

ach ja, sorry

ist genau die tabelle die weiter oben schon gepostet is - nur halt alle
Bits vertauscht

also Zeile 1 - 26 a-z
     Zeile 28-... A-Z
usw

Ich hab n Programm geschrieben um die Zeichen zu erzeugen:
http://www.mikrocontroller.net/forum/read-4-422387.html

Vielleicht kann ja jemand was damit anfangen :)

ne kurze frage:

ist das so korrekt? ->

vsync -> 1.Zeile (Hsync vorne weg) -> 2.Zeile (hysnc vorne weg) -> ...
-> 240. Zeile -> vsync

ja okay, habe ich ja.
wieviele der zeilen werden nicht sichtbar sein?

Hallo Benedikt,
Bist schon gut vorann gekommen. Ich sehe es gibt scheinbar nur diesen
Weg. Den Trick mit dem abschlten der SPI hat dir auch den Inverter
erspart. Hast du es auch schon geschaft die Lücke wenn nötig zwischen
den "Zeichen zu schließen" ? Ich konnte Bit7 des Zeichens einfach
duplizieren und in der Lücke ausgeben. Zur Zeit arbeite ich noch an
einem Setup Bildschirm Für die Bildlage und Uhrzeiteinstellung über
IR-Fernbedinung. Mir fehlt aber noch komplet die Schnitstellen
implemenierung nach außen. dafür möchte ich die Zweidrahtschnitstelle
der Mega8 verwenden, da gehen 400kBit, das reicht für ein kompletes
Bild in einem Halbbild. Den Interlace habe ich über Synctabellen
realisirt. Zur Erinnerung:
http://www.mikrocontroller.net/forum/read-1-379469.html#new

Gruß Christof

Ich habe mich für den UART entschiden, da diese doppelt gepuffert ist.
Wenn man I2C mit voller Geschwindigkeit nutzt, also wirklich 400kHz
überträgt (das sind immerhin rund 40kByte/s, bzw. fast 3 Bytes/Zeile),
dann gehen davon 2 Stück verloren (wenn die Schnittstelle den Takt
nicht blockiert), da der mega8 diese nicht abfragen kann, da er die
Bilddaten ausgeben muss.
Beim UART ist das dagegen kein Problem: Das empfangene Byte landet im
Puffer, das nächste kann bereits empfangen werten. Im HSync Interrupt
wird dann ein Byte abgefragt und verarbeitet. Das ermöglicht 15kByte/s,
was auch schnell genug ist.

Mein Version habe ich in diesem Status abgeschlossen, da mache ich
nichts mehr dran, da diese stabil läuft. Das mit dem 7bit könnte ich
machen, da ich aber hauptsächlich Text darstelle ist das nicht
unbedingt notwendig.

Ich versuche das demnächst auf einem ARM, da dieser billiger ist als
ein AVR mit viel SRAM und da dieser ein 16bit SPI Interface mit 8 Word
FIFO hat, was erlaubt 128Pixel auf einmal zu schreiben (nennt sich SSP
Interface). Pro Zeile muss der uC also nur 4x Werte nachliefern für ein
komplettes 512x288 Bild (64x32 Buchstaben). Außerdem erlaubt dieses
lückenlos mehrere Transfers aneinander zu hängen.

Benedikt, das TWI kann sozsuagen auf "Pause" gestellt werden, da geht
nix verloren, weil das ne getaktete Übertragung ist.

@ Läubi - genau

Habe in der Zeilendarstellung noch ein Paar Nops da geht bestimmt noch
was.

ARM klingt interesannt, habe mich damit noch nicht beschäftigt sind die
billiger als 1,65€

IMO ein großer Vorteil von TWI. Auch wenn die Leute immer schreiben
"wenn ich TW mit 400khz mache schaf ich XYZ an Daten"... der Maser
als auch der Slave dürfen den Bus nahezu beliebig! lange sperren wenn
sie die Daten nicht so schnell liefern/verarbeiten können.
Ist besonders nützlich wenn man int. Osc benuzt da wirken sich
gangungenauigkeiten nicht aus.

Eigendlich ist ja auch gut, wenn man zwischein einem Projekt mit RS232
und I2C schnitstelle wählen kann.

Gruß Christof

@Läubi

Das sagte ich doch...
Das kann aber auch eine dumme Fehlerquelle sein, wenn der Slave uC sich
aufhängt und so den Bus blockiert. Das hat mich mal einen Tag gekostet,
den ich mit Fehlersuche verbracht habe.

@Bernhard:
>>Mein TV-Projekt läuft auch

Gratuliere, sie doch Klasse aus !
Womit ist das realisiert ? C ? ASM ?

Schöne grosse Zeichen! ;-)

Gruß Jan

@Bernhard

Hut ab! Eine feine Sache hast Du da programmiert. Läuft es mit Atmega8
oder mit einem von den "Größeren"?

MfG Paul

Hallo Bernhard,
Schönes Projekt ! Das bringt mich auf einige Ideen.

Ich habe auch eine Weiterentwicklung meines AVR Videoterminals
in der Codesammlung eingestellt.
An der vorletzten Zeile des Bildschirmphotos kannst du evtl.
erkennen, was ich noch damit vorhabe. :-)

Gruß Jan

>>Die H-Synchronisation einer Bildzeile beginnt mit

Woran merkst du das ?
Ich habe keine Ahnung, wo mein Fernseher syncronisiert.
Wie kann ich das erkennen ?

Gruß Jan

In meinem Programm werden die empfangenen UART Daten während des HSync
Impuls verarbeitet, die Impulsdauert varriert also je nach Befehl. Das
Bild ist aber stabil.
Die Triggerung erfolgt also über die fallende Flanke des Sync
Impulses.

Ich habe eine Vermutung, warum dein Bild so ausgefranzt ist (das
Problem hatte ich auch):
Kann es sein, dass sich der Bildbeginn verschiebt, oder der
Timerinterrupt nicht sofort angesprungen wird, da der AVR z.B. einen 2
Cycle Befehl (z.B. einen Sprung)  ausführt ?

Ich werde es morgen mal ausprobieren, welche Flanke es wirklich ist.

Wie funktioniert die Kontrolle durch den 2. Timer genau ?
Ich gebe zu, ich habe mir dein Programm angeschaut, versteh aber nicht
wirklich wo was genau abläuft.

Der Spung mit IJMP ist ja echt genial, um das ganze Taktgenau
hinzubekommen. Respekt !

Würde aber nicht 1 Timer ausreichen ? Dieser ist ja auch Taktgenau wenn
dieser im Compare Mode läuft.


Ich habe die Taktflanke ausprobiert: Du hattest recht, der TV triggert
wirklich auf die steigende Flanke, was das ganze sogar noch
vereinfacht, da die Low-High Flanke direkt vor Beginn der Pixelausgabe
erfolgen kann, und so die Latenzzeit des Interrupts in gewissen Grenzen
kompensiert wird.

Sagen wir mal man nimmt den 16bit Timer im Compare Modus und verwendet
den Compare Interrupt. Somit wird schonmal alle 1024 Takte ein
Interrupt ausgelöst, egal was dazwischen kommt.
Zu Beginn des Interrupts erzeugt man das Sync Signal, liest den Timer
aus und gleicht das ganze mittels IJMP an, so dass der Sync Impuls
immer genau z.B. 5us also 320 Takte nach dem Timer Compare beendet
wird.
Das ganze kann man sogar automatisch machen lassen, indem man die
weiteren OCR Register verwendet:
Man verbindet diese mit dem OCR Pin. Nun stellt man alles so ein, dass
der Pin beim Rest des Timers auf 0 und bei einem Zählerstand von etwa
300 wieder auf 1 gesetzt wird.
Der Sync Impuls wird also automatisch ohne einen weiteren
Softwarebefehl erzeugt.
Man braucht also theoretisch garkeinen Interrupt mehr.

Das ganze ist nur eine spontane Idee, die ich noch nicht ausprobiert
habe, es müsste aber funktionieren. Ich nutze die Timer aber gerne um
solche Signale zu erzeugen (z.B. zwei Impulse, von denen einer zeitlich
leicht versetzt ist usw.)

Ich denke nicht, dass diese Flanke sehr kritisch ist, genauso wie auch
die ganzen Vor und Nachtrabanten bei VSync.
Heutige TVs besitzen alle gute PLLs, wenn nicht sogar eine komplett
digitale Verarbeitung. Um auch schlechte Sender empfangen zu können
sind diese also sehr tolerant.

Bin gerade dabei am Testen...

So, die erste Version mit Sync in Harware über die Timer läuft.
Das gesamte Programm kommt mit einem 16bit Timer aus, und benötigt nur
rund 70 Zeilen (außer der einmaligen Initialisierung).
Es läuft komplett über den Interrupt, im Hauptprogramm kann man also
einen beliebigen Code laufen lassen, solange er nicht mehr als 20Byte
RAM benötigt, mit der Hälfte der Register auskommt und die Interrupts
nicht abschaltet. Die Latenzzeit von bis zu 10 Takten wird automatisch
kompensiert.
Die IJMP Routine war aufwendig zu berechnen, und hat mich einen TV
gekostet. Irgenwas hat mit den Sync Signalen nicht gepasst, da der
Sprung falsch war, es hat kurz geknackt und der TV war hinüber...
Naja, ich habe noch genügend rumstehen, aber das war mein bester,
eigentlich ein PC Monitor, super scharfes Bild, schade.

Der TV/Monitor war schon alt, die 70Hz waren dem wohl doch etwas
zuviel.
Anscheinend zieht irgendwas zuviel Strom, denn das Schaltnetzteil
pfeift und kann nicht mehr eine stabile Spannung liefern.
Horizontal und Vertikalendstufe scheinen aber zu laufen.


Ich habe in die Software alles eingebaut was andere und ich an Tricks
entwickelt haben:
- Die Korrektur der Latenzzeit mittels IJMP (kann bis 0-10 Takte
auskorrigieren, wenn es mehr wird hängt sich alles auf.)
- Das Hauptprogramm ist eine leere Endlosschleife, hier kann man also
beliebige Software einbauen.
- Die Datenausgabe läuft im Interrupt.
- Die Sync Impulse werden per Hardware erzeugt und sind absolut
stabil.
- Die Zeit während des Zeilen und Bildrücklaufs stehen also komplett
der Software im Hauptprogramm zur Verfügung.

Der VSync Impuls ist einfach eine Invertierung der PWM Einstellungen,
die vom AVR synchron übernommen werden. Das macht das Softwaretiming
unkritisch und die Impulse genauer.

Wenn das ganze stabil läuft, poste ich den Code in der Codesammlung.
Das ganze hat noch einige wenige Fehler, im Moment läuft das ganze zum
Testen und emuliert ein serielles LCD mit rund 20fps in denen jeweils
das komplette Bild refreshed wird (250kbit/s Baudrate)

Ich habe die Software mal in die Codesammlung gestellt.
Ich habe noch kein Programm eingebaut, das den Text erzeugt, das kann
jeder selbst machen:

http://www.mikrocontroller.net/forum/read-4-429298.html#new

Ja, ich habe sogar schonmal einen Encoder geschrieben, der ein BMP in
ein ROM Image umwandelt, dass man mit etwa 20MS/s aufwärts abspielen
muss um in farbiges TV Bild zu erhalten.

Im Anhang das Bild zeigt ein echtes FBAS Signal. Die Burst (unten klein
um den VSync herum, oben vergrößert um den HSync herum) dienen zur
Syncronisation, die kleinen Schwingungen auf der Bildinformation sind
der Farbträger + Farbinformation.

Theroetisch lässt sich das ganze leicht erzeugen:
Sinus und Cosinus mit 4,433MHz erzeugen, R-Y und B-Y erzeugen und mit
dem Sin und Cos multiplizieren und das zu dem Y Signal mischen.
Y=Schwarzweissignal, also 0,3*R+0,59*G+0,11*B

Mit einem AVR gibt es ein paar Schaltungen die mit 4*4,433 also 17,7MHz
laufen. Aber die erzeugen nur ein festes Farbbild.

>...und anschließend komplett abgeschaltet.

Nicht ganz:
Die Farbinformationen werden Quadraturamplitudenmoduliert den
Bildinformationen überlagert. In dem Bild sieht man ja die Schwingungen
mit der selber Frequenz wie die Bursts über dem Bildsignal.

Um also jetzt ein komplett rotes Bild zu übertragen, würde man den
Spannungspegel als Schwarzweis Bild berechnen:
Y=0,3*R+0,59*G+0,11*B
Man hätte also 0,3V für ein komplett helles rotbild (Videopegel 1Vss).
R-Y wäre dann also 0,7V und G-Y wäre -0,3V

Die letzen beiden Spannungswerten würde man jetzt mit dem Sin und Cos
multiplizieren. Wenn man diese beiden dann addiert erhält einen Sinus
mit einer bestimmten Phase (die irgendwo zwischen dem von dem
urpsrünglichen sin und cos liegt) und einer Amplitude die aus der
Überlagerung der beiden sinusförmigen Kurven entsteht.
Die Farbinformation steckt also in der Phase der 4,433MHz Schwingung
(bzw. genauer: In der Phasenverschiebung zwischen Burstschwingung und
dem Wert während der Bilddaten). Daher wird diese in jeder zweiten
Zeile invertiert, damit sich Phasenfehler auslöschen.

Ein wirklich brauchbares Bild lässt sich mit einem AVR aber nicht so
recht erzeugen.
Man müsste zumindest die sin/cos Modulation extern machen, so dass der
AVR nur noch die Y und R-Y und G-Y Signale erzeugen müsste.
Irgendwo hatte das mal jemand in einen FPGA gepackt, der aus RGB Daten
ein (digitales) FBAS Signal erzeugt hat.