Druckbare Version
dieses bild mit nur 6 graustufen finde ich im terminal schon sehr unüberschauber deswegen wäre meine meinung auf keinefall 16 verschiedene zeichen zu nehmen, da es dann zu unübersichtlich wird
man könnte nur fürs terminal die 16 graustufen in 4 gruppen unterteilen, sodass graustufe 1-4 5-8 9-12 und 13 -16 jeweils ein zeichen sind im program für die auswertung kann man ja mit allen 16 graustufen weiterarbeiten.
lg
martin
Ich habe auch schon an Dirk geschrieben das es sinvoller wäre nur 8 statt 16
Graustuffen zuverwenden, und echt kann mir einer sagen warum 16 graustuffen für den Rp6 notwendig sind? Das wären doch nur mehr programmier aufwand und kostet den RP6 nur Rechenleistung.
PS Dirk das soll kein Angriff auf dich sein
@Martinius11:
Ja, 8 Graustufen kann man natürlich auch nehmen. Ist schon deutlich einfacher.
Zum Speichern eines Bildes (wenn man das in 1024 Byte unterbringen will ...) hilft es sehr, von 256 (8 Bit) auf 16 (4 Bit) Farben zu reduzieren, weil dann die doppelte Menge an Bildpunkten gespeichert werden kann.
Reduziert man die 16 auf 8 Farben (3 Bit), dann bringt das ohne viele Klimmzüge keinen Vorteil beim Speichern, weil in ein Byte nicht 3, sondern immer noch 2 Bildpunkte passen (= 6 Bit). 2 Bits bleiben dann pro Byte frei.
@RobbyMartin:
Ja, ich möchte ein Bild auf dem Terminal sehen. Leider gibt es ja die Blockgrafik:
http://de.wikipedia.org/wiki/Blockgrafik nicht mehr, so dass man sich irgendwie helfen muss ... Hast du eine Idee, wie man das machen könnte?
Gruß Dirk
Ich würd gern mal wissen ob man wirklich die Kabel für die Kammera und ADC abschirmen muss Danke
@ martinius11
ich habe für meine kamera einfach ein stück flachbandkabel genommen um genau zu sein einfach die ferbindung zwischen der base und dem erweiterungsbord der bus mit y1-y12 oder so und es funktioniert ohne probleme über längere strecken würde ich es wahrscheinlich abschirmen
@dirk
ich bin am überlegen wie es funktionieren kann doch bis jetzt ist mir noch nichts gescheites eingefallen doch ich werde heute abend mal drüber nachdenken
lg
martin
Hallo,
Bei mir funktioniert das ganze auch gut ohne abschirmung.Ich würd sagen wenn das Kabel nicht länger als 20 cm. ist kann man die Abschirmung auch weglassen.
. : o + x O X
diese 8 zeichen kommen mir sinnvol vor wobei das + und das x fast identisch sind
ich würde immer noch dazu tendieren im terminal nur max. 4 verschiedene zeichen zu benutzen da es sonst mit dem ASCII zeichensatz zu unübersichtlich wird.
lasse mich aber gerne umstimmen wenn jemand gute zeichen zeigt die auch klar von der helligkeit unterscheidbar sind sonst sieht das bil eher so aus als wären dort nur sinnlose zeichen im terminal
lg
martin
Hallo Leute,
ich habe doch mal 16 Zeichen probiert.
In der 5x7 Punktmatrix ist die Pixelzahl aufsteigend von 0 (Leerzeichen) bis 35 (alles hell).
Wie sieht das aus?
Gruß Dirk
so habe den graukeil einfach mal ins terminal eingegeben doch wirklich überzeugen tut es mich nicht 8-[
ich hätte auch gerne die meinung anderer leute gehört die bei dem projekt mitmachen....
lg
martin
Mir geht's auch so ... :-kZitat:
... wirklich überzeugen tut es mich nicht
Aber wie dann ...?
Gruß Dirk
wenns nach mir geht brauchen wir nur schwarz , weis und grau
so habe jetzt den test für die dritte phase gemacht und bei mir kommen ergebnisse die schon mal ganz gut aussehen nur einen abweichung von 0,002 das sollte doch ausreichen oder ??
lg
martin
@Martin:
Das sieht sehr gut aus! Die Zeilenfrequenz beträgt 15625 Hz, d.h. alle 64 µs (Zeilenlänge) kommt ein HSync-Impuls (1 / 0,000064 s = 15625 Hz).Zitat:
... bei mir kommen ergebnisse die schon mal ganz gut aussehen nur einen abweichung von 0,002 das sollte doch ausreichen oder ??
Gruß Dirk
habe jetzt mal im wiki die rätsels lösung eingetragen also das man den jumper neun verücken mus um das vsync signal im test messsen zu können
@dirk
ist es okay wenn ich im wiki (rp6 mitmachprojekt) auch etwas ergänze oder möchtest du das nicht ???
lg
martin
@martin:
Das ist ok! Sicher gibt es noch an vielen Stellen "Lücken", besonders auch im Software-Teil!Zitat:
ist es okay wenn ich im wiki (rp6 mitmachprojekt) auch etwas ergänze
Gruß Dirk
Hallo
"Mehr als 16 Werte hintereinander kann der ADC auch bei 4MHZ-Takt nicht digitalisieren"!
Das wußten wir eigentlich schon immer, nur wirklich wahrhaben wollten wir es bisher noch nicht. Nach einem erneuten Anstoß habe ich das nun endlich mal aufgegriffen und das Einlesen einer Bildschirmzeile daraufhin "optimiert". Anstelle von "lies Werte so schnell du kannst" verwende ich nun einen regelkonformeren Ansatz:
Der ADC wandelt weiterhin im Dauerlauf, Erkennung von Bildstart und Anfang der gewünschten Zeile funktionieren wie gehabt.
Neu ist nun der Abschnitt nach dem Start der gewünschten Zeile: Bei gefundener Zeile steht nach while(ADC<30) schon der Wert des ersten Zeilenpixel in ADCH. Dieser wird abgespeichert und das ADIF-Flag wird gelöscht. Dann werden die nächsten 15 Werte eingelesen, nachdem der ADC jeweils die Fertigmeldung der Wandlung über ADIF signalisiert hat.
Nach dem Zeilensprung zur nächsten gesuchten Zeile wird das dann bis zum Bildende wiederholt. Ich verwende im Demo unten einen Zeilensprung von 10, das ergibt bei 24 Zeilen und 30 übersprungenen Zeilen eine Bildlänge von 270 Pixel (ungefähr;)
Hier nun ein paar Bilder dazu. Links der Versuchsaufbau (im Bild vom Blitz der Kamera extrem ausgeleuchtet, im Versuch war es deutlich dunkler), das TV-Kontrollbild und schließlich die Terminalausgabe:
Bild hier Bild hier Bild hier
Terminal ist ZOC das ich hier vorgestellt habe. Der Code unten funktioniert aber mit dem RP6Loader (Infos zur Anpassung im Quelltext):
Das Bild wird einmal in der Sekunde neu dargestellt, mit ZOC steht dabei das Bild still und wird nicht hochgescrollt.Code:// Ein 24*16 Ascii-Bild 3.5.10 mic
// Mit neuen Erkenntnissen ein Versuch, diese umzusetzen. Ziel war möglichst
// schnell einen Überblick über den Bildinhalt einzulesen und ohne zu Scrollen
// im Terminal darzustellen. Dazu verwende ich anstelle des Loaders ein anderes
// Terminalprogramm: https://www.roboternetz.de/phpBB2/viewtopic.php?t=54087
// Es funktioniert aber in dieser Version auch mit dem RP6Loader!
// Es werden in einem Halbbild(!) von 24 Linien jeweils die 16 Zeilenwerte am Stück
// eingelesen. Das ergibt zwar ein extrem verzerrtes Bild, aber mit 90°-Drehung
// und mit Ausgabe der Werte im Hexformat hat man so durchaus ein Bildgefühl ;)
#include "RP6RobotBaseLib.h"
#define vt100_Black 0 // VT100 Farbdefinitionen
#define vt100_Red 1
#define vt100_Green 2
#define vt100_Yellow 3
#define vt100_Blue 4
#define vt100_Magenta 5
#define vt100_Cyan 6
#define vt100_White 7
#define vt100_Reset 0
#define vt100_Bright 1
#define vt100_Dim 2
#define vt100_Underscore 4
#define vt100_Blink 5
#define vt100_Reverse 7
#define vt100_Hidden 8
uint8_t c; // freies Char
uint16_t x, y;
uint8_t std, min, sec;
void init(void);
void setMotorPWM(uint8_t power_links, uint8_t power_rechts);
void vt100_cls(void);
void vt100_set_cursor(uint8_t line, uint8_t column);
void vt100_set_color(uint8_t foreground, uint8_t background);
void vt100_set_attrib(uint8_t attrib);
void vt100_writeGrafic(uint8_t *string);
void vt100_writeGraficAt(uint8_t line, uint8_t column, uint8_t *string);
void Bild_aufnehmen(void)
{
// Variablen dürfen NICHT global sein!
uint8_t bildspeicher[24][16], *bildzeiger;
uint8_t zeile, sync, c;
zeile=30; // 30 Zeilen am Bildanfang überlesen
// Warten auf langen Syncbereich = Bildstart
cli();
do{sync=0;while (ADCH > 20);while (ADCH < 30) sync++;}while (sync < 40);
for(c=0; c<24; c++) // 24 Zeilen einlesen
{
bildzeiger=&bildspeicher[c][0];
sync=15; // 15 Werte sollen am Stück gelesen werden
while(zeile--){while (ADCH > 20);while (ADCH < 30);} // auf Zeile warten
*bildzeiger++=ADCH; // erster Wert!
ADCSRA |= (1<<ADIF);
while(sync--) // Werte 2-16 einlesen
{
while(!(ADCSRA & (1<<ADIF)));
*bildzeiger++=ADCH;
ADCSRA |= (1<<ADIF);
}
zeile=10; // 10 Zeilen überlesen (30+ 24*10 = 270 Zeilen) Sind auch 11 möglich?
}
sei();
// Hier kann man die Darstellung mit dem VT100-Terminal verbessern
writeChar('\n'); // extra Vorschub für RP6Loader
writeChar('\n');
// vt100_set_cursor(3,1); // Bildstart bei VT100-Terminal, beim RP6Loader störend
for(c=0; c<16; c++)
{
for(zeile=0; zeile<24; zeile++)
{
writeChar(' ');
//writeIntegerLength(bildspeicher[23-zeile][c], HEX, 2); // Hexwerte
writeChar((bildspeicher[zeile][c]-30)/10+'0');
}
writeChar('\n');
}
}
int main(void)
{
init();
vt100_cls();
writeString_P(" Ein 24*16 Ascii-Bild per VT100 3.5.10 mic");
setStopwatch1(0);
startStopwatch1();
while(1)
{
if(getStopwatch1() >999) // Uhr
{
setStopwatch1(0);
sec++;
if(sec>59) {sec=0; min++;}
if(min>59) {min=0; std++;}
if(std>23) std=0;
vt100_set_cursor(26,72);
writeIntegerLength(std,10,2);
writeChar(':');
writeIntegerLength(min,10,2);
writeChar(':');
writeIntegerLength(sec,10,2);
Bild_aufnehmen(); // Bildrefresh nach einer Sekunde
}
}
return(0);
}
void init(void)
{
initRobotBase();
//DDRC |= (SCL | SDA); // Servopins auf Ausgang setzen
//TIMSK |= (1 << TOIE1); // Die Timer1 Overflow-ISR zur Servoansteuerung
extIntOFF(); // schaltet den E_INT1-Port auf Eingang für den ADC
// ADC interne Referenz 2,56V, Ergebniss linksbündig, Kanal ADC4 (E_INT1)
ADMUX = (1<<REFS1) | (1<<REFS0) | (1<<ADLAR) | 4;
// setzte free running triggern
SFIOR = (0<<ADTS2) | (0<<ADTS1) | (0<<ADTS0);
// kein interupt, Wandler einschalten, prescaller /2
ADCSRA = (0<<ADIE) | (1<<ADEN) | (0<<ADPS2) | (0<<ADPS1) | (1<<ADPS0);
// Autotriggern bedeutet jetzt free running aktivieren, altes Flag löschen
ADCSRA |= (1<<ADATE) | (1<<ADIF);
// Initialisierung starten
ADCSRA |= (1<<ADSC);
// und noch die wohl eher unnötige Initiallesung
while (!(ADCSRA & (1<<ADIF)));
ADCSRA |= (1<<ADIF);
//powerON();
}
// Achtung! Die PWM-Werte werden hier OHNE Rampe verändert!
void setMotorPWM(uint8_t power_links, uint8_t power_rechts)
{
extern uint8_t mleft_ptmp, mright_ptmp;
if(power_links > 210) power_links = 210;
if(power_rechts > 210) power_rechts = 210;
mleft_power=mleft_ptmp=power_links;
mright_power=mright_ptmp=power_rechts;
OCR1BL = power_links;
OCR1AL = power_rechts;
if(power_links || power_rechts)
TCCR1A = (1 << WGM11) | (1 << COM1A1) | (1 << COM1B1);
else
TCCR1A = 0;
}
void vt100_cls(void)
{
writeString_P("\x1B[2J"); // clear screen ESC [ 2 J
writeString_P("\x1B[H"); // cursor home ESC [ H
}
void vt100_set_cursor(uint8_t line, uint8_t column)
{
writeString_P("\x1B["); // set cursor position ESC [ Pl ; Pc H
writeInteger(line, 10);
writeString_P(";");
writeInteger(column, 10);
writeString_P("H");
}
void vt100_set_color(uint8_t foreground, uint8_t background)
{
writeString_P("\x1b[");
writeInteger(30+foreground, 10);
writeString_P(";");
writeInteger(40+background, 10);
writeString_P("m");
}
void vt100_set_attrib(uint8_t attrib)
{
writeString_P("\x1b[");
writeInteger(0, 10);
writeString_P(";");
writeInteger(attrib, 10);
writeString_P("m");
}
void vt100_writeGrafic(uint8_t *string)
{
while(*string)
writeChar(128|*string++); // Grafikzeichen mit gesetztem Bit7 senden
}
void vt100_writeGraficAt(uint8_t line, uint8_t column, uint8_t *string)
{
vt100_set_cursor(line, column); // Cursor postionieren
while(*string)
writeChar(128|*string++); // Grafikzeichen mit gesetztem Bit7 senden
}
Gruß
mic
PS:
Bei der Ausgabe der Werte dreht sich alles um diese Zeile:
writeChar((bildspeicher[zeile][c]-30)/10+'0');
Vom Helligkeitswert von Bildpunkt x, y wird der Grundwert 30 abgezogen, der Rest durch 10 geteilt. Das ergab bei meinem Demo Werte bis 4. Um die Ausgabe z.B. auf einstellige Werte oder begrenzte Graustufen zu optimieren müßte man an dieser Formel schrauben. Die '0' sollte wohl klar sein ;)
Auf diese Bildbasis könnte man schon einfache Bildanalysen wie hellster/dunkelster Punkt/Zeile/Spalte aufsetzen oder Faltungen anwenden um Kanten zu finden ;)
Erst klassig werd ich bald mal ausprobieren
@mic:
Wieder mal ein tolles Stück! Muss ich gleich probieren!
Ich denke: Nein.Zitat:
(30+ 24*10 = 270 Zeilen) Sind auch 11 möglich?
Mein erstes "Zählprogramm", das die wirklich vorhandenen TV Zeilen der CMOS Kamera ermittelt, gibt aus: 288.
Das hat mich auch gewundert, ich war nach Datenblatt von 260 TV Zeilen ausgegangen, obwohl das Bildelement mit 288 angegeben wird.
Gruß Dirk
hi Leute,
ich hätte da ein kleines Problem ich habe nämlich heute mdie kamera platine fertig nun ist die kammera ja festgelötet und ich weiß nicht mehr welcher Pin was ist könnte jemand ein bild von der rückseite seiner Kammera machen
Danke
Leider etwas unscharf:
Bild hier
Von oben links nach unten:
Video out
GND
Vcc
Gamma
Gain
Die Kamera sollte man steckbar einbauen ;)
Gruß
mic
vielen dank radbruch
so lange wurde zu diesem projekt nichts mehr geschrieben lebt das projekt noch da ich es sehr interessant fand???
lg
martin
... würde mich auch interessieren.Zitat:
lebt das projekt noch
Wer hat das eigentlich nachgebaut?
Hat jemand ein gutes Programm dafür geschrieben?
Gruß Dirk
also ich habe es in allen Stufen nachgebaut ausser die letzte mit dem infrarot dies ist aber nicht so wichtig
Also nachgebaut habe ich das Projekt auch bis zur Infrarotstufe, aber um eigene Programme zu entwickeln zu können fehlen mir noch ein paar Jahre. Ich dachte auch das hier das Projekt richtig abgeht, und ich hier das eine oder andere mitnehmen kann, aber daraus wurde nichts. Jetzt liegt die Platine in der Schrottkiste und die CAM wird als Türspion benutzt.
Trainmen
ein bascom programm existiert noch nicht oder?
adc im freerun
timer (oder vlt ohne doch besser?)
und ausgabe über rs232 oder 8 leds für linien erkennung das man was sieht
Hallo
Die Umsetzung von C nach Bascom für Stufe 1 (nur Kamera und AVR) gibt's hier:
https://www.roboternetz.de/phpBB2/ze...=434274#434274
Wesentlich ist die Einstellung des ADC auf gewünschte Funktion: Freeruning mit Prescaler /2 und linksbündiges Ergebniss. Das ist allerdings schon etwas älter. Die neusten Erkenntnisse, die wir erst nach dem Start des Mitmachprojekts gewonnen haben, sind in dieser Umsetzung noch nicht berücksichtigt.
Ich habe bisher "nur" Stufe 1 nachgebaut. Das hatte ich zwar im Prinzip schon immer, neu ist jedoch der Aufbau auf der Experimentierplatine und der jumperbare Widerstand parallel zum Signal.
Gruß
mic
[Edit]
Nebenbei mal bemerkt: Die Hauptschleife der Liniensuche in der Bascom-Umsetzung ist ja echt knuffig:
Hier sieht mal wieder, wie einfach man auch mit Bascom sehr flotte Anwendungen ohne Assembler programmieren kann ;)Code:Do
' keine Störung erlauben
Disable Interrupts
' Warten auf Bildstart
Do
X = 0
While Adch > 30 ' sichtbare Zeile
Wend
While Adch < 50 ' Strahlrücklauf
Incr X
Wend
Loop Until X > 40 ' sync länger als 40
'warten auf 50ste Zeile
X = 50
While X > 0
While Adch > 30 ' sichtbare Zeile
Wend
While Adch < 50 ' Strahlrücklauf
Wend
Decr X
Wend
' Der Strich ist dunkler als 65. Wir zählen von links die Anzahl der
' Lesungen bis der Strich erkannt wird
X = 0
While Adch > 65
Incr X
Wend
' Linie gefunden
Enable Interrupts
' ermittelten Wert in Leerzeichen umrechnen und beides zum Terminal senden
Print X ;
S = Space(x)
Print S;
Print "***"
Waitms 200
Loop
[NocheinEdit]
Jetzt wäre eine Erweiterung auf eine Linienverfolgung nicht schwer, wenn man die Antriebe mit Bascom ansteuern kann. Da ich nicht weiß, ob es schon Bascom-Funktionen für den RP6 gibt, habe ich mal auf meiner Festplatte gesucht und ein undokumentiertes RP6-Programm (vom 21.8.08?) mit Motoransteuerung gefunden:
Das Programm kennt folgende Motorfunktionen:Code:$regfile = "M32def.dat"
$crystal = 8000000
$hwstack = 32
$swstack = 32
$framesize = 64
$baud = 38400
Declare Sub Rp6_vorwaerts()
Declare Sub Rp6_rueckwaerts()
Declare Sub Rp6_stop()
Declare Sub Rp6_links()
Declare Sub Rp6_rechts()
Dim Tccr1a_set As Byte
Dim Tccr1b_set As Byte
Dim Wert As Byte
Dim Zaehler As Word
Dim Zaehler1 As Word
Dim Test As Byte
Dim Address As Byte , Command As Byte
Config Rc5 = Pinb.2
Config Pinc.2 = Output
Config Pinc.3 = Output
Config Pinb.4 = Output
On Int0 Int0_int
On Int1 Int1_int
On Int2 Int2_int
Enable Interrupts
Config Int0 = Falling
Config Int1 = Falling
Enable Int0
Enable Int1
Enable Int2
Tccr1a_set = 0
Tccr1b_set = 0
Reset Tccr1a_set .wgm10
Set Tccr1a_set .wgm11
Set Tccr1a_set .com1a1
Set Tccr1a_set .com1b1
Tccr1a = Tccr1a Or Tccr1a_set
Reset Tccr1b_set .wgm12
Set Tccr1b_set .wgm13
Set Tccr1b_set .cs10
Tccr1b = Tccr1b Or Tccr1b_set
Icr1h = 0
Icr1l = 210
Set Portb.4
Wert = 0
Wait 1
Do
Waitms 500
Loop
Reset Portb.4
End
Int0_int:
Disable Int0
Enable Interrupts
Zaehler = Zaehler + 1
Enable Int0
Return
Int1_int:
Disable Int1
Enable Interrupts
Zaehler1 = Zaehler1 + 1
Enable Int1
Return
Int2_int:
Disable Int2
Enable Interrupts
Getrc5(address , Command)
If Command = 1 Then
Call Rp6_vorwaerts()
End If
If Command = 2 Then
Call Rp6_rueckwaerts()
End If
If Command = 3 Then
Call Rp6_links()
End If
If Command = 4 Then
Call Rp6_rechts()
End If
If Command = 0 Then
Call Rp6_stop()
End If
Enable Int2
Return
Sub Rp6_vorwaerts()
Call Rp6_stop()
Reset Portc.2
Reset Portc.3
For Wert = 0 To 100
Waitms 20
Pwm1a = Wert - 3
Pwm1b = Wert
Next
End Sub
Sub Rp6_rueckwaerts()
Call Rp6_stop()
Set Portc.2
Set Portc.3
For Wert = 0 To 100
Waitms 20
Pwm1a = Wert - 3
Pwm1b = Wert
Next
End Sub
Sub Rp6_links()
Call Rp6_stop()
Set Portc.2
Reset Portc.3
For Wert = 0 To 60
Waitms 20
Pwm1a = Wert
Pwm1b = Wert
Next
End Sub
Sub Rp6_rechts()
Call Rp6_stop()
Reset Portc.2
Set Portc.3
For Wert = 0 To 60
Waitms 20
Pwm1a = Wert
Pwm1b = Wert
Next
End Sub
Sub Rp6_stop()
For Test = Wert To 0 Step -1
Pwm1b = Test
Pwm1a = Test
Waitms 10
Next
Wert = 0
End Sub
Declare Sub Rp6_vorwaerts()
Declare Sub Rp6_rueckwaerts()
Declare Sub Rp6_stop()
Declare Sub Rp6_links()
Declare Sub Rp6_rechts()
Diese Funktionen kann man mit einer RC5-Fernbedienung auswählen. Woher das Programm stammt und ob es funktioniert kann ich leider nicht sagen.
Hallo
Die Umsetzung mit einem Pic im elektor-Septemberheft:
http://www.elektor.de/jahrgang/2010/....1468122.lynkx
Bild hier
(Bild von Elektor)
Das ist übrigens unsere 15€-SW-Kamera;)
Gruß
mic
mal ein anderer gedanken gang
es müsste doch auch möglich sein den hellsten punkt "rein" elektrisch zusuchen
immer den höchsten spannungswert speichern
videosignal( ohne sync signale) ---diode---kondensator---gnd
und dann die spannung vor und nach der diode mit einem komperator(meisten avrs haben ja ein comperator) vergleichen, wenn die spannung vor der diode größer ist soll ein interrupt ausgelöst werden.
die sache hat nur ein paar haken
die 0,7V flusspannung der diode also ist die spannung vor der diode fast immer größer
das eingangssignal muss relativ groß sein um den kondensator schnell genug laden zukönnen bei helligkeitsspitzen.
wie resetet man am einfachsten hinterher den speicher /kondensator
ich hoffe man kann verstehen was ich meine
@ Thomas$
so wie du das beschrieben hast. Suchst du nur mit der Kamera einen hellen Punkt kannst aber nicht bestimmen wo genau er sich befindet.
Wie beim Video Grabber müsste man in dem Koordinatensystem von 32x32 Bildpunkten die hellsten stellen suchen und somit zB. eine Led oder auch eine Kerze finden.
So kann man zB. heraus finden an der Stelle (10|13) ist ein heller Punkt und darauf entsprechend reagieren.
Was ich noch sehr interessant fände wäre am Display der M32 2 Spalten der Kamera anzuzeigen und auch nur 2 Farben also Weiß " " und Schwarz "#" und somit zum experimentieren die Situation vor der Kamera Live zu übertragen.
Leider kann ich es noch nicht selbst ausprobieren, da ich programmiertechnisch nicht der beste bin. Meine stärken liegen in der Elektronik.
Wenn jemand interesse daran hat würde ich gerne um Unterstützung bitten, was noch ganz lieb wäre wenn ihr den Programmtext gut kommentiert damit ich dort auch gut durchblicke ;)
Sonst: Ich habe jetzt neue Servos bestellt sodass ich jetzt auch eine Schwenkvorrichtung bauen kann.
@ radbruch
Habe nun auch die neue Eletor und werde mich mal ein wenig einlesen wie es dort vonsatten geht zwar ist esein PIC aber man kann bestimmt einige interessante Details finden.
Ich hoffe das dieses Projekt nicht untergeht, da ich es sehr interssant finde.
Einen schönen Sonntag noch
Martin
aber die schaltung könnte funktionieren oder wie gänge sie besser?
der witz an der sache ist immer wenn die spannung höher ist als im kondensator soll über den compare aeingang ein interrupt ausgelöst werden
und auf dem µC läuft ein timer
jedes mal wenn ein interupt ausgelöst wird
wird der aktuelle zeitpunkt gespeichert am ende einer zeile wird der kondensator entladen
und der letzte interrupt war der hellste punkt und über die zeit die durch den timer bestimmt wurde habe ich die exakte position und da habe ich teoretisch eine höhere auflösung weil ich weniger adc abfragen brauche
mir machen bloß die 0,7 flussspannung zuschaffen
wegen des vergleichs der beiden spannungn
wie groß sollte der kondensator sein
wie entrlade ich den kondensator
Das Video Siganl hat ja einen Spannungsbereich von 1V.
0V-0.3V für die Sync Signale und
0.3V-1V für das Video Signal.
Also kann man schon mit deiner Methode den hellsten Punkt bestimmen, aber nicht die genaue Position da du die Syncsignale weglässt somit kann man auch mit Timer die Position nicht bestimmen.
LG
Martin
ok iuch habe zuviel weggekürtzt sry
ich beziehe mich auf die schaltung des projektes mit demschaltkreis der mir schon die sync signal verrät
jetzt kommte der µC ins spiel der timer startet mit em sync der zeilen anfangs
transistor wird von µC geschalten
so das an der diode das videosignal ankommt
so wird fleisig immer wieder nder neue rekordwert bestimmt
und am ende wenn das zeile ende ereicht wird soll der kondensator kurzgeschlussenn werden über ein transtor wieder com µC aus gesteuert
ich hoffe man kan es verstehen was ich meine ansonsten muss ich mich wirklich probiern einen schaltplan zu erstellen der dann noch verbessert werden muss
Jetzt verstehe ich es langsam ;)
Ich habe vorher gedacht du willst das reine Videosignal abgreifen und nur die Spannungen auswerten.
So könnte es funktionieren und es wäre auch einen Versuch wert.
ok
nur mangelt es bei mir an der elektornik kenntnis
- als erstes ich brauch viel mehr signal pegel
-die 0,7V stören mich beim compare 2. diode verwenden das dort auch die 0,7V fehlen? sonst ist die spannung vor der diode ja fast immer höher als die am kondensator und ich habe dauerhaft interupts
-der kondensator muss teoritisch mit einem pixel vollaufladbar sein (reliv hohe ström)
-der kondansator muss die ladung bis zum zeilenende behalten können
man könnte das Signal mit einem Transistor auf bis zu 5 Volt verstärken. Ein BC547 schaltet ab 0.6-0.7V voll durch also würde die Spannung vollkommend ausreichen. Es fehlt dann nur noch ein Vorwiderstand.
R= (1V-0.7V)/0.002A
R= 150Ohm
Damit könnte hat man dann eine Ausgangspegel bis zu ca. 5 Volt
Ich hoffe ich habe es nicht wieder falsch verstanden. Falls doch wäre es nett wenn du eienn Schaltplan posten könntest.
LG
Martin
ich bin nicht gleich mit eagel klargekommen werde erstmal damit üben müssen
openoffice hat erstmal dafür hergehalten