-         

Ergebnis 1 bis 2 von 2

Thema: RP6Control M32: Helligkeits Sensor

  1. #1
    Erfahrener Benutzer Begeisterter Techniker Avatar von RobbyMartin
    Registriert seit
    31.12.2009
    Ort
    Leverkusen
    Alter
    24
    Beiträge
    206

    RP6Control M32: Helligkeits Sensor

    Anzeige

    SMARTPHONES & TABLETS-bis zu 77% RABATT-Kostenlose Lieferung-Aktuell | Cool | Unentbehrlich
    Hey Kamera Mitexperimentierer,

    für die Experimentierplatine, die wir hier beschrieben haben:
    http://www.roboternetz.de/phpBB2/zei...ag.php?t=53424
    ... und die hier:
    http://www.rn-wissen.de/index.php/RP...itmach-Projekt

    auch ich bin mal zwischen dem ganzen Schulstress dazugekommen etwas zu programmieren.

    Zwar ist es nichts besonderes da ich nur die Terminalausgabe von Dirk auf die LEDs weitergeleitet habe.

    Das Auge nimmt das starke flimmern nicht mehr war und es wird als Balkenanzeige wahrgenommen. Ich weiß das dies nichts Anspruchsvolles war doch ich will auch zeigen das ich an dem Projekt interessiert bin

    Code:
    /* 
     * **************************************************************************** 
     * RP6 ROBOT SYSTEM - RP6 CONTROL M32 TESTS 
     * **************************************************************************** 
     * Beispiel: Dieses Progra
     * Author(s): radbruch, Dirk : modifiziert von Martin zur einfache Helligkeitsanzeige
     * **************************************************************************** 
     * Description: 
     * 
     * With this program (written by radbruch for the RP6Base) the picture of a 
     * CMOS camera (CONRAD 150001) can be displayed on the terminal. 
     * The camera is connected to this hardware project: 
     *   http://www.rn-wissen.de/index.php/RP...itmach-Projekt 
     * The BAS video information (PG3) is connected to ADC4 (ADC plug, pin 3). 
     * The synchronization signals are connected as follows: 
     * 
     *   Signal      RP6 Name   Port   Function 
     *   VSync      EINT2      PD3      INT1 
     *   HSync      IO_PD6      PD6      ICP1 
     *   Odd/Even   EINT3      PB2      INT2 
     * 
     * ############################################################################ 
     * The Robot does NOT move in this example! You can simply put it on a table 
     * next to your PC and you should connect it to the PC via the USB Interface! 
     * ############################################################################ 
     * **************************************************************************** 
     */ 
    
    /*****************************************************************************/ 
    // Includes: 
    
    #include "RP6ControlLib.h"       // The RP6 Control Library. 
                            // Always needs to be included! 
    
    /*****************************************************************************/ 
    // Defines: 
    
    #define HSYNC      (PIND & IO_PD6) 
    #define VSYNC      (PIND & EINT2) 
    #define ODD_EVEN   (PINB & EINT3) 
    #define IRon()      (PORTC &= ~IO_PC6) 
    #define IRoff()      (PORTC |= IO_PC6) 
    
    /*****************************************************************************/ 
    // Variables: 
    
    uint8_t bildspeicher[1024], *bildzeiger; // 32*32=1KB * 8Bit Bildspeicher 
    
    /*****************************************************************************/ 
    // Functions: 
    
    void bild_einlesen(void) 
    { 
       uint8_t pixel[32],*pixelzeiger; 
       uint8_t i, zeilen, step, lines, rows, h_step, 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(); 
          // VSync abwarten (Seitenanfang) 
          while(VSYNC); 
          // 40 Zeilen Austastzeit & ein Stück oberen Bildrand überlesen 
          h_step=40; while (h_step) { while (HSYNC); while (!HSYNC); 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 (HSYNC); while (!HSYNC); h_step--; } 
          // mit h_delay steuern wir nun den Pixel an 
          // Nach dem HSync fängt das Bild etwas verzögert an (Schwarzschulter), 
          // der Zeitpunkt des Auslesens des ADC verteilt sich bei 32 Punkten pro 
          // Zeile optimal auf den Zeileninhalt mit "h_delay=30+6*rows;". Bei der 
          // Überprüfung mit Testbild ist ein Offset von 20 aber besser geeignet. 
             h_delay=20+6*rows; while (h_delay--) {nop();}; 
    
             *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); 
    } 
    
    /*****************************************************************************/ 
    // Main function - The program starts here: 
    
    int main(void) 
    { 
       initRP6Control();   // Always call this first! The Processor will not 
                      // work correctly otherwise. 
    
       initLCD();         // Initialize the LC-Display (LCD) 
                      // Always call this before using the LCD! 
    
       // Write some text messages to the LCD: 
       showScreenLCD("################", "################"); 
       mSleep(1500); 
       showScreenLCD("<<RP6  Control>>", "<<LC - DISPLAY>>"); 
       mSleep(2500); 
       showScreenLCD("Helligkeit Sen.", "  Version 1.00  "); 
    
       // Clear the four Status LEDs: 
       setLEDs(0b0000); 
        
       // Initialize the M32 ICP pin (PD6) as input: 
       DDRD &= ~IO_PD6;               // ==> HSync 
       PORTD |= IO_PD6;               // Pullup on 
       // Initialize the M32 INT1 pin (PD3) as input: 
       DDRD &= ~EINT2;                  // ==> VSync 
       PORTD |= EINT2;                  // Pullup on 
       // Initialize the M32 INT2 pin (PB2) as input: 
       DDRB &= ~EINT3;                  // ==> Odd/Even 
       PORTB |= EINT3;                  // Pullup on 
       // Initialize the M32 TOSC1 pin (PC6) as output: 
       DDRC |= IO_PC6;                  // ==> IR 
       IRoff();                     // IR LEDs off 
    
       uint16_t i, j; uint8_t video; 
    // ADC interne Referenz 2,56V, Ergebniss linksbündig, Kanal ADC4 
       ADMUX = (1<<REFS1) | (1<<REFS0)  | (1<<ADLAR) | 4; 
    // setzte free running triggern 
       SFIOR = (0<<ADTS2) | (0<<ADTS1) | (0<<ADTS0); 
    // kein interupt, Wandler einschalten, prescaler /4 
       ADCSRA = (0<<ADIE) | (1<<ADEN) | (0<<ADPS2) | (1<<ADPS1)  | (0<<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(true) 
       { 
          bild_einlesen(); 
    
          for (i=0; i<32; i++) 
          { 
             for (j=0; j<32; j++) 
             { 
                video = bildspeicher[j+32*i]; 
                if (video < 30) ;
    			if ((video >= 30) && (video < 40)) setLEDs(0b0000);
                if ((video >= 40) && (video < 50)) setLEDs(0b0001); 
                if ((video >= 50) && (video < 60)) setLEDs(0b0011); 
                if ((video >= 60) && (video < 70)) setLEDs(0b0111);  
                if (video >= 70) setLEDs(0b1111); 
    //            if (bildspeicher[j+32*i] > 55) writeString_P("*"); 
    //            else writeString_P(" "); 
             } 
             writeInteger(i,DEC); 
             writeString_P("\n\r"); 
          } 
          mSleep(200); 
       } 
       return 0; 
    } 
    
    /****************************************************************************** 
     * Additional info 
     * **************************************************************************** 
     * Changelog: 
     * - v. 1.0 (initial release) 10.05.2010 by Martin
     * 
     * **************************************************************************** 
     */ 
    
    /*****************************************************************************/
    Lg
    Martin

  2. #2
    Erfahrener Benutzer Robotik Einstein Avatar von Dirk
    Registriert seit
    30.04.2004
    Ort
    NRW
    Beiträge
    3.791
    Hi Martin,

    tolle Variante, muss ich gleich ausprobieren!

    Gruß Dirk

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •