-
        

Seite 1 von 2 12 LetzteLetzte
Ergebnis 1 bis 10 von 11

Thema: Problem mit Bitfeld Array

  1. #1
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.08.2008
    Ort
    Graz
    Beiträge
    500

    Problem mit Bitfeld Array

    Anzeige

    Ich hab mit ein Bitfield Array erstellt, mit dem ich die Karte vom Grundstück abbilde:
    1. Feld 3 Bit: Zähler für Felder in denen der Roboter schon war
    2. Feld 4 Bit: Zähler für temporäre Hindernisse: Wenn der Roboter selbst ein Hinderniss erkennt, soll hier der Wert hochgezählt werden
    3. Feld 1 Bit: Bit setzen wenn das Feld blockiert ist, zB Haus, ist fix in Karte_init vorgegeben.

    Der Roboter ist schon seit letztem Jahr mit der Karte unterwegs, bisher wurden nur Felder 1 und 3 verwendet.
    Jetzt wollte ich auch Feld 2 verwenden, um damit eine teilweise selbstlernende Karte umzusetzen.

    Wenn aber Werte in Feld 2 geschrieben werden (Funktion Karte_Temp_schreiben), wird auch zumindest Feld 3 verändert. Ob auch Feld 1 zufällig verändert wird kann ich nicht bestätigen da immer sehr viele Felder betroffen sind. Zumindest ist mir nicht aufgefallen dass diese auf einmal niedrigere Werte hätten, also sollte es passen.
    Es werden oft gleich ganze Spalten (y) von Feld 3 verändert. Hatte zuerst das EEPROM in Verdacht, aber seitdem ich die Funktion Karte_Temp_schreiben deaktiviert habe, passt die Karte wieder. (Übertrage die Daten vom EEPROM ins Excel für eine übersichtliche Ansicht der Karte)


    Damit es ja keine Fehler gibt wie über die Array Grenzen hinaus schreiben oder lesen, wird das Array nur über die unten gezeigten Funktionen beschrieben/gelesen.

    Unten der Code, wo liegt der Fehler?
    Mit falschen Werten in Feld 3 funktioniert die Navigation nicht mehr.

    LG!


    allgemeine defines der Karte:
    Code:
    #define grund_x 46 //  Anzahl Felder W-O
    #define grund_y 84 //Anzahl Felder S-O
    #define kartenfeld 50 // Größe eines Kartenfeldes in 1cm Einheit
    #define zielbereich 80    // auf 80*x cm genau soll Ziel erreicht werden
    #define    besetzt 1
    
    #define pos_x_max (grund_x*kartenfeld-1)
    #define    pos_y_max (grund_y*kartenfeld-1)
    
    // für A*
    #define max_x_karte     (grund_x/2-2)
    #define max_y_karte     (grund_y/2-2)
    #define max_x             (max_x_karte-1)
    #define max_y             (max_y_karte-1)
    #define kartenfeld_navi (kartenfeld*2)
    karte.h:
    Code:
    extern unsigned char Karte_lesen(unsigned char x, unsigned char y); /* liest 1x gemaehtes Felder */
    extern unsigned char Karte_lesen_navi(unsigned char x, unsigned char y); /* liest 4x fixbesetze Felder */
    extern unsigned char Karte_lesen_naviII(unsigned char x, unsigned char y);/* liest 1x fixbesetze Felder */
    extern void Karte_schreiben(unsigned char x, unsigned char y, unsigned char wert); /* schreibt 1x gemaehtes Felder */
    extern unsigned char Karte_Temp_lesen(unsigned char x, unsigned char y); /* liest 1x temp Felder */
    extern void Karte_Temp_schreiben(unsigned char x, unsigned char y, unsigned char wert); /* schreibt 1x temp Felder */
    extern void Karte_init(void); // besetzte Felder der Karte festlegen
    extern void Karte_schreiben_init(unsigned char x, unsigned char y); /* schreibt 1x besetzt Felder */
    extern void Karte_loeschen(void); // komplett löschen
    Karte.c:
    Code:
    #include <stdlib.h>
    #include "karte.h"
    #include <allgemeine_defines.h>
    
    static struct
    {
        unsigned char gemaeht:3;
        unsigned char temp_besetzt:4;
        unsigned char fixbesetzt:1;
        
    } Karte[grund_x+1][grund_y+1];
    
    /*+++++++++++++++ Karte bearbeiten ++++++++++++++++++++++*/
    inline unsigned char Karte_lesen(unsigned char x, unsigned char y)
    {
        unsigned char wert;
    
        if ((x<grund_x)&&(y<grund_y))
        {
            if (Karte[x][y].fixbesetzt!=0) wert=100; // beim überprüfen auf fertig gemäht müssen die besetzten Felder mitgezählt werden.
            else wert=Karte[x][y].gemaeht;
            
        }
        else wert=255;
    
        return(wert);
    }
    
    
    
    // 4 Felder auf 1x lesen, Navi verwendet Karte mit nur 1/4 Auflösung!!!!
    inline unsigned char Karte_lesen_navi(unsigned char x, unsigned char y)
    {
        unsigned char wert;
        wert=0;
        if (((x*2+1)<grund_x)&&((y*2+1)<grund_y))
        {
            wert=Karte[x*2][y*2].fixbesetzt;
            wert=wert+Karte[x*2][y*2+1].fixbesetzt;
            wert=wert+Karte[x*2+1][y*2].fixbesetzt;
            wert=wert+Karte[x*2+1][y*2+1].fixbesetzt;
            
            
        }
        else wert=255;
    
        return(wert);
    }
    
    inline unsigned char Karte_lesen_naviII(unsigned char x, unsigned char y)
    {
        unsigned char wert;
        wert=0;
        if ((x<grund_x)&&(y<grund_y))
        {
            wert=Karte[x][y].fixbesetzt;
    
        }
        else wert=1;
    
        return(wert);
    }
    
    
    inline void Karte_schreiben(unsigned char x, unsigned char y, unsigned char wert)
    {
        if ((x<grund_x)&&(y<grund_y))
        {
            if(Karte[x][y].fixbesetzt==0)
            {
                if (wert==0)
                {
                    if (Karte[x][y].gemaeht<7) Karte[x][y].gemaeht++;
                }
                else
                {if (wert>7) wert=7;
                    Karte[x][y].gemaeht=wert;
                }
            }
        }
    }
    
    inline unsigned char Karte_Temp_lesen(unsigned char x, unsigned char y)
    {
        unsigned char wert;
    
        if ((x<grund_x)&&(y<grund_y))
        {
            wert=Karte[x][y].temp_besetzt;
        }
        else wert=0;
    
        return(wert);
    }
    inline void Karte_Temp_schreiben(unsigned char x, unsigned char y, unsigned char wert)
    {
        if ((x<grund_x)&&(y<grund_y))
        {
                if (wert==0)
                {
                    if (Karte[x][y].temp_besetzt<=1) Karte[x][y].temp_besetzt=9;
                    if (Karte[x][y].temp_besetzt<13) Karte[x][y].temp_besetzt++;
                }
                else
                {
                    if (wert>14) wert=14;
                    Karte[x][y].temp_besetzt=wert;
                }
    
        }
    }
    
    void Karte_schreiben_init(unsigned char x, unsigned char y)
    {
        if ((x<grund_x)&&(y<grund_y))
        {
            Karte[x][y].fixbesetzt=1;
    
        }
        
    }
    
    /*++++++++++++++++++ Karte init +++++++++++++++++++++++++++*/
    void Karte_init(void) // besetzte Felder der Karte festlegen
    {unsigned char x,y;
        
        // Tor
        Karte_schreiben_init(14,0);Karte_schreiben_init(16,0);Karte_schreiben_init(18,0);
        Karte_schreiben_init(15,0);Karte_schreiben_init(17,0);Karte_schreiben_init(19,0);
        // Kompost
        //    Karte_schreiben_init(4,82,besetzt);Karte_schreiben_init(5,82,besetzt);Karte_schreiben_init(4,81,besetzt);
        for (x=2;x<=3;x++)
        {for (y=77;y<=79;y++)
            Karte_schreiben_init(x,y);
        }
        // Ecke Terasse Garagenmauer schwer erreichbar
        //    Karte_schreiben_init(17,29,besetzt);
        // Zaun hinten
        
        for (x=26;x<grund_x;x++) // Zaun hinten schief
        Karte_schreiben_init(x,83);
        for (x=28;x<grund_x;x++) // Büsche
        Karte_schreiben_init(x,82);
        for (x=28;x<grund_x;x++) // Büsche
        Karte_schreiben_init(x,81);
        for (y=72;y<grund_y;y++) // Büsche
        Karte_schreiben_init(44,y);
    
    
        // Zaun links
        for (y=22;y<grund_y;y++)
        Karte_schreiben_init(0,y);
        for (y=64;y<grund_y;y++)
        Karte_schreiben_init(1,y);
        // Zaun rechts
        for (y=46;y<grund_y;y++)
        Karte_schreiben_init(45,y);
        for (x=28;x<grund_x;x++)
        Karte_schreiben_init(x,0);
        //Haus
        for (x=14;x<=38;x++)
        {for (y=38;y<=60;y++)
            Karte_schreiben_init(x,y);
        }
        // Garage
        for (x=8;x<=16;x++)
        {for (y=32;y<=47;y++)
            Karte_schreiben_init(x,y);
        }
        for (x=10;x<=16;x++) // //schwer erreichbar ==> nicht als leeres Feld suchen und anfahren lassen, aber auch nicht für Zufallsfahrt blockieren
        {for (y=18;y<=31;y++)
            Karte_schreiben(x,y,3);
        }
    
        
        for (y=18;y<=32;y++) // Garagenmauern, notwendig für A*
        {    Karte_schreiben_init(9,y);
            Karte_schreiben_init(16,y);
        }
    
    
        // Terasse
        for (x=16;x<=28;x++)
        {for (y=30;y<=37;y++)
            Karte_schreiben_init(x,y);
        }
       
    
    
        //Spielhaus
        for (x=39;x<=42;x++)
        {for (y=8;y<=12;y++)
            Karte_schreiben_init(x,y);
        }
    
        //Sandkiste
        for (x=40;x<=42;x++)
        {for (y=15;y<=18;y++)
            Karte_schreiben_init(x,y);
        }
    
    }
    
    
    void Karte_loeschen(void)
    {
    unsigned char x,y;    
    
        for (x=0;x<grund_x;x++) // Karte komplett löschen
        {
            for (y=0;y<grund_y;y++)
            {
                Karte[x][y].fixbesetzt=0; 
                Karte[x][y].temp_besetzt=1; 
                Karte[x][y].gemaeht=1;
            }
        }
    }
    alles über meinen Rasenmäherroboter (wer Tippfehler findet darf sie gedanklich ausbessern, nur für besonders kreative Fehler behalte ich mir ein Copyright vor.)

  2. #2
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.08.2008
    Ort
    Graz
    Beiträge
    500
    Keiner eine Ahnung warum Karte_Temp_schreiben nicht funktioniert?
    alles über meinen Rasenmäherroboter (wer Tippfehler findet darf sie gedanklich ausbessern, nur für besonders kreative Fehler behalte ich mir ein Copyright vor.)

  3. #3
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.08.2008
    Ort
    DE
    Beiträge
    523
    Werde mir das demnächst mal ansehen. Sehe ich das soweit richtig, dass ein Fehler immer nur auftritt, wenn du Karte_temp_schreiben anwendest?

    mfg

  4. #4
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    22.06.2009
    Beiträge
    1.266
    Ich rate jetzt einfach mal so ins blaue rein und gebe mal paar möglichkeiten an die so ein Verhalten hervorrufen könnten. 1. Du versuchst mehr als 4 bit reinzuschreiben. 2. Der Speicher deines Microcontrollers reicht nicht aus. 3,. Du greifst sonst irgendwie drauf zu und zerschiest dabei was.

  5. #5
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.08.2008
    Ort
    Graz
    Beiträge
    500
    @Wsk8: genau, die Funk​tion Karte_temp_schreiben beeinflusst Feld 3, die Karte funktioniert nur wenn diese Funktion nicht verwendet wird.

    @shedepe: der Kontroller hat noch 9kB SRam frei. Es wird nur über diese hier aufgeführten Funktionen auf das Array zugegriffen, gerade um ein zerschiesen des Programmes auszuschließen!

    LG!
    alles über meinen Rasenmäherroboter (wer Tippfehler findet darf sie gedanklich ausbessern, nur für besonders kreative Fehler behalte ich mir ein Copyright vor.)

  6. #6
    Erfahrener Benutzer Begeisterter Techniker
    Registriert seit
    13.01.2014
    Beiträge
    398
    Blog-Einträge
    3
    Code:
    static struct {
        unsigned char gemaeht:3;
        unsigned char temp_besetzt:4;
        unsigned char fixbesetzt:1;
     } Karte[grund_x+1][grund_y+1];
    Warum grund_x+1 bzw. grund_y+1 statt grund_x bzw. grund_y?

  7. #7
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.08.2008
    Ort
    Graz
    Beiträge
    500
    Angstbytes damit das Array sicher groß genug ist.
    LG!
    alles über meinen Rasenmäherroboter (wer Tippfehler findet darf sie gedanklich ausbessern, nur für besonders kreative Fehler behalte ich mir ein Copyright vor.)

  8. #8
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.08.2008
    Ort
    DE
    Beiträge
    523
    Also Karte_temp_schreiben sollte korrekt funktionieren. Gab bei mir keine Probleme. Und wenn du die 4 Bits voll ausnutzen möchtest, dann dürfen da Werte <= 15 drin stehen.

    mfg

  9. #9
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    20.08.2008
    Ort
    Kandel
    Alter
    29
    Beiträge
    1.220
    Wenn du sagst, dass ganze Spalten (mehrere X=const, Y=variabel Koordinaten) betroffen sind, spricht das eigentlich für einen Fehler außerhalb. Läuft dein Code auch ohne angeschlossene Hardware (oder alternativ: Hast du Zugang zu einem Hardware-Debugger? Dann würde ich dir nämlich raten, einfach Mal dem AVR beim Rechnen zuzusehen und zu beobachten wann die betreffenden Speicherbereiche beschädigt werden.

    Alternativ könntest du versuchen, Routinen zur Speicher-Validierung umzusetzen (dir z.Bsp. einige Zellen mit bekanntem Inhalt auswählen, deren Inhalt vor/nach jeder Manipulation prüfen und sobald eine Abweichung vom Soll auftritt, Alarm schlagen und möglichst detailliert den aktuellen Systemzustand ausgeben).

    mfG
    Markus
    Tiny ASURO Library: Thread und sf.net Seite

  10. #10
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    06.08.2008
    Ort
    Graz
    Beiträge
    500
    Hm, werde die Funktion wieder aktivieren, rechne aber dass es wieder die Karte zerstören wird. Ohne Karte_temp_schreiben waren die Werte stabil, dh die blockierten Felder waren immer sichtbar.
    Überlege was ich zur Speicher Validierung umsetzen kann, vielleicht ein paar fixe Positionen mit Karte_temp_schreiben beschreiben, um zu sehen wie lange oder bei welchen Positionen die Karte fehlerhaft wird.

    LG!
    alles über meinen Rasenmäherroboter (wer Tippfehler findet darf sie gedanklich ausbessern, nur für besonders kreative Fehler behalte ich mir ein Copyright vor.)

Seite 1 von 2 12 LetzteLetzte

Ähnliche Themen

  1. Problem mit gets(array-variable) in C
    Von pete1612 im Forum Software, Algorithmen und KI
    Antworten: 5
    Letzter Beitrag: 10.04.2012, 22:07
  2. Problem mit Array
    Von The Man im Forum C - Programmierung (GCC u.a.)
    Antworten: 7
    Letzter Beitrag: 31.01.2009, 18:39
  3. Problem mit globalen Array [gelöst]
    Von OnkelTobi im Forum C - Programmierung (GCC u.a.)
    Antworten: 0
    Letzter Beitrag: 25.11.2006, 16:04
  4. n-Damen-Problem lösen mit dynamischem mehrdim. Array
    Von n0Br4iN3r im Forum C - Programmierung (GCC u.a.)
    Antworten: 6
    Letzter Beitrag: 23.09.2005, 13:19
  5. Problem mit Array und Ports
    Von pensoffsky im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 2
    Letzter Beitrag: 14.08.2005, 21:00

Berechtigungen

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