So, Ziel ist erreicht. Ein Primitivst Regler hält Asuro die paar cm lang einigermaßen in Richtung. Weiters habe ich es jetzt so gemacht dass Asuro nur noch 10cm lang versucht einen Barcode zu finden. Wenn er bis dorthin keinen gefunden hat, bricht er ab.

Hier der aktualisierte Code:

Code:
/*Einstellungen um Asuro fit für die Barcode-Funktion zu machen.*/
/*Geschwindigkeit links/rechts definieren=>damit Asuro geradeausfährt*/
#define BC_SPEED 90
/*Hell/Dunkel Schwelle für Odometrie.
Linke Odometrie wird als Referenz verwendet*/
#define BC_OLSCHWELLE 600
#define BC_ORSCHWELLE 730
/*Hell/Dunkel Schwelle für Barcode*/
#define BC_LSCHWELLE 45


/*Einstellungen um das Barcode zu ändern.*/
/*ACHTUNG: Bei Veränderungen von BC_STRICH_ANZAHL müssen in der Funktion
2 Anpassungen vorgenommen werden! Näheres siehe in der Funktion!*/
/*Anzahl der Datenbits*/
#define BC_DATENBITS_ANZAHL 3
/*Anzahl der Striche(Startbit+Datenbits+Prüfbit inklusive Stoppbit)*/
#define BC_STRICH_ANZAHL 5
/*Wie oft pro Strich der Helligkeitswert gemessen werden soll
ACHTUNG: dafür muss die Strichbreite angepasst werden*/
#define BC_ABTASTUNGEN_PRO_STRICH 5
/*Um im bin_erg[] eine 1 auszulösen, müssen pro Strich mindestens
BC_ABTASTUNGEN_PRO_STRICH-2 Messwerte 1 sein. */
#define BC_LOGIKSCHWELLE 3
/*Anzahl der Werte im daten[] Array*/
#define BC_MAX_WERTE 55
/*Fehlercodes*/
#define BC_FEHLER_PARITY 255
#define BC_FEHLER_RICHTUNG 254

unsigned char fkt_barcode_lesen(void)
{
    unsigned int ldata[2]={0},odata[2]={0};
    unsigned int led_on[2]={0},led_off[2]={0};
    unsigned int links=0,rechts=0,ges=0;

    unsigned char flag_l=0,flag_r=0,n=0,startbit=0,summe=0,index=0,dez_erg=0,richtung=0;
    unsigned char odo_counter=0,counter_l=0,counter_r=0,speed_l=BC_SPEED,speed_r=BC_SPEED;
    unsigned char daten[BC_MAX_WERTE]={0},bin_erg[BC_STRICH_ANZAHL-1]={0};
    MotorDir(FWD,FWD);
    MotorSpeed(BC_SPEED,BC_SPEED);
    StatusLED(OFF);

    /*Wegstrecke(odocounter) ab Startbit messen*/
    while(odo_counter<BC_MAX_WERTE)
    {

        OdometrieData(odata);
        MotorSpeed(speed_l,speed_r);

        /*Bei jedem Tick daten[] Array auffüllen.*/
        if( (flag_l==0 && odata[0]>BC_OLSCHWELLE) ||
            (flag_l==1 && odata[0]<BC_OLSCHWELLE) )
        {
            counter_l++;
            FrontLED(ON);
            LineData(ldata);
            led_on[0]=ldata[0];
            led_on[1]=ldata[1];

            FrontLED(OFF);
            LineData(ldata);
            led_off[0]=ldata[0];
            led_off[1]=ldata[1];

            links=led_on[0]-led_off[0];
            rechts=led_on[1]-led_off[1];
            ges=(links+rechts)/2;

            if(ges<BC_LSCHWELLE)
            {
                daten[odo_counter]=1;
                if(startbit==0)
                {
                    StatusLED(GREEN);
                    startbit=1;
                }
            }

            if(flag_l==0)
                flag_l=1;

            else
                flag_l=0;


            if(startbit!=0)
            {
                odo_counter++;
            }
        }

        if( (flag_r==0 && odata[1]>BC_ORSCHWELLE) ||
            (flag_r==1 && odata[1]<BC_ORSCHWELLE) )
        {
            counter_r++;

            if(flag_r==0)
                flag_r=1;

            else
                flag_r=0;
        }

        if(Gettime()%75==0 && (counter_l>3 || counter_r>3) )
        {
            if(counter_l<counter_r)
            {
                speed_l=speed_l+1;
            }
            else if(counter_l>counter_r)
            {
                speed_l=speed_l-1;
            }
            if( (counter_l>35 || counter_r>35) && startbit==0)
                break;
        }


    }

    MotorDir(BREAK,BREAK);
    MotorSpeed(0,0);

    /*Binärzahl aufbauen + Prüfbit*/
     for(n=0;n<BC_MAX_WERTE;n++)
     {

        summe=summe+daten[n];

        /*Wenn BC_STRICH_ANZAHL verändert wird,
        muss hier ein entsprechender Eintrag erfolgen*/
        if((n+1)%BC_ABTASTUNGEN_PRO_STRICH==0)
        {
            if((n+1)==(BC_ABTASTUNGEN_PRO_STRICH*3)
                ||
                (n+1)==(BC_ABTASTUNGEN_PRO_STRICH*5)
                ||
                (n+1)==(BC_ABTASTUNGEN_PRO_STRICH*7)
                ||
                (n+1)==(BC_ABTASTUNGEN_PRO_STRICH*9))
            {
                if(summe>=BC_LOGIKSCHWELLE)
                    bin_erg[index]=1;
                else
                    bin_erg[index]=0;

                index++;

            }

        summe=0;
        }

     }

    /*Richtung erkennen*/
    /*Wenn BC_STRICH_ANZAHL verändert wird,
    muss hier der Faktor angepasst werden.*/
     summe=0;
     for(n=(BC_ABTASTUNGEN_PRO_STRICH*9);n<(BC_ABTASTUNGEN_PRO_STRICH*11);n++)
     {
         summe=summe+daten[n];
     }
     if(summe>=(BC_ABTASTUNGEN_PRO_STRICH*2-BC_LOGIKSCHWELLE))
        richtung=1;


    /*Binärzahl umwandeln in Dezimalzahl oder Fehlercode zurückgeben*/

    /*alles OK => Dezimalzahl zurückgeben*/
    if((bin_erg[0]+bin_erg[1]+bin_erg[2])%2!=bin_erg[3] && richtung==1)
        dez_erg=4*bin_erg[0]+2*bin_erg[1]+1*bin_erg[2];

    /*Fehlercode BC_FEHLER_RICHTUNG->falsche Richtung*/
    else if((bin_erg[0]+bin_erg[1]+bin_erg[2])%2!=bin_erg[3] && richtung==0)
        dez_erg=BC_FEHLER_RICHTUNG;

    /*Prüfbit falsch*/
    else
        dez_erg=BC_FEHLER_PARITY;


    StatusLED(OFF);

    return dez_erg;
}
Beispiel Anwendung der Funktion:
Code:
unsigned char fkt_taster(void);

int main(void)
{
    unsigned char c=0,d=0;

    Init();

    while(1)
    {
        c=fkt_barcode_lesen();
        SerPrint("\r\nBarcode=");
        PrintInt(c);

        if(c!=255 && c!=254)
        {
            for(d=0;d<c;d++)
            {
                Msleep(500);
                StatusLED(GREEN);
                Msleep(500);
                StatusLED(OFF);
            }
        }
        while(fkt_taster()==0);
    }




    return 0;
}

unsigned char fkt_taster(void)
{
    unsigned char taster=0;

    taster=PollSwitch();

    if(taster==PollSwitch() && taster!=0)
        return taster;
    else
        return 0;
}