Svenska ElektronikForumet

Kan undra om det blir att tänka om helt angående visningen... Koden nedan fungerar nästan klanderfritt förutom att uppdateringen blir så långsam så pilarna blinkar synligt på displayen.
Funktionen kallas rakt från main-loopen, utan delayer eller annat.

Kod: Markera allt

void screenUpdate() {
    
    int X = 0;
    int Y = 0;
      
    for(int i=0; i < commands; i++){
  
      
      
      switch(commands[i]){
        
        case 'F':
        u8g.firstPage();
        do {
        u8g.drawBitmapP( X, Y, 2, 20, arrow_up); }
        while(u8g.nextPage());
        X+=16;
        break;
    
        case 'L':
        u8g.firstPage();
        do {
        u8g.drawBitmapP( X, Y, 2, 20, arrow_left); }
        while(u8g.nextPage());
        X+=16;
        
        break;
  
        case 'R':
        u8g.firstPage();
        do {
        u8g.drawBitmapP( X, Y, 2, 20, arrow_right); }
        while(u8g.nextPage());
        X+=16;
        //
        break;
  
      }
  
   // Hantera radbyte
      if(X>160){
        X+=0;
        Y+=21;
      }
      
    }
 
}

? Är det snarare inte så att det blir blink för att den 100-tals gånger per sekund uppdaterar? Hur ser det ut om du bara kör den 1 gång?

Jag provade precis att deklarera uint8_t commands[24] = { 'L','F','R','L','F','R','R','L','L','R','F' };, och sen köra funktionen genom att lägga den i setup().
Det enda jag ser på skärmen är att pilarna bläddrar förbi en gång snabbt på displayen, för att sen bli helt svart.

I for-loopen står det i < commands. Vet inte hur kompilatorn till arduino tolkar detta. Kan tolkas som 24, något på 70 eller pekarens värde.Du bör använda sizeof(commands) istället. Har kanske inte med ditt problem att göra men onödigt att köra for-loopen för många gånger.

En väldigt bra poäng men kommer inte alltid sizeof(commands) returnera 24 i och med att jag deklarerat uint8_t commands[24];?

Den gjorde det innan när jag testade men jag gjorde säkert något fel.

Den kommer alltid returnera 24 då. Du får ha en räknare som håller reda på antalet symboler som ska visas och som finns i arrayen.

Såhär kanske?

Kod: Markera allt

#define COMMANDS_SIZE 24
uint8_t commands[COMMANDS_SIZE];

for(int i=0; i < COMMANDS_SIZE; i++){}

Min tanke var att displayen aldrig kommer att kunna visa mer än 24 pixlar så jag skrev in det direkt.
Men visst blir det precis samma sak som jag redan gjort förutom att er metod är enklare att överblicka och ändra?

Satt och funderade lite och antagligen går allt för långsamt. I och med att jag såg pilarna "rulla" förbi på displayen så blir väl det en indikation på att systemet är för slött.
Hade alla pilar bara blinkat till så skulle väl det visa att den i alla fall är snabb nog att visa alla pilar utan att man uppfattar att dom egentligen kommer sekvensiellt?

Neeeej, det borde finnas något sätt att inte skriva om alla tecken så fort ett nytt ska skrivas.

Ja om du skriver 24 eller definierar nått till 24 blir samma sak. Men jag tror att du inte bör skriva commands utan att använda sizeof().

Men jag förstår inte riktigt vad du menar med att alla pilar blinkar. Bör inte principen vara att endast skriva ut rätt pil EN gång när du trycker på en knapp och sen rensa(kanske genom att skriva en blank bitmap) när ingen knapp är intryckt?

Ok, perfekt. Ska använda mig av sizeof()

Tanken är att displayen ska visa hela sekvensen/serien av rörelser som man programmerar. Totalt blir det 8 pilar per rad, i 4 rader.
När man sen trycker "kör" så går roboten just den sekvensen.
Det jag märker med koden som jag postade är att ju fler tecken jag matar in desto lägre frekvens uppdateras hela displayen med. Alltså pilarna blinkar långsammare och långsammare.

Jag tror problemet är att for-loopen samt en skrivning av en pil tar lite för lång tid så när det väl börjar bli 4-5 pilar så tar skrivningen så lång tid så pilarna blinkar.
Sitter just nu att labbar med att strunta i for-loopen och försöka skriva en pil i taget utan att skriva om hela displayen (alla tecken).
Har lyckats få skrivningen skitbra med radbryt med mera men displayen visar just nu enbart den senast inmatade pilen, allt annat är svart.

Det är inga problem att skriva ut en statisk bild tillräkligt snabbt, du vet mitt lilla geocaching spel jag visade häromdan, gör ju delar av det du vill (ikoner som ändras osv)
Har du tid ngn kväll att jag kommer över kanske vi kan klura in min rutin?

Jaha, då förstår jag. Men då behöver du ju bara trycka på en knapp, skriva ut rätt pil, flytta pekaren och vänta på nästa tryck, skriva ut rätt pil, flytta pekaren o.s.v
Dvs bygga sekvensen steg för steg med knapparna. Då blir det bara en pil att skriva ut en gång för varje tryck.

Låter kanon Xyzzy men jag undrar ändå om det här inte är en annan sak. Att skriva ut en statisk bild så gör man ju en enda stor skrivning och sen kan rutinen börja om.
Genom att göra på mitt korkade sätt så skrivs först en "pil" ut, sen börjar rutinen om och skriver ut två pilar, börjar om och skriver ut 3 pilar. Så håller den på ända upp till 24 pilar. Det kanske är det här som gör det segt?

Ett alternativ kanske hade varit att låta hela skärmen representera en "bild" som man bit-vis manipulerar. Sen låter man skriva den här bilden om och om igen. Förstår ni vad jag menar?

Det är precis så jag försöker göra Glattnos men använder antagligen fel funktion/tillvägagångssätt...

EDIT: Nedan kod fungerar "klockrent", förutom att föregående pilar inte visas, utan enbart den pilen som senast trycktes på. Funktionen körs varje gång man trycker på en knapp.

Kod: Markera allt

void screenUpdate() {
     
       if(X_axis>=128){
          X_axis=0;
          Y_axis+=20;
            if(Y_axis>=60){
              Y_axis=0;
            }      
        }
      u8g.firstPage();
     
      switch(commands[commandCounter]){

        case 'F':       
        do {
        u8g.drawBitmapP( X_axis, Y_axis, 2, 20, arrow_up); }
        while(u8g.nextPage());
        X_axis+=16;
        break;
   
        case 'L':
        do {
        u8g.drawBitmapP( X_axis, Y_axis, 2, 20, arrow_left); }
        while(u8g.nextPage());
        X_axis+=16;      
        break;
 
        case 'R':
        do {
        u8g.drawBitmapP( X_axis, Y_axis, 2, 20, arrow_right); }
        while(u8g.nextPage());
        X_axis+=16;
        break;
 
      }
}

Din screenUpdate() skulle haft en if-sats i början som kollar om det finns något nytt tryck registrerat. Om nytt tryck - skriv ut rätt pil och flytta pekaren. Om inget nytt tryck - hoppa över resten av funktionen.

screenUpdate() behöver inte göra nått om inget nytt tryck finns, eftersom inget på skärmen ska ändras då.
Typ så

Vi menar samma sak, statisk som att den inte ändras hela tiden, som i en animation, att uppdatera hela bilden enstaka gånger per sekund är inga problem med en AVR.
Ett av problemen du nog har är att varje pil är 16pixlar hög (tror jag vi pratat om) och dessa displayer kan inte hoppa in och skriva mitt i en page (varje page är 8 pixlar hög).

Du minns min lilla Geocache? Den skrollar en 16pixlar hög text med uppdatering tiotalet bilder i sekunden.

Svenska ElektronikForumet

Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering

Re: Arduino robotprogrammering