Minimallösung: Kamera für den RP6

hey

guck mal auf der erweiterungs platine da steht int 1 drauf

lg
martin

danke den hab ich auch schon gahabt dachte aber das wär ein anderer,
den da das "E" davor nich is ich bin jezt am INT1 nur irgendwie kommt das Signal nich richtig an.

lg Alex

Hallo,

toller Thread.

Ich will das mit dem Linien-Folgen nachprogrammieren, aber scheitere an meinen Hardware-Unkenntnissen.

Wo schließt ihr den Chinch-Stecker an, so dass ihr das Bild der Kamera auf dem PC-Monitor seht? Welche Zusatzsoftware nutzt ihr?

Kann man auch einen VGA-Stecker anschließen und ihn an den VGA-Anschluss eines Monitors anschließen?

Danke für Hinweise!

Wo schließt ihr den Chinch-Stecker an

Den schließt du an GND und Signal an Signal is bei meiner Kamera vom großen C vout.

Hier nochmal ein Bild
Bild hier

1. ist Signal
2. Masse(GND)

lg Alex

Danke, das hat auch weitergeholfen, meine eigentliche Frage war eine andere... nämlich wohin ihr die Kamera anschließt, damit ihr ein Bild von der Kamera (zur Prüfung) seht?

Also wohin geht das Signal?

Das Frage ich mich auch 8-[
Ich habe das auch noch nich richtig hinbekommen ](*,) und hoffe das wir es nochmal erklärt bekommen.

lg ALex

hm... ich kann euch da nicht Helfen.

Liste der Anhänge anzeigen (Anzahl: 1)

Hallo

Zitat:

Der Anschluß:

Die 5V-Kamera wird am Pin 3/5(Vcc) und 1/2(GND) angeschlossen. Der Vid-Ausgang der Kamera (oder des beliebigen Composite-Video-Lieferanten) kommt an Pin 8 (E_INT1). Dies ist, außer den User_ADCs der einzig freie ADC-Kanal, der zudem noch praktischerweise am XBus liegt. Außerdem hat er einen PullDown von 10K, die optimale Last für ein Composite-Signal. Der Chinch-Stecker wird zusätzlich zwischen Pin 8 (Signal) und Pin 1/2 (GND) angeschlossen. Der ist eigentlich nur zu Kontrolle gedacht, damit man sehen kann, was der RP6 sieht. Gam(ma) ist bei meiner Kamera nicht angeschlossen, sollte man aber als Jumper vorsehen.

(Ein Zitat aus dem Startbeitrag dieses Threads.)

Links die Kamera, in der Mitte der Stecker für den XBUS und rechts unten der Chinchstecker zum Anschluss an den Fernseher:
Bild hier

Das Videosignal hat nominale 1V an 75Ohm. Ohne Kontrollmonitor (Fernseher) ist aber nur der PullDown am E_INT1 angeschlossen. Die gemessenen Werte sind daher höher als mit Kontrollmonitor. Um diesen Effekt etwas zu dämpfen habe ich bei späteren Anwendungen einen jumperbaren 100Ohm-Widerstand als zusätzlichen PullDown eingesetzt der im Betrieb ohne Kontrollmonitor die Signalquelle mehr belastet.

FBAS auf VGA passt nicht wirklich: http://lmgtfy.com/?q=fbas+to+vga

Gruß

mic

komisch ich finde den E_INT1 irgendwie nicht auf meinem RP6

E_INT1 ist der Anschluß PA4 am Mega32 und der Pin8 am XBUS:

Zitat:

#define UBAT (1 << PINA7) // ADC7 (Input)
#define MCURRENT_L (1 << PINA6) // ADC6 (Input)
#define MCURRENT_R (1 << PINA5) // ADC5 (Input)
#define E_INT1 (1 << PINA4) // INT1 (input per default... can be output)
#define LS_L (1 << PINA3) // ADC3 (Input)
#define LS_R (1 << PINA2) // ADC2 (Input)
#define ADC1 (1 << PINA1) // ADC1 (Input)
#define ADC0 (1 << PINA0) // ADC0 (Input)

(Aus RP6RobotBase.h)

Cool Danke ich werds mal versuchen \:D/

Lg Alex

Hallo

Trotz Mitmachprojekt finden sich immer noch keine Anwendungen für diese einfache und kostengünstige Kameralösung. Weil ich die Kamera aber für mein RA2-Projekt verwenden möchte und mir gleichzeitig eher zufällig ein zur Kamera passendes sehr grobpixeliges Display in die Hände gefallen ist, habe ich eine Variante für einen 8MHz-ATMega8 geschrieben. Aufgrund der Erkenntnisse aus dem Mitmach-Thread verwende ich als Basis das einfache 24x16 Pixel-Programm. An das Display angepasst werden nur 12 der 16 möglichen x-Pixel angezeigt, die y-Auflösung wurde auf 10 Zeilen reduziert. Der ADC rennt zwar immer noch mit Prescaler /2 im Dauerlauf, aber da nun auf das Ende der AD-Wandlung gewartet wird, ist das Einlesen eines Bildes so entspannt, dass man dazu nicht mal mehr die Interrupts sperren muss:

Code:

uint8_t bild[4][160]; uint8_t Bild_aufnehmen(void) { static uint8_t bildnummer=0; uint8_t *bildzeiger; uint8_t zeile, sync, c; bildnummer = (bildnummer+1) & 3; // Bildnummer von 0 bis 3 zeile=30; // 30 Zeilen am Bildanfang überlesen bildzeiger = &bild[bildnummer][0]; do{sync=0;while (ADCH > 20);while (ADCH < 30) sync++;}while (sync < 40); for(c=0; c<10; c++) // 10 Zeilen einlesen { 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=24; // 24 Zeilen überlesen (30+ 24*10 = 270 Zeilen) } return(bildnummer); }

Wie gehabt wird der ADC mit Prescaler /2, rechtsbündig und mit interner 2,56V-Referenz betrieben. Nach der Erkennung des Bildstarts werden 30 Zeilen überlesen, dann werden in einem Rutsch die 16 Pixel einer Zeile eingelesen. Nach jeweils einem Zeilensprung von 24 Zeilen werden dann schließlich die restlichen 9 Zeilen eingelesen. Das alles passiert innerhalb eines Halbbildes und mit freigegebenen Interrupts!

Der Bildspeicher ist 16x10=160 Bytes groß, ich verwende davon vier Stück die ich nacheinander mit den Kameradaten fülle. Die Einlesefunktion verwendet die Bildspeicher als Ringspeicher. Die Auswertefunktion bildet das Mittel aus den einzelnen Bildspeichern und stellt die Pixel auf dem Display dar:

Bild hier
http://www.youtube.com/watch?v=ngim6DzIcGQ

Mein ungeputzter Arbeitscode:

Code:

// Kamera und acht Helligkeitsstufen mic 29.12.2010 #include <avr/wdt.h> #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <util/delay.h> #include <inttypes.h> #define colors 8 // Anzahl der Farbebenen (8 ist Maximum!) // Variablen ------------------------------------------------------------------ volatile uint8_t ebene=0, col = 0; // Bildaufbau der LED-Matrix mit Timer2-ISR uint8_t x, y, z, bildspeicher[colors][15]; uint8_t bild[4][160]; uint16_t counter=0; uint8_t attrib=1; prog_uint8_t font[5][17]={ // Zeichensatz für 3x5 7-Segmentanzeige 0 bis F und Blank (Speicherplatz im Flash) { 0b111, 0b001, 0b111, 0b111, 0b100, 0b111, 0b100, 0b111, 0b111, 0b111, 0b111, 0b100, 0b111, 0b001, 0b111, 0b111, 0b000},\ { 0b101, 0b001, 0b001, 0b001, 0b101, 0b100, 0b100, 0b001, 0b101, 0b101, 0b101, 0b100, 0b100, 0b001, 0b100, 0b100, 0b000},\ { 0b101, 0b001, 0b111, 0b111, 0b111, 0b111, 0b111, 0b001, 0b111, 0b111, 0b111, 0b111, 0b100, 0b111, 0b111, 0b111, 0b000},\ { 0b101, 0b001, 0b100, 0b001, 0b001, 0b001, 0b101, 0b001, 0b101, 0b001, 0b101, 0b101, 0b100, 0b101, 0b100, 0b100, 0b000},\ { 0b111, 0b001, 0b111, 0b111, 0b001, 0b111, 0b111, 0b001, 0b111, 0b001, 0b101, 0b111, 0b111, 0b111, 0b111, 0b100, 0b000} \ }; prog_uint8_t * fnt = (prog_uint8_t *) font; // Zeiger für den Zugriff auf den Zeichensatz (für plot_byte()) // Funktionen ----------------------------------------------------------------- void init(void); void cls(void); void plot_byte(uint8_t x, uint8_t y, uint8_t ziffer); // Ziffer von 0 bis F void write_byte(uint8_t a, uint8_t z); // z=0 ist oben, z=1 ist unten uint8_t Bild_aufnehmen(void); void Bild_darstellen(uint8_t level); void Bild_Info(void); // Einen Bildpunkt an x, y setzen. Werte für c: 0 ist aus, 1 ist dunkel, 4 ist hell void set(uint8_t x, uint8_t y, uint8_t c); // Potiwert P2 an ADC6 einlesen als Byte! Kanal 7 ist die Cam uint8_t readADC6(void); // WatchDog beim Initialisieren ausschalten // https://www.roboternetz.de/phpBB2/vi...=531597#531597 void kill_WD(void) __attribute__((naked)) __attribute__((section(".init3"))); void kill_WD(void) { MCUSR = 0; wdt_disable(); } // Hauptschleife -------------------------------------------------------------- int main(void) { init(); for(x=0; x<12; x++) for(y=0; y<10; y++) set(x, y, (colors-((x+y)/3)%colors)); // Helligkeitsstufen anzeigen _delay_ms(2000); cls(); while(Bild_aufnehmen()); // Bildspeicher füllen // Bild_Info(); // min - max - mitte - durchschnitt while(1) { if(!col) { z=readADC6(); if(attrib) { for(y=5; y<10; y++) for(x=0; x<12; x++) set(x, y, z/29); // 255/29 ergibt 8,8 } else { while(Bild_aufnehmen()); Bild_darstellen(z); } if(z==0) if(attrib) { attrib=0; Bild_Info(); } // Bit0: Zeile if(z==255) if(!attrib) { attrib=1;}; if(attrib) write_byte(z, attrib); } counter++; } return (0); } // Definitionen der Funktionen ------------------------------------------------ uint8_t Bild_aufnehmen(void) { static uint8_t bildnummer=0; uint8_t *bildzeiger; uint8_t zeile, sync, c; bildnummer = (bildnummer+1) & 3; // Bildnummer von 0 bis 3 zeile=30; // 30 Zeilen am Bildanfang überlesen bildzeiger = &bild[bildnummer][0]; do{sync=0;while (ADCH > 20);while (ADCH < 30) sync++;}while (sync < 40); for(c=0; c<10; c++) // 10 Zeilen einlesen { 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=24; // 24 Zeilen überlesen (30+ 24*10 = 270 Zeilen) } return(bildnummer); } void Bild_darstellen(uint8_t level) { uint8_t x, y, temp; uint8_t bild_temp[160]; uint16_t temp16; for(x=0; x<160; x++) { temp16 = bild[0][x] + bild[1][x] + bild[2][x] + bild[3][x]; bild_temp[x] = temp = temp16/4; } if(level) { for(y=0; y<10; y++) for(x=0; x<12; x++) { temp= bild_temp[16*y+x+2]; if(temp<level) set(x, 9-y, colors); else set(x, 9-y, 0); } } else for(y=0; y<10; y++) for(x=0; x<12; x++) { temp= bild_temp[16*y+x+2]; set(x, 9-y, (temp-20)/8); } } void Bild_Info(void) { uint8_t min=225, max=0, temp; uint16_t durchschnitt=0, temp16; for(x=0; x<160; x++) { temp16 = bild[0][x] + bild[1][x] + bild[2][x] + bild[3][x]; temp = temp16/4; if(temp > max) max=temp; else if(temp>20) if(temp < min) min=temp; durchschnitt += temp; } durchschnitt /= 160; cls(); write_byte(min, 1); _delay_ms(1000); cls(); write_byte(max, 0); _delay_ms(1000); cls(); write_byte((min+max)/2, 1); _delay_ms(1000); cls(); write_byte(durchschnitt, 0); _delay_ms(1000); } void cls(void) { uint8_t x, y; for(y=0; y<colors; y++) for(x=0; x<15; x++)bildspeicher[y][x] = 0; } void set(uint8_t x, uint8_t y, uint8_t c) { uint8_t ebene; y = 9-y; // Koordinatennullpunkt unten links if(y < 8) // y 9 bis 2 for(ebene=0; ebene<colors; ebene++) if(c>ebene) bildspeicher[ebene][x] |= (1 << y); else bildspeicher[ebene][x] &= ~(1 << y); else // y 1 und 0 for(ebene=0; ebene<colors; ebene++) if(c>ebene) bildspeicher[ebene][12+(x>>2)] |= (1<<((x%4)*2+(y&1))); else bildspeicher[ebene][12+(x>>2)] &= ~(1<<((x%4)*2+(y&1))); } void plot_byte(uint8_t x, uint8_t y, uint8_t ziffer) { uint8_t c, f1=colors, f2=0, fontbyte=0; for(c=0; c<5; c++) { fontbyte = pgm_read_byte_near(fnt+17*c+ziffer); // Zeichensatz ist im Flash if(fontbyte & 4) set(x , y-c, f1); else set(x , y-c, f2); if(fontbyte & 2) set(x+1, y-c, f1); else set(x+1, y-c, f2); if(fontbyte & 1) set(x+2, y-c, f1); else set(x+2, y-c, f2); if(fontbyte & 0) set(x+3, y-c, f1); else set(x+3, y-c, f2); } } void write_byte(uint8_t a, uint8_t z) // z=0 ist oben, z=1 ist unten { uint8_t c, temp=1; c=0; while(a >= 100) {a-=100; c++; } if(c) plot_byte(0, 9-5*z, c); else { plot_byte(0, 9-5*z, 16); temp=0; } c=0; while(a >= 10) {a-=10; c++; } if(c || temp) plot_byte(4, 9-5*z, c); else plot_byte(4, 9-5*z, 16); c=0; while(a >= 1) {a-=1; c++; } plot_byte(8, 9-5*z, c); } uint8_t readADC6(void) { uint8_t adc6, dummy; ADCSRA = (0 << ADEN); dummy=ADCH; // A/D Conversion (aus der asuro-Lib) ADCSRA = (1 << ADEN) | (1 << ADPS2) | (0 << ADPS1) | (1 << ADPS0); // clk/32 ADMUX = (1<<ADLAR) | (1 << REFS0) | (6);// AVCC reference with external capacitor ADCSRA |= (1 << ADSC); // Start conversion while (!(ADCSRA & (1 << ADIF))); // wait for conversion complete adc6=ADCH; ADCSRA |= (1 << ADIF); // clear ADCIF ADCSRA = (0 << ADEN); dummy=ADCH; // rechtsbündig, interne 2,56V-Referenz (0:1 5V, 1:1 2,56V) , Kanal 7 ADMUX = (1<<ADLAR) | (1<<REFS1) | (1<<REFS0) | 7; // enable, start conversion, freerunning, prescaler /2 ADCSRA = (1<<ADEN) | (1<<ADSC) | (1<<ADFR) | (0<<ADPS2) | (0<<ADPS1) | (1<<ADPS0); return(adc6); } void init(void) { cli(); DDRB = 0xff; DDRC = 0x0f; DDRD = 0xf0; TCCR2 = (1<<CS21) | (0<<CS20); // 8-bit Timer mit 1/8 Vorteiler TCCR2 |= (1<<WGM21) | (1<<WGM20); // Fast PWM TCCR2 |= (0<<COM21) | (0<<COM20); // no OC2-Pin OCR2 = 100; // 0=dunkel, 255=hell TIFR = (1<<OCF2) | (1<<TOV2); // Clear old flags TIMSK |= (1<<TOIE2) | (1<<OCIE2); // overflow and compare interrupt // rechtsbündig, interne 2,56V-Referenz (0:1 5V, 1:1 2,56V) , Kanal 7 ADMUX = (1<<ADLAR) | (1<<REFS1) | (1<<REFS0) | 7; // enable, start conversion, freerunning, prescaler /2 ADCSRA = (1<<ADEN) | (1<<ADSC) | (1<<ADFR) | (0<<ADPS2) | (0<<ADPS1) | (1<<ADPS0); sei(); // Interrupts erlauben } // ISR ------------------------------------------------------------------------ SIGNAL (SIG_OUTPUT_COMPARE2) { OCR2 = (1<<ebene)-1; // hihi PORTC &= ~0x0f; // Die Pins der Displaymatrix werden wieder auf Low gesetzt PORTD &= ~0xf0; PORTB &= ~0x03; } SIGNAL (SIG_OVERFLOW2) { uint8_t ledval, portb; // Spalten if(col) PORTB |= (1<<4); /* Danach Einsen hinterherschicken (PB4 = 1) */ else PORTB &= ~(1<<4); /* Bei der ersten Spalte eine 0 ausgeben (PB4 = 0) */ PORTB |= (1 << 3); /* PB3 = 1 (cl) */ PORTB &= ~(1 << 3); /* PB3 = 0 (!cl) */ PORTB |= (1 << 2); /* PB2 = 1 (str) */ PORTB &= ~(1 << 2); /* PB2 = 0 (!str) */ // Zeilen ledval = bildspeicher[ebene][12+(col>>2)]; // y 1 und 0 portb = (ledval >> (col%4)*2) & 0x03; ledval = bildspeicher[ebene][col]; // y 9 bis 2 PORTC |= ledval & 0x0f; PORTD |= ledval & 0xf0; PORTB |= portb; col++; if(col>11) { col=0; ebene++; if(ebene == colors) ebene=0; } }

Gruß

mic

Hi mic,

das ist ja mal wieder genial!

Ich hole mir dieses PingPong erst mal vom großen C.

Ich wußte gar nicht, dass da ein M8 drin sitzt...

Gruß Dirk

Gibt es einen aktuelleren Quellcode?
Ich möchte dieses Projekt für mein nächstes verwenden.

Das ist der aktuellste Quellcode. Der ADC wird zwar auch hier gnadenlos übertaktet, aber beim Einlesen einer Bildzeile wird nicht mehr stur eingelesen sondern auf den Status des ADC geachtet. Es ist die aktuell schnellste Lösung, alle Pixel werden innerhalb eines Halbbildes eingelesen. Basis ist diese Version:

https://www.roboternetz.de/phpBB2/ze...=500285#500285

Bedeutend höhere Auflösungen sind auch möglich, allerdings wird so pro Halbbild nur ein Pixel pro Zeile eingelesen:

https://www.roboternetz.de/community...l=1#post458253
https://www.roboternetz.de/community...l=1#post457599

Was soll die Kamera bei deinem Projekt erkennen?

Die Kamera soll drei IR Laser Orten um die Landung eines Quadrocopters autonom erfolgen zu lassen. Wenn ich fertig bin werde ich mal ein Video posten (wahrcheinlich erst in den Sommerferien).
Danke für den aktuellen Quellcode. Mit was hast du den denn Compiliert?

LG Matthias

Hallo,

ist es mit der von dir beschriebenen Methode denn auch möglich Farben zuverlässig zu unterscheiden?
Wie kalibrierst du die Kamera? Machst du das manuell, indem du werte im Programm änderst oder geht das automatisch?

Gruß

Hallo

Mit Farberkennung habe ich noch keine Versuche unternommen. Eventuell kann man mit Filterscheiben arbeiten?

Da die Kamera einen automatischen Weisabgleich macht, braucht man eigentlich nichts kalibrieren. Zur Zeit spiele ich mal wieder mit einem Linienfolger, diesmal aber mit dem asuro und in Bascom:
http://www.youtube.com/watch?v=usS3a3Ud_vo

Es klappt zwar noch nicht so gut, aber es ist auch eher als Einstieg in eine echte Bildverarbeitung gedacht.

Gruß

mic

Hallo

Gleich vorweg die Warnung: Dieser Beitrag ist nur für die wirklich harten Kamera-Fans geeignet.

Zur Zeit versuche ich die Kamera auch mit Bascom in den Griff zu bekommen. Das klappt auch ganz gut:

http://www.youtube.com/watch?v=sr-7kZ68qDo

Basis ist der eigentlich schon getestete Code für den RP6. Wie üblich hangelt sich der Code an den Syncs zum Bildanfang und dann zur Zielzeile, in meinem Programm zur 50. Zeile. Dann wird laufend geprüft, ob die Helligkeit größer einer bestimmten Schwelle ist. Die Anzahl der Prüfungen wird mitgezählt und das Ergebnis ist dann der Wert für die Position der Kante der Linie:

Code:

Do ' Auf Bildanfang warten B = 0 While Adch > 30 ' solange kein sync Wend While Adch < 50 ' solange sync Incr B ' syncs zählen Wend Loop Until B > 40 ' mehr als 40 bedeutet Bildanfang B = 50 ' die zu lesende Zeile While B > 0 ' Zeilen zählen While Adch > 30 ' solange kein sync Wend While Adch < 50 ' solange sync Wend Decr B Wend ' Zeile gefunden B = 0 While Adch > 65 ' Hell/Dunkel-Schwelle Incr B ' warten und zählen bis Schwellwert erreicht wird Wend Linie = B ' Rückgabewert kopieren

Wichtig ist nun diese kleine und eigentlich unscheinbare Funktion:

Code:

B = 0 While Adch > 65 ' Hell/Dunkel-Schwelle Incr B ' warten und zählen bis Schwellwert erreicht wird Wend

Was mache ich da? Der Pegel des Videosignals in ADCH ist beim Sync deutlich unter 30, alles was größer als 50 ist, wird als Bildinformation interpretiert. Alle Werte über der Schwelle von 65 werden als "Hell" gewertet, ein Wert unter der Schwelle bedeutet die Kante der Linie ist gefunden.

Eigentlich hätte ich nun erwartet, dass bei einem 8MHz-RISC-Kontroller der Zähler sofort in die Höhe schießt, denn die Ausführung der kleinen Scheife dauert nur ein paar Takte. Dem ist aber nicht so! Wenn ich mit Adch > 50, quasi alles was nicht Syncpegel ist, als Bildbereich gelten lassen, komme ich auf Zählerstände von maximal 27. Das ist auch das, was man im Video oben sieht und hört: Wenn der Linienwert >26 ist wird keine Linie erkannt, weil sie außerhalb des Sichtbereichs der Kamera ist. Aber warum ist der Wert so unerwartet niedrig? Ich vermute, Bascom wartet intern bis der ADC mit der Wandlung fertig ist bevor der Wert von ADCH gelesen werden kann. Das würde also 26 echte Positionen bedeuten, was allerdings zu den in C ermittelten maximalen 16 nicht ganz passt. Hier muss man noch etwas weiter forschen, aber ich schweife auch ab....

Wirklich spannend ist nun folgendes: Wenn man die Schwelle nicht als absoluten Wert angibt sondern als Variable, dann verändern sich die gemessenen Werte:

Dim Schwelle As Byte

...
Adch > Schwelle
...

So komme ich nur noch auf Maximalwerte von ca. 23! Irgendwas an der Art der Zuweisung scheint so länger zu dauern als in der Variante mit Konstanten. Sehr seltsam. Was Basom da übersetzt sollte man mal disassemblieren.

Gruß

mic

Hallo

Da ich mal wieder an meiner ewigen Kamerabaustelle arbeite, kann ich nun quasi die Version 2.0 der Minimalkamera als Beta vorstellen.

Bisher hatten wir das Problem, dass wir zwar die Syncs gefunden haben, aber die Flanken wurden nicht richtig erkannt. Deshalb "zitterte" der Zeilenanfang beim Einlesen der Bilddaten. Das sieht man deutlich bei den HiRes-Bildern:

Bild hier Bild hier Bild hier
(Bilder aus https://www.roboternetz.de/community...l=1#post458253)

Nun bin ich schon vor einiger Zeit im Datenblatt der AVRs über diesen Satz in der Beschreibung des analogen Komparators (Analog Comparator) gestolpert:

Zitat:

The output of the Analog Comparator is synchronized and then directly connected to
ACO. The synchronization introduces a delay of 1 - 2 clock cycles.

Frei übersetzt: Der Status der Komparators wird innerhalb von 1 bis 2 Taktzyklen (!) im ACO-Bit dargestellt.

Blöderweise sind aber die Pins des Komparators bei meinen Fertigrobotern schon belegt, deshalb habe ich diesen Ansatz bisher nicht weiterverfolgt. Eher zufällig ist mir nun aufgefallen, dass mein asuro-probot genau diese Pins nicht verwendet, wenn ich die Sensorplatine nicht einstecke. Dadurch kann ich nun AIN0 und AIN1 nutzen. Als zusätzliche Hardware erzeuge ich mit einem 10k-Poti eine einstellbare Spannung an AN0 als Schwelle für den Sync-Pegel, die Erweiterung der Software beschränkt sich auf das Umschalten zwischen ADC- und AC-Betrieb und der geänderten Sync-Erkennung:

Code:

Sub Readline(byval Zeile As Word) Local Znr As Word ' AC einschalten Vergleich zwischen AIN0 (PD6) und ADC-Kanal 4 (PC4) Reset Adcsr.aden ' ADC dissable Reset Acsr.acd 'enable analog comparator ACSR bit 7 = 0 Portd.4 = Acsr.aco ' Status zeigen: Warten auf Bildstart Do ' Auf Bildanfang warten Znr = 0 While Acsr.aco = 0 ' solange kein sync (PC4 > PD6) Wend While Acsr.aco = 1 ' PC4 < PD6 = Sync Incr Znr ' syncs zählen Wend Loop Until Znr > 60 ' mehr als 60 (mit AC!) bedeutet Bildanfang Znr = Zeile ' die zu lesende Zeile While Znr > 1 ' Zeilen zählen While Acsr.aco = 0 ' solange kein sync Wend While Acsr.aco = 1 ' solange sync Wend Decr Znr ' eine Zeile vor dem Ziel... Wend While Acsr.aco = 0 ' solange kein sync Wend ' ADC einschalten Set Adcsr.aden ' ADC Enable Set Adcsr.adsc ' ADC Start Conversion Portd.4 = Acsr.aco ' Status zeigen: Zeile gefunden Set Adcsr.adif ' ADIF-Bit rücksetzen !!! Nur schreibend zugreifen !!! While Adcsr.adif = 0 ' warten bis ADC fertig mit Wandeln Wend Znr = Adch ' erste Lesung ist noch Sync Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(01) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(02) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(03) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(04) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(05) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(06) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(07) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(08) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(09) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(10) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(11) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(12) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(13) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(14) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(15) = Adch Set Adcsr.adif While Adcsr.adif = 0 Wend Linienspeicher(16) = Adch Set Adcsr.adif End Sub

Da der ADC wie gehabt im Dauerlauf gestartet wurde, schaltet die Funktion zuerst den ADC aus und den AC ein. Dann hangelt sich die Funktion durch die Syncs über den Bildanfang bis zu der Zeile, die sich vor der gesuchten Zeile befindet. Wenn am Ende dieser Zeile der Sync erkannt wird, schaltet die Funktion von AC auf ADC zurück und startet die erste Wandlung des ADC noch während des Syncs. So wird der Zeilenanfang mit einer bisher noch nicht gekannten Genauigkeit getroffen. Dieses einfache Demo

Code:

While X = X Readline 50 For X = 1 To 16 Print Linienspeicher(x) ; " "; Next X Print Waitms 300 Wend

erzeugt diese Ausgabe:

Code:

Bascom-Spielereien mit der Kamera 96 102 103 103 103 103 99 79 57 99 99 96 96 46 6 35 96 102 103 103 103 102 99 56 57 99 97 96 96 15 3 35 96 103 103 103 103 102 99 56 60 99 97 96 96 9 3 35 96 102 103 103 103 102 99 71 57 99 99 96 96 39 6 35 96 102 103 103 103 102 99 57 57 97 97 96 96 39 6 35 96 102 103 103 102 102 99 57 57 97 97 96 96 19 3 35 96 102 103 103 103 102 99 57 56 99 97 96 96 39 6 35 96 102 103 103 103 103 99 63 57 99 99 96 96 39 6 35 96 102 103 103 103 102 99 56 56 97 97 96 96 39 6 35 96 102 103 103 103 102 99 76 56 99 99 96 96 41 6 35 97 103 103 103 103 102 99 60 60 99 97 96 96 15 3 35 88 102 102 103 102 102 99 79 56 99 99 96 96 54 6 35 97 103 103 103 103 102 99 56 62 99 97 96 96 9 3 35 87 103 103 103 103 102 99 60 60 99 97 96 96 30 4 35 96 102 103 103 103 103 99 76 56 99 99 96 96 44 6 35 86 102 103 103 103 102 99 70 57 99 99 96 96 39 6 35 96 102 103 103 103 102 99 78 56 99 99 96 96 44 6 35 96 103 103 103 103 102 99 57 57 99 97 96 96 19 3 35 96 102 103 103 103 102 99 56 57 99 97 96 96 14 3 35

Werte<70 sind der Strich, <ca. 40 ist der Sync am Ende der Zeile. Es sind also ca. 13 Werte pro Zeile die gelesen werden.

Gruß

mic

Hallo Radbruch

Gigantisch was du da gemacht hast. Funktionier das auch mit einer Farbkamera zb. 156967 - 62 vom grossen C ? Muss man da etwas besonderes beachten oder kann ich die Kamera wie oben beschrieben anschliessen ?

Danke und Grüße
HSC123

Hallo

Obwohl ich es nie mit einer Farbkamera versucht habe, gehe ich davon aus, dass es mit dieser Kamera auch funktioniert. 5V Versorgung und 1V Signal scheint ideal, nur der Preis ist etwas happig. Bevor du dich in Unkosten stürzt, sollte dir klar sein, das es keine "ready to use"-Lösung für diese Anwendung einer Kamera gibt.

Für den Fall, dass du das noch nicht gefunden hast, hier der Link zum "Mitmach-Projekt" (das softwaremäßig leider in den Startlöchern stecken geblieben ist). Großes Lob an dieser Stelle an Dirk:

http://www.roboternetz.de/community/...ra-für-den-RP6

Gruß

mic

Hallöle,
man muss vielelicht dazu sagen, das eine cam Lösung weniger an irgendwelchen technischen Problemen scheitert - eagl ob SW oder das schwieriger zu dekodierende FBAS Farbsignal - als viel mehr am verfügbaren Ram um das Image dann auch im Speicher abzubilden und auszuwerten. Die meisten mir bekannten Lösungen schieben daher das Bild raw auf den PC welcher das Image in Folge bearbeitet und Steuersequenzen an den Mega32 sendet. Auf dem Mega32 ist nicht viel mehr als z.B. ein einfacher Linienfolger machbar - und der muss nicht bunt sein. Ein Farbbild braucht im günstigsten Fall "nur" 3 mal mehr Ram als ein greyscale gleicher Bittiefe.
Möchte man dann aber noch Einstellungen an der cam vornehmen (capture/exposure time usw.), ist man mit einer i2c-cam eh besser bedient. Allerdings löst das auch nicht das allgegenwärtige Speicherproblem.
Wenn du sinnvoll mit einer Cam spielen möchtest, leg dir daher lieber gleich nen anständiges ARM7/9 Board mit satt Speicher und USB Cam zu oder versuch die PC-lösung... z.B. mit der neuen WLAN Karte.

Selbst das Minibild einer Gameboy cam in greyscale verlangt schon 8-16k Ram.... je nach bittiefe
http://www.angelfire.com/de3/juliprograms/amr/gbcam.htm
Und das Ding ist wenigstens dank Artifical Retina Image Sensor einstellbar.
(äm.. womit ich nicht das Projekt hier kritisieren möchte... aber es hat eben Grenzen...)

Gruß Rolf

Hi,

man muss aber nicht das ganze Bild im RAM halten für einige bestimmte algos.
z.B. hier:
http://www.jrobot.net/Projects/AVRcam.html

farbige Objekte verfolgen und Statistiken mit nem kleinen MEGA8.
Das geht natürlich nicht mit der analogen Cam das ist klar.
Bei den analogen Cams geht natürlich auch noch einiges mehr an Rechenzeit für das erfassen des Bildes ansich drauf...

Hallo,
vielleicht liest jemand das hier noch der hier in dem Thread aktiv ist /war oder jemand der mir trotzdem weiterhelfen kann (:.
Ich finde das das hier eine super Idee ist. Deswegen möchte ich das nun auch nachbauen. Nur hat Conrad dummerweise das Kamera Modul 1 aus dem Programm genommen. Und jetzt suche ich nach einer Kamera die ich ersatzweise benutzen kann finde aber keine die genau wie diese 5 Pole hat... Deswegen wollt ich fragen was für eine Kamera dafür benutzbar ist (:. Weil die im Mitmach Projekt auch die alte Kamera verwendenhilft mir das uch nicht weiter. Ich hättee aber gerne auch noch so eine Kamera mit 5 Polen. Also mit Vcc (am besten +5V), GND, Gamma, VIDEO-IN, Gain).

Danke im Vorraus,

DarkSoldier

Hallo

Ja, leider ist die Kamera nicht mehr lieferbar. Grundsätzlich funktionieren alle Kameras mit AV-Ausgang, denn deren Signal hat immer 1V. Schwieriger ist es eine passende Eingangsspannung zu finden. Bei den 12V-Typen vermute ich einen internen Spannungsregler der möglicherweise die von uns gewünschten 5V erzeugt:
http://www.pollin.de/shop/dt/NTM5OTE...amera_S_W.html

Vermutlich funktioniert auch eine Farbkamera , denn die SW-Fernseher konnten ja auch ein Farbbild in Graustufen darstellen:
http://www.conrad.de/ce/de/product/156967/

Aber das habe ich selbst noch nicht getestet. (Oje: https://www.roboternetz.de/community...l=1#post556795)

Gruß

mic

Hallo,
Danke erstmal für deine schnelle Antwort.
Ich habe mir überlegt das ich mir die Kamera vom Großen C besorgen werde die du als Link geschrieben hattest.
Ich habe mir auch in den letzten Stunden gedanken über die Programmierung gemacht. Da hab ich dieses Bild hier gefunden: http://ires.roboterbastler.de/images...nmoduliert.PNG
Das ist doch dann 1 einzelnes Pixel oder nicht? Welches dann vermutlich in einem Byte abgespeichert werden kann oder hab ich das noch nicht richtig verstanden?
Und da gibts dann sozusagen die "ankündigung" für ein neues Pixel, dann wird die Spannung auf 0V gezogen für 4,7us und dann wird sie für 5,8us auf 0,3 V erhöht. Worauf dann für 13us dass signal für schwarz kommt und je nach höhe der spannung ist das pixel mehr oder weniger schwarz, dann dass selbe jeweils für grau, hellgrau und weiß. Dann kommt noch eine "endsequenz".
Hab ich das jetzt richtig verstanden oder habe ich da einen Grundlegenden Denkfehler?

Danke für deine/eure Hilfe
DarkSoldier

Hi DarkSoldier,

nein, das Bild zeigt eine ganze Bildzeile.
Du kannst dir vielleicht die Grundlagen bei dem RP6 Kamera Mitmach-Projekt ansehen: http://www.rn-wissen.de/index.php/RP...ations-Signale

Hallo,
also ich habe mich da jetzt mal durchgekämpft ;)

Da gibt es ja ein Csync und ein Hsync die aber durchaus zu gleichen Zeiten unterschiedliche Werte haben. Deswegen stellt es mir grade die Frage wie man das alles durch ein Kabel jagen kann :O . Ich möchte anfangs erstmal auf jedenfall nur das Hsync der kamera auslesen und "auswerten". Und das Csync ignorieren, dass läuft doch in der Zeit ab in der das Hsync Pause macht oder nicht? Und alles geht durch das gleiche Kabel? (:

Entschuldigt bitte doppelt und 3 fache fragen usw.. aber über ein soo großes elektrotechnik wissen verfügt man in der 10. Klasse eines bayrischen gymnasiums leider noch nicht :( da macht man ja leider GAR NIX zu solchen interessanten themen... das muss man sich alles seber beibringen ;)

danke an euch für eure hilfe ;)

DarkSoldier

- - - Aktualisiert - - -

Hallo nochmal,

jetzt wo ich mir den wikipedia artikel dazu nochmal angesehen hab ist mir vermutlich der sinn der farbverteilung aufgefallen ;) die eingezeichneten graphen geben die spannung wieder die durch das einzige kabel durchfliesst. bei einem fernseher mit zb 4 farbstufen gibt es also 4 verschiedene spannungen von denen jede einzelne "ihre farbe" zugewiesen bekommen hat also weiß hat immer ca. 1 volt. usw. unt vor jeder zeile gibt es eine art "vorsequenz" die sagt, dass da jetzt eine neue zeile anfängt. und danach auch.
Hab ich das jetzt richtig verstanden? ;)
Danke,
Darksoldier

Ja, so ähnlich.
Da wird wirklich in Form eines Spannungsverlaufs die ganze Zeile dargestellt und die "Vorsequenz" kennzeichnet Zeilenanfänge. Es gibt auch genauso "Vorsequenzen" für Seitenwechsel. Es wird allerdings nicht die Farbe, sondern die HELLIGKEIT der Bildpunkte in der Zeile dargestellt.

Gut :D
Naja ich werd mir dann mal die kamera besorgen und mal mitm oszi usw mir des anschauen vlt versteh ichs dann ja komplett (:

Danke erstmal,
DarkSoldier

Hallo,

nun muss ich dieses in die Jahre gekommene Thema auch mal ausgraben. Ich habe ebenfalls vor, eine SW-Kamera an den RP6 anzuschließen, damit er Linien verfolgen kann. Dazu habe ich mir folgende Platinenkamera besorgt: http://www.conrad.de/ce/de/product/1...-352-H-x-288-V

Zunächst ist sie am ADC0 angeschlossen, ihre Stromversorgung ist VDD und wurde mit einem Widerstand versehen, um auf die 3V Betriebsspannung zu kommen. Das schwarze Kabel ist an GND angeschlossen. Ein einfaches Programm ließt die ADC-Werte und schreibt sie in den Terminal (Light-Detection Beispielprogramm auf andere ADC-Kanäle abgeändert). Dabei erhalte ich Werte von 350 +/-20 mV. Theoretisch sollte sich der Großteil der Werte verändern, wenn man die Kamera direkt ins Licht hält oder die Linse verdeckt, da die Sync-Signale ja nur sehr kurz andauern. Allerdings schwanken die Spannungen ohne erkennbares Muster in dem genannten Bereich. Beeinflussen kann man sie nicht.

Daher erst einmal folgende Frage: Kann es sein dass meine Kamera defekt ist/ nicht dafür geeignet ist/ meine Überlegungen bezüglich der Beeinflussung der Werte völlig falsch sind?

Andererseits wurde ja immer zum E_Int 1 als ADC geraten. Hierbei wüsste ich aber nicht, wie ich diesen Einlesen soll. Ist dafür ADCH zuständig?

Einen schönen Abend!

Hallo

So auf den ersten Blick scheint die Kamera geeignet, auch wenn sie leider nicht gerade billig ist.

Bei einer Stromaufnahme (laut minimalem Datenblatt der Kamera) von ca. 40mA sollte der Vorwiderstand wohl ca. (5V-3V)/0,04A = 50 Ohm betragen. Größer wäre vielleicht sicherer, ein echter Spannungregler, eine Spannungsregelung mit Z-Diode oder zumindest ein Spannungsteiler scheint mir aber besser/genauer zu sein. Zusätzlich sollte auch das Signal der Kamera mit einem Widerstand (nominal ca. 75 Ohm, kann aber auch bis zu mehrere 100 Ohm sein) belastet werden.

"Ein einfaches Programm ließt die ADC-Werte und schreibt sie in den Terminal" Das Programm solltest du uns zumindest mal zeigen. Der Mega32 hat nur einen analogen Wandler (=ADC) der ein 10-bitiges Ergebniss liefert. Mit diesem Wandler kann man aber verschiedene Eingänge (=Kanäle) wandeln, ob das der E-INT oder der ADC0 ist ist egal solange der verwendete Kanal im ADMUX-Register auch richtig ausgewählt ist. Das Ergebniss der Wandlung steht im ADC-Register welches sich aus ADCH (Bit 15-8) und ADCL (Bit 7-0) zusammensetzt. Es werden allerdings nur die Bits 9-0 verwendet. Das Videosignal sollte maximal (weiser Bildpunkt) ca. 1V betragen (je nach Belastungswiderstand kann es auch etwas mehr sein!)

Als Referenzspannung verwendet man die interne 2,56V-Reverenz. Um das Kopieren des Ergebnisses aus dem 16bit ADC-Register etwas zu beschleunigen, und um Speicherplatz zu sparen, wird das Ergebniss im ADC-Register linksbündig dargestellt und nur das ADCH-Register gelesen.

Ein kleiner Überblick:

Hier werden 254 Werte eingelesen und zum Terminal gesendet:
https://www.roboternetz.de/community...l=1#post457514

Für ADC0 muss hier der Kanal geändert werden:
// ADC interne Referenz 2,56V, Ergebniss linksbündig, Kanal ADC4 (E_INT1)
ADMUX = (1<<REFS1) | (1<<REFS0) | (1<<ADLAR) | 4; // 0 für ADC0

Hier sieht man ein Sync (55-57), die Schwarzschultern (52-54 und 58-64) und ab Zeile 65 beginnt dann die Bildzeile:

Code:

51: 54 30 51 54 52: 15 30 31 35 53: 15 30 31 35 54: 15 30 31 35 55: 4 6 6 6 56: 4 6 6 6 57: 4 6 6 6 58: 28 28 28 28 59: 28 28 28 28 60: 28 28 28 28 61: 28 28 28 28 62: 28 28 28 28 63: 28 28 28 28 64: 28 56 28 28 65: 56 56 56 56 66: 56 56 56 56 67: 56 56 56 56 68: 56 57 56 56 69: 56 57 56 56 70: 56 57 56 56 71: 57 60 60 60

( Aus https://www.roboternetz.de/community...l=1#post457514)

Die Syncwerte muss man eventuell an die Kamera anpassen:

Code:

do{sync=0;while (ADCH > 20);while (ADCH < 30) sync++;}while (sync < 40);

(ADCH > 20 bedeutet Bildzeile, ADCH < 30 ist ein Sync und mehr als 40 Syncs am Stück bedeutet der Start eines neuens Bildes)

Das hier ist die letzte Variante des Programms. Es wird gewartet bis die jeweilige Wandlung beendet ist:
https://www.roboternetz.de/community...l=1#post463226

Der aktuelle Stand der Entwicklung ist die Verwendung des analogen Komperators zur Erkennung der Syncs:
https://www.roboternetz.de/community...l=1#post519622
(Leider beim RP6 nicht so einfach umsetzbar)

Gruß

mic

Vielen Dank für die Antwort!

Mich würde nur erst einmal interessieren, ob überhaupt etwas aus der Kamera herauskommt. Die Verpackung sah schon benutzt aus, darum vermute ich, dass sie schon einmal verwendet wurde. Könntest du vielleicht die 2 Zeilen posten, die benötigt werden, um E_INT als Eingang zu nutzen, damit ich die Werte im Terminal anzeigen kann? Das würde mir erstmal bedeutend weiter helfen.

Hallo

Der E_INT kann beim RP6 als Interupteingang für I2C genutzt werden und ist in der Library schon integriert. Diese Funktion kann man ausschalten, dabei wird der E_INT zu einem normalen Eingang:

extIntOFF();

So mache ich es auch in meinem Setup:

Code:

void ADC_Init(void) { 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; // setze free running triggern SFIOR = (0<<ADTS2) | (0<<ADTS1) | (0<<ADTS0); // kein Interupt, Wandler einschalten, prescaler /2, ADC läuft nun mit 4MHz! 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 empfohlene Initiallesung while (!(ADCSRA & (1<<ADIF))); ADCSRA |= (1<<ADIF); }

(Aus https://www.roboternetz.de/community...l=1#post457514)

Nach dem Initialisieren und dem Init des ADC steht dann immer der aktuelle Wert im ADCH-Register:

Code:

initRobotBase(); ADC_Init(); while(1) { writeInteger(ADCH, 10); writeString_P("\n"); }

Gruß

mic

Etwas dergleichen habe ich bereits probiert. Nun habe ich noch einmal die beiden Codes von dir als Programm ausgeführt. Wie schon vorher werden ununterbrochen und scheinbar zufällig die Zahlen 1 und 3 ausgegeben. Dabei würde es sich ja um äußert niedrige Spannungen handeln. Interessanterweise ist es dabei egal, ob ich das Signalkabel der Kamera am E_INT angeschlossen habe oder nicht. Hast du eine Idee was ich falsch machen könnte?

Hallo

Möglicherweise ist doch die Kamera defekt. Richtigen E_INT-Pin verwendet? E_INT (INT1) ist über einen 10k-Widerstand (R34) mit GND verbunden, deshalb wird der Pin mit 0V gemessen, wenn nichts angschlossen ist. GND der Kamera ist mit GND vom RP6 verbunden? Was wird gemessen, wenn du eine 1,5V-Batterie zwischen GND und E_INT klemmst (bei 2,56V-Referenz bitte nicht mehr als 2,56V anschliessen!) Andere Signalquelle versuchen (TV, VCR, DVD, Playstation...).

Zitat:

Ein einfaches Programm ließt die ADC-Werte und schreibt sie in den Terminal (Light-Detection Beispielprogramm auf andere ADC-Kanäle abgeändert). Dabei erhalte ich Werte von 350...

Was wird gemessen wenn du den ADC= mit Vdd oder GND verbindest? Zeig mal bitte dein Programm.

Gruß

mic

Guten Abend,

verbinde ich eine Batterie mit + an E_INT und - an GND, so messe ich mit dem Programm Spannungen von 140, was ja völlig richtig ist. Daher dürfte das Programm auch korrekt laufen. Posten kann ich es zwar nicht, da der Laptop auf dem ich programmiere ab und zu nicht anzuschalten ist. Es handelt sich im großen und ganzen um das was du selbst gepostet hast.

Gruß

Tja, 140 bedeutet bei der linksbündigen Auswertung von ADCH ca. 1,4V, das liegt in plausiblen Bereich. Entweder ist die Kamera wirklich kaputt oder falsch angeschlossen oder die Spannungsversorgung mit dem Vorwiderstand (wie groß ist der denn?) funktioniert nicht wie erwartet.

Kannst du als Gegenprobe die Kamera an einem Bildschirm anschließen?

Als Vorwiderstand verwende ich 100 Ohm. Ich erhalte auch keine Spannungen, wenn ich mit einem Multimeter nachmesse. Ein Kabelbruch ist auszuschließen, da ich die 'Messsonde' auch direkt an die Lötstelle an der Platine halten kann und nichts passiert. Ich werde das gute Stück morgen einfach wieder abgeben, ist leider nicht das erste mal dass ich etwas defektes einkaufe.

Bei Conrad finde ich ansonsten nur eine CMOS-Kamera für 30€. Du meintest, dass selbst die andere sehr teuer sei. Welche würdest du stattdessen empfehlen?

Ansonsten dürfte morgen ein Arduino Leonardo eintreffen. Dieser könnte dann gegebenfalls mit seinen 16MHz die Kameraauswertung übernehmen und den RP6 entlasten.