IR-bake

**inka** · 19.12.2013, 17:44

hallo,

inzwischen bin ich durch die verkleinerung des basiswiderstandes R13 von 4,7k auf 3,2k auf einer reichweite der bake von 3 metern angekommen, wohlgemerkt bei (noch) auf niedrigerer temperatur arbeitendem Q2, nach ca. 1 minute wird es schlechter...

jetzt möchte ich außer der reaktion auf dem LCD eine andere reaktion sehen und es klappt nicht:

mit dem aufruf dieser Funktion aus der while schleife (siehe weiter unten):

Code:

void read_IR_value(void)
{

    I2CTWI_transmitByte(I2C_RP6_BASE_ADR, 30); // Start with register 30
    I2CTWI_readBytes(I2C_RP6_BASE_ADR, ir_value, 1);

}

while-schleife:

Code:

    while(true)
    {

    read_IR_value();

    clearLCD();

    setCursorPosLCD(0, 0);
    writeStringLCD_P("dez: ");
    setCursorPosLCD(0, 13);
    writeIntegerLengthLCD(ir_value[0], DEC, 4);

    setCursorPosLCD(1, 0);
    writeStringLCD_P("bin: ");
    setCursorPosLCD(1, 8);
    writeIntegerLengthLCD(ir_value[0], BIN, 8);

    setCursorPosLCD(2, 0);
    writeStringLCD_P("hex: ");
    setCursorPosLCD(2, 8);
    writeIntegerLengthLCD(ir_value[0], HEX, 4);

/*
    if (ir_value[0] = 0)
        {
        sound(180,80,25);
        setLEDs(0b1000);
        sound(220,80,25);
        mSleep(500);
        }
*/
    readAllRegisters();


    }
    return 0;

werden die werte der variablen "ir_value", also 0 oder 4 je nachdem ob bake "gesehen" wird oder nicht auf dem LCD ausgegeben.

die if abfrage (hier auskommentiert) der variablen "ir_value" habe ich (bei abgeschalteter bake) mit den werten 1 bis 4 probeweise ausgeführt, die reaktion erfolgt richtig, es piepst. Frage ich nach dem wert "0", passiert nichts, auch bei eingeschalteter bake und auf dem display erscheinendem wert "0"

ich verstehe es einfach nicht. Frage ich die falsche variable ab? Oder nach falschen werten? Oder sind die abfrageabstände zu kurz? kann der beeper nicht so schnell reagieren?

**Dirk** · 19.12.2013, 19:27

Hi inka,

3 Sachen:
1. Die Abfrage if (ir_value[0] = 0) ergibt nie das gewünschte Ergebnis, aber if (ir_value[0] == 0) würde helfen.
2. Die Abfragefrequenz sollte man auch reduzieren, z.B. mit einer Stopwatch. 250 bis 500ms sind sicher ausreichend. Immerhin muss auch noch die I2C-Kommunikation zwischen RP6 und M32 erfolgen: Das braucht Zeit.
3. ir_value[0] ist ein Feld-Variable. Wo wird die gefüllt?

**inka** · 20.12.2013, 12:17

hi Dirk,

zumindest der punkt 1 hätte mir auffallen müssen...- jetzt reagiert die abfrage auf das empfangen des IR-signals...

die verzögerung habe ich mit "mSleep(500)" gemacht , das ist wohl blockierend - wenn ich es richtig in erinnerung habe - stört das hier?

Zitat von Dirk

3. ir_value[0] ist ein Feld-Variable. Wo wird die gefüllt?

oh, ich dachte das passiert hier

Code:

void read_IR_value(void)
{ 
I2CTWI_transmitByte(I2C_RP6_BASE_ADR, 30); // Start with register 30
I2CTWI_readBytes(I2C_RP6_BASE_ADR, ir_value, 1);
}

ist das nicht so?

ansonsten ist sie in der programmdatei so:

Code:

uint8_t ir_value[1];

deklariert...

**Dirk** · 20.12.2013, 16:37

Hi,

mSleep() ist leider blockierend.
Besser sind die Stopwatches, siehe Anleitung des RP6, 4.6.3. Delay Funktionen (...), Überschrift "Stopwatches". Da ist auch ein Beispiel mit 2 Stopwatches.

Die Feldvariable, die als uint8_t ir_value[1] deklariert ist, enthält letztlich nur EINE Variable, die heißt ir_value[0].
So muss man sie auch ansprechen.
Die beiden Variablen ir_value und ir_value[0] sind nicht identisch.

**inka** · 21.12.2013, 18:02

Hi Dirk,

Zitat von Dirk

Die Feldvariable, die als uint8_t ir_value[1] deklariert ist, enthält letztlich nur EINE Variable, die heißt ir_value[0].
So muss man sie auch ansprechen.
Die beiden Variablen ir_value und ir_value[0] sind nicht identisch.

das muss ich erstmal verarbeiten (und verstehen)...

in meinem programm (die basis war das "Example_06_I2CMaster") ist z.b:

Code:

// Read all registers function 
 
uint8_t RP6data[32]; // This array will contain all register values of RP6  
                     // after you called readAllRegisters() 
                      
                     // It is better to keep such big arrays GLOBAL as  
                     // they otherwise fill up the stack in memory... 
 
/** 
 * This function reads ALL registers available in the standard I2C Bus Slave 
 * Example program for the Robot Base and outputs their values on the serial interface.  
 * You will see a lot of zeros when the Motors are not running. The main values that are not 
 * zero are the two Light Sensors and the two free ADC Channels. 
 */ 
void readAllRegisters(void) 
{ 
    I2CTWI_transmitByte(I2C_RP6_BASE_ADR, 0); // Start with register 0... 
    I2CTWI_readBytes(I2C_RP6_BASE_ADR,RP6data, 30); // and read all 30 registers up to 
                                                    // register Number 29 ! 
 
    // Now we output the Data we have just read on the serial interface: 
    writeString_P("\nREADING ALL RP6 REGISTERS:"); 
    uint8_t i = 0; 
    for(i = 0; i < 30; i++) 
    { 
        if(i % 8 == 0)           // add some newline chars otherwise everything  
            writeChar('\n');  // is printed on ONE single line... 
        else 
            writeString_P(" | "); 
        writeChar('#'); 
        writeIntegerLength(i,DEC,2); 
        writeChar(':'); 
        writeIntegerLength(RP6data[i],DEC,3); 
    } 
    writeChar('\n'); 
}

die variable (array) "uint8_t RP6data[32]", die auch so definiert wird und dann in der zeile:

I2CTWI_readBytes(I2C_RP6_BASE_ADR,RP6data, 30);

auch als RP6data beschrieben/gefüllt wird...

aber wie gesagt, das muss ich erstmal verstanden haben...

ein kleiner erfolg auf dem weg zu einer funktionierenden bake:

es ist mir gelungen mit der einstellung an den beiden potis des blinkers und an der mSleep-verzögerung im programm das so einzustellen, dass über einen längeren zeitraum einmal pro sekunde das IRsignal gesendet UND auch vom RP6 empfangen wird. Ohne aussetzer, das war bisher nicht der fall, war mehr oder weniger zufällig, wenns mal geklapt hat, zumindest nicht so regelmäßig..

**Dirk** · 22.12.2013, 11:56

Hi inka,

die variable (array) "uint8_t RP6data[32]", die auch so definiert wird und dann in der zeile:
I2CTWI_readBytes(I2C_RP6_BASE_ADR,RP6data, 30);
auch als RP6data beschrieben/gefüllt wird...
aber wie gesagt, das muss ich erstmal verstanden haben...

Das ist ja eine Funktion aus der RP6I2CmasterTWI-Library.
Im Header der Lib ist die Funktion als Prototyp so deklariert:

Code:

void I2CTWI_readBytes(uint8_t targetAdr, uint8_t * messageBuffer, uint8_t numberOfBytes);

Das heißt: Als 2. Parameter wird der messageBuffer als Adresse (im Speicher, also nicht als Wert) übergeben. In der Lib besteht der messageBuffer aus der Feldvariablen RP6data, so dass man die Funktion so aufrufen kann, wie du oben angeführt hast. Das geht so aber nur, wenn RP6data in der Parameterliste einer Funktion auftaucht.
Grundsätzlich würde ich einer einzelnen Variablen nicht den Namen einer Feldvariable geben, dann bleibt's übersichtlich.

Für dein Programm:
Ich würde die read_IR_value() Funktion so ändern:

Code:

uint8_t read_IR_value(void)
{ uint8_t temp;
 I2CTWI_transmitByte(I2C_RP6_BASE_ADR, 30); // Start with register 30
 I2CTWI_readBytes(I2C_RP6_BASE_ADR, temp, 1);
 return temp;
}

Die Funktion hat dadurch einen Byte-Rückgabewert und wird so aufgerufen: Wert = read_IR_value();
Wenn du diese Werte dann in eine Feldvariable übernehmen willst:

Code:

 i = 0;

 // Schleife:
 ir_value[i] = read_IR_value();
 i++;

Wenn du diese zwei Zeilen mehrfach aufrufst (z.B. in einer Schleife), wird dein Wert (IR-Empfang ja oder nein) nacheinander in die Feldvariable ir_value gepackt.
Du must natürlich dafür sorgen, das sie ausreichend dimensioniert ist und i also nicht zu hoch wird.

ein kleiner erfolg auf dem weg zu einer funktionierenden bake

Klingt gut!

**inka** · 11.01.2014, 16:15

Hi,

mit den änderungen

Code:

case 2://
    setLEDs(0b0010);
    writeString_P("\n\n messung feldvariable\n");

    initRP6Control();
    initLCD();

    while(true)
    {
//    rotate (20, RIGHT, 3, false);

//    read_IR_value();
        uint8_t i = 0;
    for(i = 0; i < 499; i++)
        {
        temp_IR[i] = read_IR_value();
        feld_IR[i] = temp_IR[i];
//        feld_IR[i] = read_IR_value();
        writeIntegerLength(temp_IR[i],DEC,4);
        if(i % 7 == 0)
            writeChar('\n');
        else
            writeString_P(" | ");
        mSleep(100);
//        move(50, FWD, DIST_MM(100), false);
        }

    clearLCD();

    setCursorPosLCD(0, 0);
    writeStringLCD_P("bin: ");
    setCursorPosLCD(0, 8);
    writeIntegerLengthLCD(temp_IR[0], BIN, 8);
    mSleep(300);
    setMultiIOLED3(0);

    readAllRegisters();
    mSleep(100);


        /**************************/
        uint8_t key_1 = getMultiIOPressedButtonNumber();
        key_1 = getMultiIOPressedButtonNumber();
        if(key_1 != 0) break;

        /**************************/
    }

    break;

konnte ich nun herausfinden, wie oft, bzw. mit welchem muster meine IR-bake sendet - und empfangen wird. Hier ein teilinhalt der feldvariablen "uint8_t feld_IR[500]" :

Klicke auf die Grafik für eine größere Ansicht

Name: 2014_01_11_IR_log.jpg
Hits: 21
Größe: 122,5 KB
ID: 27136

es ist folgendes muster, welches empfangen wird:

4x nichts / treffer / 3x nichts / treffer / 4x nichts / treffer usw, usw...

ich nehme an, dass der IR empfänger nicht dauernd empfängt, sondern in einem bestimmten rhythmus. Das würde evtl. erklären warum die optische anzeige (LED)

Code:

  case 1://
    setLEDs(0b0001);
    writeString_P("\n\n messung einzelsignal\n");

    initRP6Control();
    initLCD();

    // ---------------------------------------
    WDT_setRequestHandler(watchDogRequest);

/*************************************************************/

    while(true)
    {
//    rotate (20, RIGHT, 3, false);

        temp = read_IR_value();

        mSleep(100);

    if (temp == 0)
        {
        setMultiIOLED3(1);
        mSleep(100);
        setMultiIOLED3(0);
//        move(50, FWD, DIST_MM(100), false);
        }

    clearLCD();

    setCursorPosLCD(0, 0);
    writeStringLCD_P("dec: ");
    setCursorPosLCD(0, 8);
    writeIntegerLengthLCD(temp, DEC, 1);
    mSleep(300);
//    setMultiIOLED3(0);

    readAllRegisters();
    mSleep(100);


        /**************************/
        uint8_t key_1 = getMultiIOPressedButtonNumber();
        key_1 = getMultiIOPressedButtonNumber();
        if(key_1 != 0) break;

        /**************************/
    }
break;

zwar funktioniert (reaktion auf einzelne empfangene IR-signale), aber in wesentlich unregelmäßigen abständen als dieses 3 - 1 - 4 - 1 - 3 - 1 - 4 - 1 -...
Diesen rhythmuss möchte ich beibehalten, er scheint mir insofern günstig, weil man mit diesem rhythmus die IR-bake identifizieren könnte...

es beschäftigen mich nun folgende fragen:

- wie finde ich den IR-empfangsrhythmus des RP6 raus?
- Ist er irgendwo angegeben, muss ich ihn irgendwie berechnen/messen (stopwatches?)?
- wie passe ich die beiden frequenzen aneinander an?

für ideen und tipps bin ich wie immer dankbar...

**Dirk** · 11.01.2014, 22:13

Hi inka,
da bist du ja schon etwas weiter gekommen!

Diesen rhythmuss möchte ich beibehalten, er scheint mir insofern günstig, weil man mit diesem rhythmus die IR-bake identifizieren könnte...

Tatsächlich könnte man Baken mit unterschiedlicher Modulationsfrequenz so erkennen.
Dein Ausdruck der Werte scheint zu sagen, dass die Bake in regelmäßigen Abständen erkannt wird, wobei die AN-Phase nur kurz (1-3 Werte) erscheint und die AUS-Phase wohl etwa 4x so lang ist. Halt mal das Oszilloskop an den Treiber der Bake, um zu sehen, ob das so etwa auch gesendet wird (AN-AUS = 1-4).
Der "Leserhythmus" des IR-Signals wird im Wesentlichen bestimmt durch die zeitliche Länge der for(i = 0; i < 499; i++) - Schleife. Darin gibt es einerseits die feste Pause von 100ms (mSleep(100); ), dann die Zeit, die die UART-Ausgabe der Werte (writeIntegerLength(...) u.a.) braucht und die Zeit für die I2C-Kommunikation in der IR-Lesefunktion (read_IR_value(); ).
Messen kann man die Zyklusdauer der Schleife z.B. mit den Stopwatches:
1. Starten am Programmanfang mit: startStopwatch1();
2. Variable definieren: uint16_t zeitdauer;
3. Zurücksetzen auf 0 am Anfang der for(i = 0; i < 499; i++) - Schleife: if (i==498 ) setStopwatch1(0);
4. Lesen des Stopwatch Werts mit: if (i==498 ) zeitdauer = getStopwatch1(); am Ende der Schleife
5. Nach der Schleife den Wert von zeitdauer ausgeben.
Damit wird im letzten Schleifendurchlauf die Dauer in Millisekunden gemessen. Man kann das dann in die Frequenz umrechnen.

**inka** · 12.01.2014, 14:19

hi Dirk,
den "rest" dann in aller ruhe, zunächst zu der interpretation der IR-logdatei:

Zitat von Dirk

Dein Ausdruck der Werte scheint zu sagen, dass die Bake in regelmäßigen Abständen erkannt wird, wobei die AN-Phase nur kurz (1-3 Werte) erscheint und die AUS-Phase wohl etwa 4x so lang ist. Halt mal das Oszilloskop an den Treiber der Bake, um zu sehen, ob das so etwa auch gesendet wird (AN-AUS = 1-4).

das mit derm oszi funktioniert nicht, ich sehe bei allen möglichen einstellungen nur einen waagerechten strich, der seine lage im blinkinterwall der bake rauf und runter ändert, bekomme also keine darstellung der abwechselnden phasen in waagerechetn richtung aneinander gereiht, keine ahnung warum...

nun zu der logdatei:

ich würde die AN/AUS phasen anders interpretieren:

0004 bedeute kein signal
0000 bedeutet signal empfangen

in der reienfolge aus dem bild ist es dann doch so:

aus aus aus aus an aus aus aus an aus aus aus aus an aus aus aus an .............

also hätte die AN-phase jeweils nur ein wert und die AUS-phase abwechselnd 3 oder 4 werte. oder sehe ich da was falsch?