Minimallösung: Kamera für den RP6

Hallo

Leider kann ich keine andere Kamera empfehlen. Teuer ist relativ. Wenn man die Möglichkeiten einer Kamera in Betracht zieht ist der Preis durchaus vertretbar, auch wenn es bisher noch wenige geschafft haben das Teil sinnvoll einzusetzen. Spannend wäre zu überprüfen ob deine Kamera wirklich defekt ist und ob es dann mit dem Ersatz funktioniert.

Die Belastung für den RP6 hält sich ja in Grenzen, die Engstelle ist der geringe Speicher (Ram) beim Mega32. Mit dem Arduino solltest du aber gleich bei der Variante mit dem analogen Komperator als Syncerkennung beginnen. Dazu gibt es allerdings noch keine Umsetzung in C oder als Sketch. Wenn du also eh beim C vorbeischaust kannst du dir gleich noch ein Poti zur Einstellung des Triggerlevels besorgen (10K?).

Gruß

mic

P.S.:
Das ist ja spannend. Auf dem Arduino Leonardo werkelt ein 16MHz ATMega32u4. Zufällig habe ich den hier leicht verstaubt rumliegen:
https://www.roboternetz.de/community...l=1#post539603

http://www.conrad.de/ce/de/product/1...7-x-597-Pixels

Würde dieses Gerät die Zwecke erfüllen? In Leipzig ist die Kamera zurzeit auch auf Lager. Mich schreckt nur die hohe Auflösung ab, die sicher sehr ressourcenfordernd ist.

Hallo

Die Auflösung der Kamera ist kein Problem, wir lesen ja wegen des geringen Speichers des Mega32 eh nur einzelne Pixel oder Zeilen ein. Aber 12V und 90mA erscheinen mir ungünstig, auch wenn die Kamera selbst vermutlich mit einer geringeren Spannung läuft.

Leider ist deine jetzige Kamera in deiner Finiale nicht verfügbar und erst im Mai wieder lieferbar. (In Stuttgart liegen wohl noch 4 Stück rum, vielleicht können sich die Finialen untereinander austauschen...).

Gut dazu passen würde auch dieser Spannungsregler:
http://www.conrad.de/ce/de/product/147109/

Bei minimaler Eingangsspannung von 4,75V liefert der sogar zwischen 2,45V und 2,75V bei bis zu 70mA. 0,33µF und 0,1µF-Kondensatoren nicht vergessen.

Eine Alternative wäre z.B. http://www.ebay.de/itm/mini-Farb-Spi...-/230916036819

Oder schau mal bei Pollin vorbei: http://www.pollin.de/shop/p/ODk2OTE5...k/Kameras.html

Ich hatte meine erste Kamera auch aus einer solchen "Überwachungskamera" ausgeschlachtet.

Gruß

mic

P.S.: Wenn man etwas sucht wird man durchaus findig: http://www.sander-electronic.de/gm00009.html

Nunja, ich habe mich aber blöde angestellt...

Kurz bevor ich zu Conrad aufbrechen wollte, habe ich dann doch noch einmal die Kamera ausgepackt. Diesmal habe ich sie einfach an eine 1.5V Batterie angeschlossen, und siehe da, ich messe Spannungen von 0,7-1,3 Volt, je nachdem, ob ich die Linse zuhalte oder nicht.

Wenn ich die Kamera mit Plus- und Minuspol einer Batterie verbinde, den Minuspol der Batterie mit GND am XBUS und das Signalkabel an E_INT, dann erhalte ich auch im Terminal vernünftige Werte. Regelt der RP6 die VDD-Spannung vielleicht, damit 5 Volt eingehalten werden? Schließe ich nämlich ein Voltmeter zwischen VDD und GND sowie 2 100 Ohm-Widerständen an, so steigt die Spannung bis 12 Volt an. Die Batteriespannung +UB klettert sogar bis 20 Volt hoch. Der vermutlich vorhandene Schutz in der Kamera würde dann ja die Stromversorgung unterbrechen um die Kamera vor Überspannung zu schützen. Damit kommt letzlich kein Signal am ADC an.

Da ich jetzt vernünftige Werte erhalte kann ich dann auch mit der Linienerkennung loslegen. Ein Glück dass ich das gute Stück vor der Reklamation noch einmal überprüft habe :D

Gruß

Guten Abend,

nun habe ich dein Programm, welches 254 Werte in den Terminal schreib, ausgeführt. Momentan ist noch kein Widerstand, der das Signal belastet, verbaut. (Ist dieser wirklich notwendig?) Dabei komme ich auf folgende Ergebnisse:

Code:

---

---------------------------
0: 48 48 48 48
1: 48 48 48 48
2: 48 48 48 48
3: 48 48 99 54
4: 48 48 99 54
5: 48 48 99 54
6: 48 48 99 54
7: 48 116 99 54
8: 118 116 124 120
9: 118 116 124 120
10: 118 116 124 120
11: 118 116 124 120
12: 126 126 127 128
13: 126 126 127 128
14: 126 126 127 128
15: 126 126 127 128
16: 128 128 128 129
17: 128 128 128 129
18: 128 128 128 129
19: 128 128 128 129
20: 128 129 128 129
21: 129 129 129 131
22: 129 129 129 131
23: 129 129 129 131
24: 129 129 129 131
25: 129 128 131 134
26: 129 128 131 134
27: 129 128 131 134
28: 129 128 131 134
29: 134 131 135 135
30: 134 131 135 135
31: 134 131 135 135
32: 134 131 135 135
33: 134 135 135 135
34: 135 135 135 135
35: 135 135 135 135
36: 135 135 135 135
37: 135 135 135 135
38: 135 135 135 135
39: 135 135 135 135
40: 135 135 135 135
41: 135 135 135 135
42: 135 135 135 135
43: 135 135 135 135
44: 135 135 135 135
45: 135 135 135 135
46: 135 134 135 135
47: 135 134 131 131
48: 135 134 131 131
49: 135 134 131 131
50: 135 134 131 131
51: 131 131 129 131
52: 131 131 129 131
53: 131 131 129 131
54: 131 131 129 131
55: 128 128 120 126
56: 128 128 120 126
57: 128 128 120 126
58: 128 128 120 126
59: 128 112 120 126
60: 113 112 112 112
61: 113 112 112 112
62: 113 112 112 112
63: 113 112 112 112
64: 112 112 110 110
65: 112 112 110 110
66: 112 112 110 110
67: 112 112 110 110
68: 108 110 104 103
69: 108 110 104 103
70: 108 110 104 103
71: 108 110 104 103
72: 108 103 104 103
73: 103 103 81 83
74: 103 103 81 83
75: 103 103 81 83
76: 103 103 81 83
77: 51 51 17 17
78: 51 51 17 17
79: 51 51 17 17
80: 51 51 17 17
81: 14 14 41 24
82: 14 14 41 24
83: 14 14 41 24
84: 14 14 41 24
85: 14 48 41 24
86: 48 48 48 48
87: 48 48 48 48
88: 48 48 48 48
89: 48 48 48 48
90: 48 48 118 118
91: 48 48 118 118
92: 48 48 118 118
93: 48 48 118 118
94: 118 120 126 124
95: 118 120 126 124
96: 118 120 126 124
97: 118 120 126 124
98: 118 126 126 124
99: 127 126 127 128
100: 127 126 127 128
101: 127 126 127 128
102: 127 126 127 128
103: 128 128 129 129
104: 128 128 129 129
105: 128 128 129 129
106: 128 128 129 129
107: 129 129 129 129
108: 129 129 129 129
109: 129 129 129 129
110: 129 129 129 129
111: 129 131 129 129
112: 131 131 132 135
113: 131 131 132 135
114: 131 131 132 135
115: 131 131 132 135
116: 135 135 135 135
117: 135 135 135 135
118: 135 135 135 135
119: 135 135 135 135
120: 135 135 135 135
121: 135 135 135 135
122: 135 135 135 135
123: 135 135 135 135
124: 135 135 135 135
125: 135 135 135 135
126: 135 135 135 135
127: 135 135 135 135
128: 135 135 135 135
129: 135 135 135 135
130: 135 135 135 135
131: 135 135 135 135
132: 135 135 135 135
133: 134 134 131 131
134: 134 134 131 131
135: 134 134 131 131
136: 134 134 131 131
137: 134 134 131 131
138: 131 134 128 129
139: 131 134 128 129
140: 131 134 128 129
141: 131 134 128 129
142: 128 128 113 115
143: 128 128 113 115
144: 128 128 113 115
145: 128 128 113 115
146: 112 112 112 112
147: 112 112 112 112
148: 112 112 112 112
149: 112 112 112 112
150: 112 112 112 112
151: 110 112 108 110
152: 110 112 108 110
153: 110 112 108 110
154: 110 112 108 110
155: 108 108 105 105
156: 108 108 105 105
157: 108 108 105 105
158: 108 108 105 105
159: 92 96 51 51
160: 92 96 51 51
161: 92 96 51 51
162: 92 96 51 51
163: 92 48 51 51
164: 38 48 14 14
165: 38 48 14 14
166: 38 48 14 14
167: 38 48 14 14
168: 9 12 48 48
169: 9 12 48 48
170: 9 12 48 48
171: 9 12 48 48
172: 48 48 48 48
173: 48 48 48 48
174: 48 48 48 48
175: 48 48 48 48
176: 48 48 48 48
177: 48 48 118 118
178: 48 48 118 118
179: 48 48 118 118
180: 48 48 118 118
181: 120 118 126 126
182: 120 118 126 126
183: 120 118 126 126
184: 120 118 126 126
185: 127 127 128 128
186: 127 127 128 128
187: 127 127 128 128
188: 127 127 128 128
189: 127 127 128 128
190: 128 127 129 129
191: 128 127 129 129
192: 128 127 129 129
193: 128 127 129 129
194: 129 129 131 131
195: 129 129 131 131
196: 129 129 131 131
197: 129 129 131 131
198: 131 131 135 135
199: 131 131 135 135
200: 131 131 135 135
201: 131 131 135 135
202: 131 135 135 135
203: 135 135 135 135
204: 135 135 135 135
205: 135 135 135 135
206: 135 135 135 135
207: 135 135 135 135
208: 135 135 135 135
209: 135 135 135 135
210: 135 135 135 135
211: 135 135 135 135
212: 135 135 135 135
213: 135 135 135 135
214: 135 135 135 135
215: 135 135 135 135
216: 134 135 135 135
217: 134 135 135 135
218: 134 135 135 135
219: 134 135 135 135
220: 134 134 131 131
221: 134 134 131 131
222: 134 134 131 131
223: 134 134 131 131
224: 129 129 128 128
225: 129 129 128 128
226: 129 129 128 128
227: 129 129 128 128
228: 129 127 128 128
229: 127 127 113 113
230: 127 127 113 113
231: 127 127 113 113
232: 127 127 113 113
233: 112 112 112 112
234: 112 112 112 112
235: 112 112 112 112
236: 112 112 112 112
237: 108 112 108 110
238: 108 112 108 110
239: 108 112 108 110
240: 108 112 108 110
241: 108 103 108 110
242: 105 103 96 96
243: 105 103 96 96
244: 105 103 96 96
245: 105 103 96 96
246: 88 88 49 49
247: 88 88 49 49
248: 88 88 49 49
249: 88 88 49 49
250: 22 24 14 12
251: 22 24 14 12
252: 22 24 14 12
253: 22 24 14 12
254: 22 7 14 12

---

Nun würde mich noch interessieren, wie ich zwischen dem Sync-Signal für eine neue Zeile und dem für ein neues Bild unterscheide. Da ich erst einmal nur Linien verfolgen möchte, habe ich die Kamera um 90° gedreht. Es würde somit ja ausreichen, nur den ersten Bildpunkt aus einer Zeile zu speichern. Somit müsste ich lediglich das neue Bild abwarten und immer nach dem Sync-Signal den nächsten ADC-Wert speichern sowie einen Zähler hochzählen, der mir verrät, in welcher Linie ich aktuell bin. Im Moment weiß ich aber noch nicht, ob ich bei den niedrigen ADC-Werten ein neues Bild oder eine neue Zeile erwarten soll.

Gruß

Hallo

Das sieht ja schon recht brauchbar aus. Der Widerstand sollte schon drin sein, weil sonst die Werte nicht stabil sind. Bei einem zu großen oder fehlendem Widerstand sind die Werte zu groß, deshalb stimmen deine Sync und Schwarzschulterwerte nicht.

Das Programm in der orginalen Version liest viermal die Daten ab dem Start der 150ten Zeile in einen 1KB großen Speicherbereich:

Code:

---

                for(c=0; c<4; c++) // viermal den selben Bereich einlesen
                {
                  bildzeiger=&bildspeicher[256*c]; // Zeiger auf Start des Bildspeicherbereich
                  cli();
                        do // Warten auf langen Syncbereich = Bildstart
                        {
                                sync=0;
                                while (ADCH > 20); // warten solange Bilddaten erkannt werden
                                while (ADCH < 30) sync++; // Länge des Sync-Signal zählen
                        }while (sync < 40); // größer 40 bedeutet Bildstart
               
                        zeile=150; // durchhangeln bis Zeile 150
                        while(zeile--)
                        {
                                while (ADCH > 20); // Bilddaten
                                while (ADCH < 30); // Sync
                        }
               
                        spalte=255; // oje
                        do *bildzeiger++=ADCH; while(spalte--); // 254 Werte einlesen
                        //while(spalte--) *bildzeiger++=ADCH; // dito
                        //do *bildzeiger=ADCH; while(*bildzeiger++ > 20); // schneller ;)
                        sei();
                }

---

Werte kleiner 30 werden als Sync gedeutet, Werte größer als 20 als Bilddaten. Wenn 40 mal (oder öfter) hintereinander ein Sync erkannt wurde sollte das der Bildstart sein. Ab hier werden dann 150 Bilddaten/Sync gezählt und schließlich 254 Werte hintereinander eingelesen und gespeichert.

Der Syncbereich beim Bildstart ist deutlich länger als der zwischen den einzelnen Zeilen, deshalb kann man daran den Bildstart erkennen. Die Halbbilder kann man so aber nicht unterscheiden. Brauchbare Zeilendaten kommen erst ab ca. der 10. Zeile. Wenn du mehrfach ohne irgendwelche Startbedingungen die Werte als Block einliest wirst du irgendwann auch den Bildwechseln erwischen...

Gruß

mic

Noch eine kleine Analyse deiner Daten:

0-7 ist noch der Rest des Syncs der 150ten Bildzeile, genauer eine Schwarzschulter die ca. 0,3V sein sollte (fehlender Widerstand).
8-76 Bilddaten der 150. Bildzeile
77-93 Schwarzschultern
81-85 Sync
94-158 Bilddaten der 151ten Bildzeile
159-180 Schwarzschulter
168-171 Sync
181-241 Bilddaten Zeile 152
usw.


Bei den Bilddaten sind einige Werte doppelt, weil diese Programmversion die Daten aus dem ADCH schneller rauskopiert als der ADC neue Daten bereitstellt. (bisher habe ich noch nicht gefunden, wie man mit dem ADC weniger als 10 Bits sampelt).

Eine weiße Fläche sollte Werte bei ca. 120 liefern (automatischer Weisabgleich?) und eine schwarze Fläche (oder Objektiv zugehalten) Werte von ca. 35.

Die Kamera würde ich zum Linienfolgen nicht drehen, denn wenn du nur eine Bildzeile einliest wird eine senkrechte Linie in den Bilddaten der eingelesenen Zeile erscheinen. Einlesezeit wäre dann Warten_auf_Bildstart+Warten_auf_Zeile+Einlesen der Zeile. Warten auf Bildstart dauert maximal ein Halbbild, Warten auf Zielzeile mit Einlesen nur einen Bruchteil des Halbbildes, wenn du eine obere Zeile verwendest. Die Werte einer Zeile machen dann einen deutlichen Sprung, wenn die Linie getroffen wird. Wenn du oben, mitte und unten jeweils eine Zeile einliest kannst du beurteilen, ob die Linie quer durchs Bild läuft.

Bei gedrehter Kamera mußt du immer alle Zeilen abwarten und erkennen, wann die Schwarzschulter endet und die Bilddaten beginnen.

Vielen Dank für die umfangreiche Antwort!

Noch einmal eine Verständnissfrage: Eine Zeile verläuft horizontal durch das Bild. Würde ich jetzt eine Linie suchen, so müsste ich auf mindestens einer Zeile mehrere Pixel abfragen, um die Stelle zu finden, an der der Schwellwert über-/unterschritten wird. Drehe ich die Kamera hingegen auf die Seite, so reicht es, nur den Anfang jeder neuen Zeile einzulesen und dann auf das Sync-Signal zur nächsten Zeile zu warten, um dort wieder den ersten Bildpunkt abzufragen. Dadurch hat der ADC wesentlich mehr Zeit, da ich pro Zeile nur eine Spalte abfrage. Du meintest, dass ich nur eine Bildzeile pro Bild einlesen will. Habe ich da etwas falsch verstanden..?

Hallo

Zitat:

---

Vielen Dank für die umfangreiche Antwort!

---

Bitte, immer gerne.

Die Kamera ist ja mein Liebling aus einer Zeit als ich noch Einsteiger in Sachen C, AVR und Kamera war. Vieles aus der Anfangszeit war falsch oder umständlich und ist nach und nach gewachsen.

Der erste Ansatz war soviele Werte so schnell wie möglich einzulesen. Das ist die Variante die du im Moment verwendest. Dabei wurde nicht beachtet, dass der ADC mit der Wandlung eines neuen Wertes noch nicht fertig war und deshalb einige Werte doppelt eingelesen wurden. Der aktuelle Stand ist, dass man beim Einlesen auf die Meldungen des ADC wartet und den Wert erst einliest, wenn die Wandlung beendet wurde. Dadurch wird alles sehr entspannt und es funktioniert sogar ohne dass man beim Einlesen die Interrupts sperren muss.

Der ADC (mit Takt-Prescaler /2) braucht im Dauerlauf (Freerunning) 13 ADC-Takte zur Wandlung eines Wertes, das Programm muss deshalb innerhalb von 26 Kontrollertakten das Flag des ADC prüfen und bei fertiger Wandlung den Wert aus dem ADCH-Register verarbeiten. Das reicht locker um ein Sync zu erkennen oder Bilddaten abzuspeichern. Bei 8MHz-Takt des AVR dauert eine Wandlung 1/4 MHz*13 Takte = 0,00000325 Sekunden bzw. 3,25µs. Wenn ein Zeilensync ca. 4,7µs dauert sollten wir diesen zweimal hintereinander erkennen:

Bild hier  
(Bild aus http://de.wikipedia.org/wiki/Fernseh...ynchronisation)

Und wie groß ist nun die Auflösung? Deine Kamera hat eine Auflösung von 352H x 288V, kann also 288 Zeilen mit je 352 unterschiedlichen Helligkeitswerten ausgeben. Da wir sicher zwischen Sync und Bilddaten unterscheiden können, und den Zeilenstart deshalb genau erkennen können, ist es möglich gezielt auf jede einzelne Zeile zuzugreifen. Damit ist die mögliche vertikale (von oben nach unten) Auflösung so gut wie die der Kamera selbst. Innerhalb einer Zeile können wir die Werte nur in einem festen Abstand (3,25µs) zueinander einlesen. Deshalb sind mit dieser Technik nur ca. 52µs/3,25µs=16 Pixel Auflösung möglich (In der Praxis etwas weniger). Mit einem kleinen Trick läßt sich das aber steigern: Wenn am Zeilenende der Sync (bzw. die Schwarzschulter) erkannt wird, wird der ADC gestoppt und wieder neu gestartet. Es dauert dann zwar wieder 26 ADC-Takte bis der nächste gültige Wert gewandelt wird, aber das ist immer noch im Sync-Bereich und noch vor den Bilddaten. Die nächsten Werte werden dann wieder im Dauerlauf mit 3,25µs Abstand gewandelt. Und nun der Trick: Vor dem erneuten Starten ADC wird kurz gewartet und so ein kleiner Versatz zwischen den eingelesenen Pixeln erzeugt. So wird die maximale horizontale Auflösung durch die kleinste mögliche Verzögerungszeit bzw. den Takt des AVR begrenzt. Ein Beispiel mit einer Verzögerung von zwei Takten (nop's):

Grundlagen zur Auflösung:
https://www.roboternetz.de/community...l=1#post457599
https://www.roboternetz.de/community...l=1#post457945
ADC-Flag beachten:
https://www.roboternetz.de/community...l=1#post458253
Analoger Komperator:
https://www.roboternetz.de/community...l=1#post520992

Aber ich schweife ab...

Wieviel Auflösung braucht man zum Linienfolgen? Zum sicheren Erkennen müssen mindestens zwei gemessene Punkte auf der Linie liegen (Nyquist-Shannon-Abtasttheorem?). Deshalb ist die benötigte Auflösung von der Linienbreite und dem Bildausschnitt bzw. dem Abstand der Kamera von der Linie abhängig. Hier muss man das Optimum aus Auflösung, Abtastrate, Datenmenge und Reglergeschwindigkeit finden...

Danke fürs Lesen. Das Thema Speicherplatz und Farbtiefe möchte ich euch hier ersparen...

Gruß

mic

Hallo,

das mit der höheren Bilddichte durch abwechselnd verschiedene Verzögerungen mit dem Beginn des ADC-Auslesens an einer neuen Zeile habe ich soweit verstanden. Aber dennoch reicht es zum simplen Linienfolgen doch aus, nur einen Punkt auf einer Linie zu erkennen. Ich habe es mal dargestellt, da ich es anscheinend nicht so gut beschreiben konnte:

Anhang 24450

Dabei würde der Microcontroller kaum belastet werden. Man liest einfach den Wert nach jedem Sync-Impuls aus bzw. erst mit einem gewissen zeitlichen Abstand. Der dunkelste der pro Frame gefundenen Punkte wird sicherlich die schwarze Linie sein.

@radbruch
Bedeutet Auflösung von 352H x 288V nicht 352 Pixel pro Zeile (Horizontal) und 288 Zeilen (Vertikal), das wären ca. 100k Pixel?


MfG Hannes