Minimallösung: Kamera für den RP6

Habe mir das jetzt auch mal zusammen geschustert...

mit dem smily wills noch nicht so recht klappen...

auch giebt es problemem mit dem licht, da meine cammera recht viel davon braucht scheinbar ... oder ich müsste die empfindlichkeit irgendwie verändern

gruss

Hallo

Beim Smily-Programm (erste Seite des Threads) wird hier die Helligkeit des Punktes überprüft und entsprechend ein Stern oder ein Leerzeichen geschrieben:

Zitat:

---

if (bildspeicher[j+32*i] >90) writeString_P("*");
else writeString_P(" ");

---

Alle Werte über 90 sind Sternchen. Mit <90 würde die Ausgabe übrigens invertiert werden.

Meine Kamera hat, wie auch die oben gezeigte 15€-Kamera, einen Gain-Eingang mit dem man die Verstärkung (=Lichtempfindlichkeit?) der Kameras einstellen kann. Bei meinen Versuchen war Gain unbeschaltet, das bedeutet Gain-Aus, eine Brücke zu GND schaltet Gain ein?

Als Videoquelle kann man auch andere Geräte mit Videoausgang verwenden, z.B. Digicam oder Fotohandy.

Gruß

mic

bei meiner Kammera (alt funkkammera) sind 2 ausgänge GND & Signal
das Gain macht sie automatisch (die sitzt auf nem chip).

Versuch:
Mache ich licht im dunklen Zimmer aus und nehme die Taschenlampe um zu sehen ob es überblendet => klar = überblendet reguliert sich jedoch automatisch und ich habe wieder Sicht.

gruss

Hmm die Smily Version gibt mir folgenden error gruss

Code:

---

Compiling: RP6Base_Cam.c
avr-gcc -c -mmcu=atmega32 -I. -gdwarf-2  -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=RP6Base_Cam.lst -I../../RP6Lib -I../../RP6Lib/RP6base -I../../RP6Lib/RP6common -std=gnu99 -MD -MP -MF .dep/RP6Base_Cam.o.d RP6Base_Cam.c -o RP6Base_Cam.o
RP6Base_Cam.c: In function ‘main’:
RP6Base_Cam.c:91: error: expected declaration or statement at end of input
make: *** [RP6Base_Cam.o] Fehler 1

---

Sorry das compilieren geht ... nun aber ein anderes Problem.

Der RP6 dreht seine linke Kette in regelmäßigen abständen, jedoch immer stärker und schneller- am Terminal gibt er folgendes aus.

Code:

---

                                0

                                1

                                2..31 0 1 2 ...31

---

Ähm, nun wäre ein günstiger Zeitpunkt um uns dein Programm zu zeigen ;)

lustiger weise ist es dein programm. Ich meine das von dem du hier sprichst:

"Beim Smily-Programm (erste Seite des Threads) wird hier die Helligkeit des Punktes überprüft und entsprechend ein Stern oder ein Leerzeichen geschrieben:"

Hallo,

kann es sein, dass wir aneinander vorbeireden?

Zitat:

---

...nun aber ein anderes Problem.

Der RP6 dreht seine linke Kette in regelmäßigen abständen, jedoch immer stärker und schneller- am Terminal gibt er folgendes aus.

---

Und hier das (mein) Smiliy-Programm von der ersten Seite des Threads:

Code:

---

#include "RP6RobotBaseLib.h"

uint8_t bildspeicher[1024], *bildzeiger; // 32*32=1KB * 8Bit Bildspeicher bereitstellen

void bild_einlesen(void)
{
  uint8_t pixel[32],*pixelzeiger;
  uint8_t i, zeilen, step, lines, rows, h_step, h_sync, h_delay;

  zeilen=32; // Das fertige Bild soll 32 Zeilen haben
  step=7; // sichtbares TV-Bild ist ca. 30-260=230/32 ergibt Zeilensprung=7
  rows=0; // Anzahl der Spalten (32x32, rechengünstig,aber verzerrt)

  do
  {
      lines=zeilen; // Anzahl der einzulesenden Zeilen
      pixelzeiger=&pixel[0]; // Zeiger auf Start Pixelspeicher
      cli();
      // h_sync abwarten (syncsignal länger 40 bedeutet Seitenanfang)
      do { h_sync=0; while (ADCH > 20); while (ADCH < 30) h_sync++; } while (h_sync < 40);

      // 30-35 Zeilen Austastzeit überlesen (der Rest des hsyncs+nicht darstellbare BTX-Infos)
      h_step=35; while (h_step) { while (ADCH > 20); while (ADCH < 30); h_step--; }
 
      // Der Lesecursor befindet sich jetzt oben links im TV-Bild
      // ab hier werden in step-Sprüngen in allen Zeilen jeweils das Pixel eingelesen,
      // das sich im zeitlichen h_delay-Abstand vom linken TV-Bildrand befinden
      // (= eine TV-Bildspalte)

      while (lines--)
      {
        // auf die nächste gültige Zeile warten
        h_step=step; while (h_step) { while (ADCH > 20); while (ADCH < 30); h_step--; }

        // mit h_delay steuern wir nun den Pixel an
        // Nach dem sync fängt das Bild etwas verzögert an (schwarzschulter), bei mir 20
        // bei ca. 150 beginnt die 2.Schwarzschulter. Bei 150-20 möglichen Bildpunkten
        // ergibt sich eine maximale Auflösung von 128 horizontal. Zusammen mit der
        // vertikalen Auflösung von 230 kämen wir dann bei einem 8MHz-ATMega auf stolze
        // 128*230 Bildpunkte.
        h_delay=20+4*rows; while (h_delay--);

        *pixelzeiger=ADCH; // letzten ADC-Wert auslesen und wegwerfen
        *pixelzeiger++=ADCH;  // aktuellsten ADC-Werte speichern
      }
      sei();
     
      pixelzeiger=&pixel[0];
      bildzeiger=&bildspeicher[32*rows];
      for (i=0; i<32; i++) *bildzeiger++ = *pixelzeiger++;
     
  }while (rows++ <zeilen);
}

int main(void)
{
  uint16_t i, j;

  initRobotBase();
  extIntOFF(); // schaltet den E_INT1-Port auf Eingang für den ADC
  //powerON();
// 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);

  while(1)
  {
      bild_einlesen();

      for (i=0; i<32; i++)
      {
        for (j=0; j<32; j++)
        {
            if (bildspeicher[j+32*i] >90) writeString_P("*");
              else writeString_P(" ");
        }
        writeInteger(i,DEC);
        writeString_P("\n\r");
      }
  mSleep(200);
}

  return(0);
}

---

Keinerlei Befehle zur Ansteuerung der Motoren. Irgendwie passt das nicht, oder?

Wenn ich das richtig deute bekommst du nur Leerzeichen gesendet. Das bedeutet, die Schwelle von 90 wird nie überschritten. Spiele etwas mit den Werten. Mit diesem Programm werden 256 Bytes ab Zeile 100 eingelesen und zum Terminale gesendet. Kleine Werte sind Sync-Inpulse, große Werte sind hell:

Code:

---

// Liest ab der 100. Zeile 256 Werte am Stück ein
// und sendet die Daten als Tabellenvorlage zum PC.

#include "RP6RobotBaseLib.h"

int main(void)
{
uint8_t pixel[256],*pixelzeiger, *endezeiger;
uint8_t vsync, lines;

  initRobotBase();
  extIntOFF();
  //powerON();
// interne Referenz 2,56V, linksbündig, Kanal ADC4
  ADMUX = (1<<REFS1) | (1<<REFS0)  | (1<<ADLAR) | 4;
// free running triggern
  SFIOR = (0<<ADTS2) | (0<<ADTS1) | (0<<ADTS0);
// kein interupt, einschalten, prescaller /2
  ADCSRA = (0<<ADIE) | (1<<ADEN) | (0<<ADPS2) | (0<<ADPS1)  | (1<<ADPS0);
// free running aktivieren, altes Flag löschen
  ADCSRA |= (1<<ADATE) | (1<<ADIF);
// Initialisierung starten
  ADCSRA |= (1<<ADSC);

  while (!(ADCSRA & (1<<ADIF)));
  ADCSRA |= (1<<ADIF);

  pixelzeiger=&pixel[0];
  endezeiger=&pixel[255];
  lines=100;
  cli();

  do // vsync abwarten
  {
      vsync=0;
      while (ADCH > 20);
      while (ADCH < 30) vsync++;
  }while (vsync < 40);
 
  while (lines) // zeile abwarten
  {
      while (ADCH > 20);
      while (ADCH < 30);
      lines--;
  }

// 256 Werte am Stück einlesen und als Basis für ein Diagramm senden
  do *pixelzeiger=ADCH; while (pixelzeiger++ < endezeiger);
  sei();

  writeString("------------------------\n\r");
    lines=0;
    do
  {
      writeInteger(lines, DEC);
      writeString_P("; ");
      writeInteger(pixel[lines], DEC);
      writeString_P("; ");
      writeString("\n\r");
  }while (++lines);

  while (1); // ;)
  return(0);
}

---

Gruß

mic

Okay so verrückt es klingen mag ... ich mache
$make all
nach dem speichern des .hex
dreht sich der motor.
Wie beschrieben spuckt auch das terminal nur zahlen von 1 bis 31 aus.
gruss carlitoco

Also um nochmal meine problematik zu schildern:
dieser Code:

Code:

---

#include "RP6RobotBaseLib.h"

uint8_t bildspeicher[1024], *bildzeiger; // 32*32=1KB * 8Bit Bildspeicher bereitstellen

void bild_einlesen(void)
{
  uint8_t pixel[32],*pixelzeiger;
  uint8_t i, zeilen, step, lines, rows, h_step, h_sync, h_delay;

  zeilen=32; // Das fertige Bild soll 32 Zeilen haben
  step=7; // sichtbares TV-Bild ist ca. 30-260=230/32 ergibt Zeilensprung=7
  rows=0; // Anzahl der Spalten (32x32, rechengünstig,aber verzerrt)

  do
  {
      lines=zeilen; // Anzahl der einzulesenden Zeilen
      pixelzeiger=&pixel[0]; // Zeiger auf Start Pixelspeicher
      cli();
      // h_sync abwarten (syncsignal länger 40 bedeutet Seitenanfang)
      do { h_sync=0; while (ADCH > 20); while (ADCH < 30) h_sync++; } while (h_sync < 40);

      // 30-35 Zeilen Austastzeit überlesen (der Rest des hsyncs+nicht darstellbare BTX-Infos)
      h_step=35; while (h_step) { while (ADCH > 20); while (ADCH < 30); h_step--; }
 
      // Der Lesecursor befindet sich jetzt oben links im TV-Bild
      // ab hier werden in step-Sprüngen in allen Zeilen jeweils das Pixel eingelesen,
      // das sich im zeitlichen h_delay-Abstand vom linken TV-Bildrand befinden
      // (= eine TV-Bildspalte)

      while (lines--)
      {
        // auf die nächste gültige Zeile warten
        h_step=step; while (h_step) { while (ADCH > 20); while (ADCH < 30); h_step--; }

        // mit h_delay steuern wir nun den Pixel an
        // Nach dem sync fängt das Bild etwas verzögert an (schwarzschulter), bei mir 20
        // bei ca. 150 beginnt die 2.Schwarzschulter. Bei 150-20 möglichen Bildpunkten
        // ergibt sich eine maximale Auflösung von 128 horizontal. Zusammen mit der
        // vertikalen Auflösung von 230 kämen wir dann bei einem 8MHz-ATMega auf stolze
        // 128*230 Bildpunkte.
        h_delay=20+4*rows; while (h_delay--);

        *pixelzeiger=ADCH; // letzten ADC-Wert auslesen und wegwerfen
        *pixelzeiger++=ADCH;  // aktuellsten ADC-Werte speichern
      }
      sei();
     
      pixelzeiger=&pixel[0];
      bildzeiger=&bildspeicher[32*rows];
      for (i=0; i<32; i++) *bildzeiger++ = *pixelzeiger++;
     
  }while (rows++ <zeilen);
}

int main(void)
{
  uint16_t i, j;

  initRobotBase();
  extIntOFF(); // schaltet den E_INT1-Port auf Eingang für den ADC
  //powerON();
// 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);

  while(1)
  {
      bild_einlesen();

      for (i=0; i<32; i++)
      {
        for (j=0; j<32; j++)
        {
            if (bildspeicher[j+32*i] >90) writeString_P("*");
              else writeString_P(" ");
        }
        writeInteger(i,DEC);
        writeString_P("\n\r");
      }
  mSleep(200);
}}

---

Verursacht, dass der RP6 folgendes am Terminal ausgiebt:

Code:

---

[READY]
                                0

                                1

                                2

                                3

                                4

                                5

                                6

                                7

                                8

                                9

                                10

                                11

                                12

                                13

                                14

                                15

                                16

                                17

                                18

                                19

                                20

                                21

                                22

                                23

                                24

                                25

                                26

                                27

                                28

                                29

                                30

                                31

---

und sich die linke Kette dreht in pulsierenden immer intensieveren stößen.

Es ist mir schleierhaft wie das zustande kommt... Oder wird ein anderer pin als INT1 (pin8 XBUS) für den anschluss des Signals der Cam verwendet ?

gruss carlitoco