OSD célkereszt - Hobbielektronika.hu - online elektronikai magazin és fórum

(#)	nagyg80 hozzászólása	Dec 29, 2009		/

Sziasztok!

Egy OSD célkeresztett kellene csináljak speciális felhasználásra,de sehol nem találtam megfelelő megoldást.
Adott egy 640*480 pixel felbontású lcd kijelző ami kap egy külső PAL analóg videó jelet.Ezen a kijelzőn kellene megjelenítenem egy piros célkeresztet ami lehet akár csak egy sima + is.Eddig nem is lenne nagy gond,mert számtalan megoldás kering a neten. pl: Bővebben: Link Ami igazándiból a problémát okozza az az,hogy ezt a keresztet 1 pixel pontosággal mozgatni kell és az általam fellelt kütyük csak karakter szinten voltak képesek a mozgatásra plusz az elektronikának rá kell férnie egy cirka 5*5 centis panelre.

Ebben kérném a segítségeteket.

üdv.:Nagyg

(#)	pici válasza nagyg80 hozzászólására (»)	Dec 29, 2009		/	4

A linken amit irtál, ott a megoldás.
Át lehet írni full szálkeresztre a forrást, de ha csak egy + jelet mozgatsz, mint a videón is mozgatják a betűket, akkor is megfelelő.
Persze a gond lehet a színnel (nem piros). Mivel az OSD úgy működik, hogy a megfelelő időpontban fel vagy lehúzza a jelet (feket vagy fehér)
TV-n jól is kezelhető, de LCD-n már gond lehet.
Mivel a PAL analóg jel nem natív 640x480, így nem tudod pixelenként mozgatni...

(#)	nagyg80 válasza pici hozzászólására (»)	Jan 26, 2010		/

köszi a választ.majd megpróbálok ezen a vonalon mozogni

(#)	krnl hozzászólása	Márc 5, 2010		/

Sziasztok, hasonlo OSD jellegu kerdesem lenne:

ha a monitor nem kap jelet, eloszor kikapcsolja a hattervilagitast, majd visszakapcsolja nehany masodpercre es kiirja hogy "no signal".

Azt kell megoldanom, hogy ne kapcsoljon vissza a hattervilagitas (es ne jelenjen meg a szoveg, de ha nincs hattervilagitas ez nem fontos). A cel, hogyha nem kap jelet, egybol menjen el a hattervilagitas es ne jojjon vissza.

Van otletetek?

Koszi, krnl

(#)	pici hozzászólása	Feb 28, 2012		/

Ha nem is szálkereszt, de egy OSD-s project
40" LED TV-n jól néz ki élőben.

MediaBox1.jpg

MediaBox2.jpg

(#)	vzoole válasza pici hozzászólására (»)	Feb 29, 2012		/

Grat...
Szerintem én már sose fejezem be a célkereszt megvalósítását.

(#)	pici válasza vzoole hozzászólására (»)	Márc 1, 2012		/

Ha nincs rá szükséged, akkor hagyd, van más szép project is.
Ha pedig nem hagy nyugodni, akkor azért elég hamar össze lehet rakni.
De akkor már érdemes VGA porton bizgálni a cuccot, szerintem könyebb is, mint AV-n 640x480 VGA-t.

(#)	mzozo95 hozzászólása	Aug 27, 2012		/

HI!
nem találtam más OSD-s tipokot, így ide legkézenfekvőbb írnom.

Adott egy rca jel(420 soros kamera képe), és én szeretném, ha erre a képre ki tudnám írni az adc által mért értékeket.

Valaki tudna egy kapcsolást, és proogramot (esetleg cikket) ajánlani avr-re minél kevesebb alkatrésszel? Fontos lenne, hogy Magyarországon is beszerezhetőek legyenek, mert pl a MAX7456 -ot nem találtam meg egy magyar boltban sem..

Üdv.: Zoltán

(#)	GPeti1977 válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Itt egy hasonló ami kell:
http://www.rcgroups.com/forums/showthread.php?t=1473207

LM1881 szinkronjel leválaszt, int1, int0 lábakra megszakítást generál a szinkronjel, és az spi port mosi lába feliratozza a képernyőt, Aruino-ban íródott ha megérted át tudod írni.

MAX7456-ot a Sparkfun-tól vehetsz breakout borddal.
Van mintaprogram hozzá, illetve Visual basic-ben írtam egy karakterfeltöltő programot, ami a karakter szerkesztő által generált .mcm file-t tölti fel a soros porton egy avr- segítségével, így nem kell a hardvert megvenni a Maximtól.

(#)	mzozo95 válasza GPeti1977 hozzászólására (»)	Aug 28, 2012		/

Azta..., ez az arduino-s dolog átírása avr re nekem kicsit magas...
Úgylátszik nekem, mezei avr-esnek marad a sparkfun max7456 board... Valaki rendelt már a sparkfuntól MO-ra? Hogyan megy a redelés menete, és a fizetési mód? Mennyi idő alatt jön meg?

(#)	pici válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Arduino is AVR
Az LM1881-el jobban jársz. Lomiban kapható és olcsó.
Én is ilyet használok atmega88 vagy atmega168-al.
Kép csatolva

MediaBox2.jpg

MediaBoxF.jpg

(#)	mzozo95 válasza pici hozzászólására (»)	Aug 28, 2012		/

Az lm1881 tényleg olcsó és nálunk is lehet kapni..

Találtam egy érdekes cikket: Bővebben: Link

Csak még nem igazán értem, hogy mikor generál interrutot az lm1882... Minden sor végén vagy mikor? És a TV képernyőjét akkor soronként tölti fel ez az rca adatvonal? Sajnos még az alap dolgokkal sem vagyok tisztában... pl a tv honnan tudja hogy ez a kép bal felső sarka, vagy jobb alja?
És a betűket hogy lehet kirajzolni? Soronként, pixelenként? Tehát az arduinos projektben ezért van annyi adat?(minden betű binárisan leírva).
Arra már rájöttem, ha felhúzza a jelet az avr, akkor fehér lesz az adott képpont, ha lehúzza akkor fekete...

(#)	GPeti1977 válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Minden sor elején az egyik interrupt, minden félképváltáskor a másik interrupt, ez után számolja a sorokat, a páros páratlan nincs megkülönböztetve, így fele a felbontás (pal 576/2 ntsc 480/2)
Ha L szint nem fekete mert ki van diódázva, egy másik láb L szintre húzásával ellenálláson keresztül lehet sötét hátteret csinálni.
Ebben van +-1 pixel jitter, illetve nem lehet fekete keretet rajzolni, a MAX IC vel nincs jitter, van fekete és fehér szín is.
A sparkfun regisztrálni kell és paypal keresztül lehet fizetni, 2 hét és megérkezik a csomag.

Van egy egyszerűsített változatom ez csak két analóg értéket ír ki. Később felteszem a kódot.

Még lm1181 szynkron leválasztó sem kell mert egy rc kapcsolással az avr komparátorával meg egy timer modullal lehet detektálni a két szinkronjelet.

(#)	mzozo95 válasza GPeti1977 hozzászólására (»)	Aug 28, 2012		/

Hűű, a kód nagyon jó lenne, karakterekkel iratsz ki 2 értéket, amit az adc-ről olvasol be? Pont ilyen kell nekem(majd testre szabom a kiírást..

)
Majd valami kapcsolási rajz szerűséget is tudnál feltenni?

PICI, a te megoldásod is érdekelne!

Am nem gondoltatok arra, hogy egy cikket írni erről ide a fórumra? Sztem nagyon jó téma az OSD, és ha tényleg ilyen olcsón meg lehet csinálni, sokakat érdekelne is...

(#)	sargarigo válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Az biztos!
Többek között engem is, ugyanilyen célból!

(#)	GPeti1977 válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/delay.h>
//#define offset 0
#define current_cal 0.5234
#define little_delay _delay_loop_1(13);
int current_num=0;
int buttext[10] = {'T','V','V','E','R','S','S','B','A','T'};
// Buffer to store the bytes temporarely.
unsigned char buffer[10];
int a=0;
// Standard integers to use with for/while loops
int i=0;
int k=0;
// Count linenumber;
int line = 0;
// When writing text/numbers, used to store the linecount of the letter/number
int temp =0;
int loopcount=0;
int loopcount2=0;
int current=0;
unsigned char currentr[] = {3,3,3,3,3};
int currentRAW=0;
long mah =0;
int mahtemp=0;
unsigned char mahr[]={3,3,3,3,3,3};
int w;
int ADCreal=0;
int rssi=0;
void setup () {
pinMode(6,INPUT); // Analog comparator AIN0
pinMode(7,INPUT); // Analog comparator AIN1
// Test pin
pinMode(4,OUTPUT);
// Init SPI output (will just set all as output)
pinMode(10,OUTPUT);
pinMode(11,OUTPUT);
pinMode(12,OUTPUT);
pinMode(13,OUTPUT);
// Set ADC's as input
pinMode(5,INPUT);
pinMode(4,INPUT);
pinMode(3,INPUT);
pinMode(2,INPUT);
pinMode(1,INPUT);
// Set SPI;
SPCR =
(1<<SPE) | //Enable SPI
(1<<MSTR)| // Set as master
(0<<SPR1)| // Max speed
(0<<SPR0)| // Max speed
(1<<CPOL)| // We dont want it to idle high
(1<<CPHA);
SPSR = (1<<SPI2X); // SPI double speed - we want 8 mhz output.
SPDR = 0;
// Disable interrupts - necessary when using Arduino ide to avoid default
// interrupts used for the delay(), millis() etc.
TIMSK0=0;
TIMSK1=0;
TIMSK2=0;
attachInterrupt(0,detectline,FALLING);
attachInterrupt(1,detectframe,RISING);
ADMUX = (0<<MUX3) | (1<<MUX2) | (0<<MUX1) | (1<<MUX0) |
(1<<REFS0) |(0<<REFS1);
// Setup timer 1 with max speed. Used to detect if it's a new line or frame.
TCCR1B =
(0<<CS12) | //Prescale 1
(0<<CS11) | //Prescale 1
(1<<CS10) | //Prescale 1
(0<<WGM12); // CTC mode
//Clear timer (not really necessary)
TCNT1=0;
// Start timer 2 used to count time (page 164)
TCCR2B =
(1<<CS22) | //Prescale 1024
(1<<CS21) | //Prescale 1024
(1<<CS20) | //Prescale 1024
(1<<WGM22); // CTC mode (Clear timer on compare match)
TCCR2A = (1<< WGM21); // CTC mode
OCR2A = 0b11111111; // Set compare register to max;
// Enable interrupts - not needed
// sei();
}
// Numbers and letters - a single array is used for now.
// As each letter/number
// contains 8 lines, the entire ASCII table can't be implemented this way,
// due to the fact that in int want be large enough.
// Using a long as index is too slow.
// A 2D array might work, but for now I will just use it this way;
unsigned char letters[] = {
// Blank - 0
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
// A - 1
0b00000000,
0b01111110,
0b01000010,
0b01000010,
0b01111110,
0b01000010,
0b01000010,
0b01000010,
// B - 2
0b00000000,
0b01111110,
0b01000010,
0b01000010,
0b01111110,
0b01000010,
0b01000010,
0b01111110,
// C - 3
0b00000000,
0b01111110,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01111110,
// D - 4
0b00000000,
0b01111000,
0b01000100,
0b01000010,
0b01000010,
0b01000010,
0b01000100,
0b01111000,
// E - 5
0b00000000,
0b01111110,
0b01000000,
0b01000000,
0b01111110,
0b01000000,
0b01000000,
0b01111110,
// F - 6
0b00000000,
0b01111110,
0b01000000,
0b01000000,
0b01111110,
0b01000000,
0b01000000,
0b01000000,
// G - 7
0b00000000,
0b01111110,
0b01000010,
0b01000010,
0b01011110,
0b00000010,
0b00000010,
0b01111110,
// H - 8
0b00000000,
0b01000010,
0b01000010,
0b01000010,
0b01011110,
0b01000010,
0b01000010,
0b01000010,
// I - 9
0b00000000,
0b01111110,
0b00010000,
0b00010000,
0b00010000,
0b00010000,
0b00010000,
0b01111110,
// J - 10
0b00000000,
0b01111110,
0b00000010,
0b00000010,
0b00000010,
0b01000010,
0b01100110,
0b01111100,
//K - 11
0b00000000,
0b01000110,
0b01001000,
0b01010000,
0b01100000,
0b01010000,
0b01001000,
0b01000110,
// L - 12
0b00000000,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01000000,
0b01111110,
// M - 13
0b00000000,
0b01000010,
0b01100110,
0b01011010,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
// N - 14
0b00000000,
0b01000010,
0b01100110,
0b01010010,
0b01001010,
0b01001010,
0b01000110,
0b01000010,
// O - 15
0b00000000,
0b01111110,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b01111110,
// P - 16
0b00000000,
0b01111110,
0b01000010,
0b01000010,
0b01111110,
0b01000000,
0b01000000,
0b01000000,
// Q - 17
0b00000000,
0b01000010,
0b01100110,
0b01011010,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
// R - 18
0b00000000,
0b01111110,
0b01000010,
0b01000010,
0b01111110,
0b01100000,
0b01011000,
0b01000110,
// S - 19
0b00000000,
0b01111110,
0b01000000,
0b01000000,
0b01111110,
0b00000010,
0b00000010,
0b01111110,
// T - 20
0b00000000,
0b00000010,
0b00100100,
0b00001000,
0b00010000,
0b00100100,
0b01000000,
0b00000000,
// U - 21
0b00000000,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b01111110};
// Array with numbers, "-", ".", ":" and blank
char numbers[] = {
// -
0b00000000,
0b01000010,
0b01000110,
0b01000100,
0b00100100,
0b00101100,
0b00011000,
0b00011000,
// .
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00111000,
0b00111000,
// /
0b00000000,
0b00000010,
0b00000010,
0b00000100,
0b00001000,
0b00010000,
0b00100000,
0b01000000,
// 0
0b00000000,
0b00111100,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b01000010,
0b00111100,
// 1
0b00000000,
0b00010000,
0b00110000,
0b01010000,
0b00010000,
0b00010000,
0b00010000,
0b00111100,
// 2
0b00000000,
0b01111100,
0b00000010,
0b00000010,
0b00111110,
0b01000000,
0b01000000,
0b01111110,
// 3
0b00000000,
0b01111100,
0b00000010,
0b00000010,
0b00111100,
0b00000010,
0b00000010,
0b01111100,
// 4
0b00000000,
0b01000010,
0b01000010,
0b01000010,
0b01111110,
0b00000010,
0b00000010,
0b00000010,
// 5
0b00000000,
0b01111110,
0b01000000,
0b01000000,
0b01111100,
0b00000010,
0b00000010,
0b01111110,
// 6
0b00000000,
0b00111110,
0b01000000,
0b01000000,
0b01111100,
0b01000010,
0b01000010,
0b01111100,
// 7
0b00000000,
0b01111110,
0b01000010,
0b00000100,
0b00001000,
0b00010000,
0b00100000,
0b00100000,
// 8
0b00000000,
0b00111100,
0b01000010,
0b01000010,
0b00111100,
0b01000010,
0b01000010,
0b00111100,
// 9
0b00000000,
0b00111100,
0b01000010,
0b01000010,
0b00111110,
0b00000010,
0b00000010,
0b01111110,
0b00000000,
0b00000000,
0b00011100,
0b00011100,
0b00000000,
0b00011100,
0b00011100,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000,
0b00000000};
// Large numbers. Use them if you prefere.
// I have used them with USART pixel generation and it
// should be straight forward with SPI
unsigned char LargeNumbers[] ={
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000000,0b00000000,
0b00000001,0b11000000,
0b00000111,0b11000000,
0b00001111,0b11000000,
0b00011111,0b11000000,
0b00011111,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00000011,0b11000000,
0b00011111,0b11111000,
0b00111111,0b11111100,
0b00011111,0b11111000,
0b00000000,0b00000000,
0b00001111,0b11100000,
0b00011111,0b11110000,
0b00111111,0b11111000,
0b01111000,0b00111000,
0b01110000,0b00111000,
0b00000000,0b00111000,
0b00000000,0b11111000,
0b00000001,0b11110000,
0b00000111,0b11100000,
0b00011111,0b11000000,
0b00011110,0b00000000,
0b00111100,0b00000000,
0b00111111,0b11111000,
0b01111111,0b11111100,
0b00111111,0b11111000,
0b00000000,0b00000000,
0b00000111,0b11110000,
0b00011111,0b11111000,
0b00111111,0b11111100,
0b01111000,0b00011100,
0b01110000,0b00011100,
0b00000000,0b00111100,
0b00000011,0b11111000,
0b00000111,0b11110000,
0b00000011,0b11111000,
0b00000000,0b00111100,
0b01111000,0b00011100,
0b01111000,0b00011100,
0b00111111,0b11111100,
0b00011111,0b11111000,
0b00000111,0b11110000,
0b00000000,0b00000000,
0b00110000,0b00011000,
0b01111000,0b00111100,
0b01111000,0b00111100,
0b01111000,0b00111100,
0b01111000,0b00111100,
0b01111000,0b00111100,
0b01111111,0b11111100,
0b01111111,0b11111100,
0b00111111,0b11111100,
0b00000000,0b00111100,
0b00000000,0b00111100,
0b00000000,0b00111100,
0b00000000,0b00111100,
0b00000000,0b00111100,
0b00000000,0b00011000,
0b00000000,0b00000000,
0b00111111,0b11111000,
0b01111111,0b11111100,
0b01111111,0b11111000,
0b01111000,0b00000000,
0b01111000,0b00000000,
0b01111000,0b00000000,
0b01111111,0b11100000,
0b01111111,0b11111000,
0b00111111,0b11111100,
0b00000000,0b01111100,
0b00000000,0b00111100,
0b00111000,0b01111000,
0b01111111,0b11111000,
0b00111111,0b11110000,
0b00001111,0b11000000};
void detectframe() {
line=0;
}
void detectline() {
little_delay
// ============================================================
// Buttom line
// ============================================================
// Writes the text...
// Writes the numbers - first the time.
if (line > 139 && line < 148) {
temp = line - 140;
_delay_loop_1(12);
// Writes the current numbers;
_delay_loop_1(15);
buffer[0]=currentr[0]<<3;
buffer[1]=currentr[1]<<3;
buffer[2]=currentr[2]<<3;
buffer[3]=currentr[3]<<3;
buffer[4]=buttext[2]<<3;
SPDR = numbers[(buffer[0])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
SPDR = numbers[(buffer[1])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
SPDR = numbers[(buffer[2])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t");
SPDR = numbers[(buffer[3])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t");
SPDR = letters[(buffer[4])+(temp)];
_delay_loop_1(10);
buffer[0]=mahr[0]<<3;
buffer[1]=mahr[1]<<3;
buffer[2]=mahr[2]<<3;
buffer[3]=buttext[0]<<3;
SPDR = numbers[(buffer[0])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
SPDR = numbers[(buffer[1])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
SPDR = numbers[(buffer[2])+(temp)];
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t""nop\n\t");
__asm__("nop\n\t""nop\n\t""nop\n\t");
SPDR = letters[(buffer[3])+(temp)];
}
// Increase line count..
line++;
}
void loop () {
w++;
if (w==0)
{
ADCreal=analogRead(5);
current_num=ADCreal*0.14514;
// Updates currentr which will be displayed directly on the OSD;
currentr[0]= (current_num / 100)+3;
currentr[1]= ((current_num % 100) / 10)+3;
currentr[2]= 1; // Writes the dot. Should only be done once.
currentr[3]= ((current_num % 100) % 10)+3;
}
if (w==100) {
//286 573
rssi=analogRead(4);
if (rssi<286) {
rssi = 0;
}
else
{
rssi = rssi-286;
}
rssi = rssi / 3;
if (rssi>99) {
rssi = 99;
}
mahr[0]= (rssi / 10)+3;
mahr[1]= (rssi % 10)+3;
//mahr[2]=3+3;
}
}

osd.JPG

(#)	mzozo95 válasza GPeti1977 hozzászólására (»)	Aug 28, 2012		/

HI!
leteszteltem a programot avr-studio 4el, atmega8 ra állítva(mint a kapcs rajzban), és rengeteg hibát kaptam..:

Idézet:
„../OSD.c: In function 'setup':
../OSD.c:43: warning: implicit declaration of function 'pinMode'
../OSD.c:43: error: 'INPUT' undeclared (first use in this function)
../OSD.c:43: error: (Each undeclared identifier is reported only once
../OSD.c:43: error: for each function it appears in.)
../OSD.c:47: error: 'OUTPUT' undeclared (first use in this function)
../OSD.c:77: error: 'TIMSK0' undeclared (first use in this function)
../OSD.c:78: error: 'TIMSK1' undeclared (first use in this function)
../OSD.c:79: error: 'TIMSK2' undeclared (first use in this function)
../OSD.c:80: warning: implicit declaration of function 'attachInterrupt'
../OSD.c:80: error: 'detectline' undeclared (first use in this function)
../OSD.c:80: error: 'FALLING' undeclared (first use in this function)
../OSD.c:81: error: 'detectframe' undeclared (first use in this function)
../OSD.c:81: error: 'RISING' undeclared (first use in this function)
../OSD.c:98: error: 'TCCR2B' undeclared (first use in this function)
../OSD.c:102: error: 'WGM22' undeclared (first use in this function)
../OSD.c:104: error: 'TCCR2A' undeclared (first use in this function)
../OSD.c:105: error: 'OCR2A' undeclared (first use in this function)
../OSD.c: In function 'loop':
../OSD.c:699: warning: implicit declaration of function 'analogRead'
make: *** [OSD.o] Error 1
Build failed with 15 errors and 3 warnings...
”

Az elejére beszúrtam az fcpu 16mhz-t. így máris kevesebb a hiba.

Az atmega8 nál csak OCR2, TCCR2, WGM20 van, és a TIMSKX el is gondja van a fordítónak, emellett az output-al és input-al is gondja van, gondolom itt csak egy #define hiányzik az elejéről.

A video input és az output ugyanazon a vezetéken fut? és a 2es számú a gnd?(x1-2...)
A videó mérete nem lényeges? Kisebb méreten(pl 420tvl) csak nagyobbak lesznek a betűk? Ez PAL jelre ültethető OSD?

(#)	mzozo95 válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Kipróbáltam atmega 48al is a studióban, mivel ott több a timer... mégkevesebb a hiba:

Idézet:
„
Build started 28.8.2012 at 19:13:24
avr-gcc -mmcu=atmega48 -Wall -gdwarf-2 -Os -std=gnu99 -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -MD -MP -MT osd48.o -MF dep/osd48.o.d -c ../osd48.c
../osd48.c: In function 'setup':
../osd48.c:43: warning: implicit declaration of function 'pinMode'
../osd48.c:43: error: 'INPUT' undeclared (first use in this function)
../osd48.c:43: error: (Each undeclared identifier is reported only once
../osd48.c:43: error: for each function it appears in.)
../osd48.c:47: error: 'OUTPUT' undeclared (first use in this function)
../osd48.c:80: warning: implicit declaration of function 'attachInterrupt'
../osd48.c:80: error: 'detectline' undeclared (first use in this function)
../osd48.c:80: error: 'FALLING' undeclared (first use in this function)
../osd48.c:81: error: 'detectframe' undeclared (first use in this function)
../osd48.c:81: error: 'RISING' undeclared (first use in this function)
../osd48.c: In function 'loop':
../osd48.c:699: warning: implicit declaration of function 'analogRead'
make: *** [osd48.o] Error 1
Build failed with 8 errors and 3 warnings...
”

De sztem a 8kb memóriája szegény atmega48nak kevés lesz ide...
A deklarációkban tudnál segítséget nyújtani? Milyen formában kell ezeket megadni?

Gondolom ezt a kettőt így:

#define OUTPUT 1
#define INPUT 0

(#)	GPeti1977 válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Aurino -val kell lefordítani, természetesen kell egy atmega168, 328 a megfelelő bootloaderrel.
Nem lehetetlen átírni avrstudio-ra de nem is egyszerű.

Ntsc is lehet csak a betűk nagyobbak.
A be és kimenet ugyanaz.

(#)	GPeti1977 válasza GPeti1977 hozzászólására (»)	Aug 28, 2012		/

Itt van egy készen ha két bemenetről feszültséget akarsz kiírni:
http://www.hobbyking.com/hobbyking/store/__16662__HobbyKing_E_OSD.html

(#)	mzozo95 válasza GPeti1977 hozzászólására (»)	Aug 28, 2012		/

Hát, az lenne jó, ha én tudnám megcsinálni az egészet, külföldről pedig sajnos nem rendeltem még soha, és annyira nem is szeretnék... Mevárom PICI hozzászólását, kíváncsi vagyok hogy ő tényleg avr re studióval készítette e az övét...

(#)	pici válasza mzozo95 hozzászólására (»)	Aug 28, 2012		/

Hali
AVR studioval csináltam.
Nagyon rövid a kód, mert 3-4k között van 9x7-es karakterekkel.
Nálam még van benne egy RS422 kommunikáció a központi egységgel.
Úgy írtam meg, hogy a sötétitettháttér ki/bekapcsolható.
Jelszintek potival finomanhangolhatóak, mennyire legyen fényes és mennyire nyomja el eredeti jelet.
Pár fontos dolog:
1. PAL vagy NTSC tökmindegy, csak a sorok száma nagyobb PALban és így több karaktersort is ki lehet rakni, ellenben nem elég a 8 bites számláló.
2. külső kvarc kell, minél nagyobb. Én 22.118400MHz-est használtam, picit túlhúzva AVR-t és BAUD-os értéken.
Stabil táp és Kvarcnak kondik kellenek, minél stabilabb a jel, annál kevésbé "ziziznek" a betűpixelek
3. LM1881 2 megszakítást kezel. Sor és félképnél külön vezetéken adja a jelet. Sormegszakítást kell egy 16bites számlálóval számolni, ez adja az Y pixelértéket. Félképmegszakítás pedig nagyon egyszerű, lenullázza a számlátót.
4. Az x koordináta figyeléshez egy timert kell beállítani, ha az lejárt, akkor a kívánt oszlopnál jársz, pakolhatod folyamatosan a karaktered pixeleit.
Nem egyszerű figyelni, hányadik sorban jársz, ez a karaktered hányadik sora és ugye egymás utáni karakterek x sorát kell folyamatosan kirakni, aztán az x+1 sor 1. 2. 3. karakterének pixeleit...

5. figyelni kell az elágazásoknál (hányadik sornál jár...) ezeknek az utasításidejét is bele kell számolni az időzítésbe.
Oszlopfelbontás (x) a proci frekijétől függ.

(#)	sargarigo válasza pici hozzászólására (»)	Aug 29, 2012		/

Ejha!

Így ez alapján nem is tűnik olyan bonyolultnak! Azért jobban belegondolva rá kell még szánni egy kicsit..

(#)	GPeti1977 hozzászólása	Aug 29, 2012		/

Ez sem rossz:
http://electronics-home-projects.tripod.com/