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