Kalkulator ucznia na Pro Mini

[Leoneq]

Co może zrobić uczeń podstawówki, kiedy nie można w szkole używać telefonów? Specjalny kalkulator!

Tak, wiem że urządzenie jest trochę przekombinowane - za pare zł mam nowy kalkulator z kiosku, ale to nie jest zwykły kalkulator.Ten kalkulator, albowiem, robiłem ja 🙂

Budowa

Urządzenie posiada wyświetlacz TFT 1.8" ze slotem na kartę pamięci, z której możemy odtwarzać zdjęcia. Do wprowadzania informacji posłużyła mi klawiatura 4x4 w formie naklejki. Całość napędza Arduino Pro Mini, które przeprogramowałem na korzystanie z wewnętrznego kwarcu 8Mhz i wyłączenie BOD. Energię dostarcza akumulator Lipo wyjęty z tableta, ładowany przez dolutowanie się do akusa. Napięcie obniża stabilizator AMS1117 na 3,3v, co rozwiązało kwestię napięcia logiki (TFT ma 3.3v, arduino normalnie 5v) oraz zużycia energii. Wyświetlacz, do programowania, można zdejmować. Po prawej stronie dostrzegamy przełącznik włączający urządzenie, zaś pod TFT znajduje się przycisk funkcyjny. Obudowy nie chciałem robić, gdyż chciałem wzbudzić zainteresowanie wśród kolegów 🙂 

 

Funkcje

Kalkulator ma funkcję liczenia. Wow. Potrafi dzielić, mnożyć, dodawać i odejmować liczby dziesiętne, dodatnie i ujemne - ale nie umie wykonywać kolejności działań (dlatego według kalkulatora 2+2x2=8). ALE. Oprócz kalkulatora, utworzyłem aplikację paint - służy do malowania piksel po pikselu. Dobre na nudne lekcje polskiego. Po włączeniu urządzenia, wyświetla nam się lista dostępnych aplikacji. Oprócz niedokończonego snejka, jest jeszcze "czwarta aplikacja" - ściąga 😉 Wyświetla ona wzory z fizyki, chemii i matematyki oraz prawa dynamiki Newtona. Kalkulator może również w progmemie przechować jedno kolorowe zdjęcie, i wyświetlić je po 8x naciśnięciu przycisku Równa się. 

Taki kalkulator to fajna rzecz, z racji tego że można go używać w szkole bez ograniczeń i da się na nim pobawić. W ostateczności przeglądać memy, po włożeniu karty SD. 

Pozdrawiam,

Leoneq :3

Edytowano Styczeń 27, 2019 przez Leoneq

[Treker (Damian Szymański)]

//Wyciąłem kilka postów, które pojawiły się wyżej, gdy post był jeszcze ukryty. Dyskusja dotyczyła tego czy dobrze publikować opis kalkulatora, który błędnie liczy (bo nie uznaje kolejności działań).

@Leoneq, dzięki za opis projektu, doceniam ogólna koncepcję 🙂 Trochę podzielam zdanie Sabre tzn. uważam, że taki kalkulator powinien już jednak radzić sobie z kolejnością działań. Teraz trochę ciężko będzie go zakwalifikować jako pełnoprawne DIY - bardziej będzie pasował do DIY początkujący. Może jeszcze z tym "powalczysz"? Do tego bez filmiku/kodu nie wiadomo czy kalkulator faktycznie działa, bo równie dobrze mogą to byś teksty wyświetlane na ekranie 😉

[Leoneq]

W takim razie, popracuję jutro nad kodem (ale nic nie obiecuję), filmik też wrzucę. Rozumiem że mogą być podejrzenia o oszustwo - wkrótce je rozwieję 🙂 

[Leoneq]

No i cóż. Postanowiłem zrobić całość na ONP (odwrotna notacja polska), gdyż nic mi do głowy nie przychodziło jak zmodyfikować obecny kod. Kilka godzin grzebania w kodzie, by zrobić 2 funkcje: obliczanie wyrażeń zapisanych w ONP,  co mi się udało, oraz funkcja, która by przekształcała "zwykłe" wyrażenia na ONP. Tego niestety nie udało mi się dokończyć, mimo siedzenia cały dzień przy komputerze. Wysyłam kod całego kalkulatora (był on dawno pisany, więc troszkę mało optymalny jest), oraz kod niedziałającej funkcji. Jeżeli faktycznie projekt się nie zalicza do działu DIY, to proszę go opublikować w dziale DIY początkujący.

 

Kod kalkulatora:

#include <Keypad.h>
#include <Adafruit_GFX.h>
#include <Adafruit_ST7735.h>
#include <SPI.h>



#define TFT_CS 10
#define TFT_DC 9
#define TFT_RST -1

#define guzik A1

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);


const byte WIERSZE = 4;
const byte KOLUMNY = 4;

byte pinyWierszy[WIERSZE] = {A0, 2, 3, 4};
byte pinyKolumn[KOLUMNY] = {5, 6, 7, 8};
char klawisze[WIERSZE][KOLUMNY] = {
  {'1','2','3','x'},
  {'4','5','6','/'},
  {'7','8','9','+'},
  {'.','0','m','-'}
};
Keypad klawiatura = Keypad( makeKeymap(klawisze), pinyWierszy, pinyKolumn, WIERSZE, KOLUMNY );

char klawisz;
bool rownaSie = 0;



/***************************************************KLAWIATURA*/

long double a, b, c, d, e, f, g, h;
long double wynikA, wynikB, wynikC, wynikD, wynikE, wynikF, wynikG;
char znakA, znakB, znakC, znakD, znakE, znakF, znakG;
double wynik;
byte aktywnaZmienna = 1;
byte aktywnyZnaczek = 1;
byte stopienPrzecinka = 10;

byte liczbaErrorow = 0;

bool dot = false;
bool error;
bool gra;
bool check;
bool bol = true;
int timer;
int timerMem;

byte gameID = 0; //zadna apka nie jest wlaczona
/*
 * ID Gier:
 * 0 - nic: kosnolka
 * 1- kalkulator
 * 2 - paint
 * 3 - snake
 * 
 * 
 */


/***************************************************PAINT*/

byte kursorX;
byte kursorY;
word ostatniKolor;
word kolorTla;

String msg;


/***************************************************SNEJK*/

byte snejkX = 128 / 2 - 6;
byte snejkY = 160 / 2 - 6;
byte meatX, meatY;
byte xSkretow[12];
byte ySkretow[12];
byte trudnosc = 0;
int wynikSnejka = 0;
int kierunek = 0;  //0- gora 90- prawo 180- dol - 270 - lewo
bool snejk = false;


void setup()
{
  Serial.begin(9600);
  pinMode(guzik, INPUT_PULLUP);
  pinMode(13, OUTPUT);
  /*****************************************/
  tft.initR(INITR_BLACKTAB);
  tft.cp437(true);
  tft.setTextWrap(false);
  tft.fillScreen(ST7735_BLACK);
  tft.setRotation(3);
  delay(500);
  tft.setCursor(0, 0);
  tft.setTextColor(0x07E0);
  tft.setTextSize(1);
  tft.println("iNap MC BETA v1.1");
  tft.println("Ready.");
  tft.println("----------------------");
  tft.println("Please select app:");
  tft.println("1 - calculator");
  tft.println("2 - paint");
  tft.println("3 - snejk");
  check = true; //powzala sparwdzic gre
  randomSeed(analogRead(A0));
}

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

void loop()
{

  klawisz = klawiatura.getKey();
  rownaSie = digitalRead(guzik);
  Serial.println(kursorX);
  Serial.println(kursorY);
  if(klawisz)
  {
    if(check)
    {
      check = false;
      switch(klawisz)
      {
        case '1':                              // CALC
         gameID = 1;
         wyczysc();
         break;
        case '2':                            // PAINT
         gameID = 2;
         wyczysc();
         break;
        case '3':                            // SNAKE
         gameID = 3;
         wyczysc();
         break;
        case '4':
         gameID = 4;
         break;
       }
    }
    /*********************************************    WYBOR APKI  */


    switch(gameID)
    {
      case 1:
       if(klawisz == '/') tft.print(char(0xF6));
       else tft.print(klawisz);
       WprowadzZnak();
       break;
      case 2:
      switch(klawisz)
      {
        case '1':
         namaluj(1);
         break;
        case '2':
         namaluj(2);
         break;
        case '3':
         namaluj(3);
         break;
        case '4':
         namaluj(4);
         break;
        case '5':
         namaluj(5);
         break;
        case '6':
         namaluj(6);
         break;
        case '7':
         namaluj(7);
         break;
        case '8':
         namaluj(8);
         break;
        case '9':
         namaluj(9);
         break;
        case '.':
         namaluj(10);
         break;
        case '0':
         namaluj(11);
         break;
        case 'x':
         namaluj(12);
         break;
        case '/':
         tft.fillRect(kursorX, kursorY, 160, 3, ostatniKolor);
         break;
        case '+':
         namaluj(14);
         break;
        case '-':
         kursorX -= 3;
         tft.fillRect(kursorX, kursorY, 3, 3, kolorTla);
         break;
        case 'm':
         tft.fillScreen(ostatniKolor);
         kolorTla = ostatniKolor;
         tft.setCursor(0, 0);
         kursorX = 0;
         kursorY = 0;
         break;
      }
      break;

      case 3:
       switch(klawisz)
       {
        case '2':
         kierunek = 0;
         break;
        case '4':
         kierunek = 270;
         break;
        case '8':
         kierunek = 180;
         break;
        case '6':
         kierunek = 90;
         break;
       }
       
       
       break;

      case 4:
       tft.setFont();
       tft.fillScreen(ST7735_BLACK);
    tft.setCursor(0, 0);
    bol = false;
    tft.println("(Fizyka)"); //1
    tft.println("A oto magiczna sciaga:"); //1 
    tft.println("Ep = m x g x h"); //2
    tft.print("Ek = m x v");
    tft.print(char(0xFD));
    tft.println(" / 2"); //3
    tft.println("P = W / t"); //4 
    tft.println("Em = Ep + Ek"); //5 
    tft.print("Niuton = KG x m/s");
    tft.println(char(0xFD));//6
    tft.println("a = F / m"); //7
    tft.println("V = s / t");//8
    tft.println("I zas. dyn. N: jezeli Fwyp");//9
    tft.println("=0 to porusza sie lub nie");//10
    tft.println("II: jezeli Fwyp !=0 to");//11
    tft.println("porusza sie przyspieszonym");//12
    tft.println("III: sily sa w parze,");//13
    tft.println("sa przeciwne i F=F");//14
    tft.println("Za 20sek. dalej...");//15
    delay(15000);
    tft.fillScreen(ST7735_BLACK);
    tft.setCursor(0, 0);
    tft.println("(Chemia)");
    tft.println("Cp = Ms x 100% / Mr");
    tft.println("d(gest) = m / V(obj)");
    tft.println("Masa atomowa(u)=1/12masy C");
    tft.println("---------------------------");
      gameID = 1;
      break;
    }
  }
  
  if (rownaSie == false)
  {
    switch(gameID)
    {
      case 1:
       kalkuluj();
       if(error == false)
       {
       tft.println("=");
       tft.println(wynik);
       }
       wyzeruj();
       delay(250);
       break;
      case 2:
      tft.println("");
      kursorY += 3;
      kursorX = 0;
      delay(250);
      break;
     case 3:
      //CO JEZELI WCISNE GUZIK PRZY SNEJKU
      if(snejk == false) tft.println("snejk!");
      break;
    }
  }

  switch(gameID)
  {
    case 3:
     if(snejk)
     {
     ruch();
     rysujWeza();        
     delay(500);
     } else tft.println("TU BEDZIE SNEJK");
    break;
  }
}

void ruch()
{
  switch(kierunek)
  {
    case 0:
     snejkY -= 6;
     break;
    case 90:
     snejkX += 6;
     break;
    case 180:
     snejkY += 6;
     break;
    case 270:
     snejkX -= 6;
  }
}

void rysujWeza()
{
  switch(kierunek)
  {
    case 0:
     tft.writeFillRect(snejkX, snejkY, 6, 5, ST7735_GREEN);
     tft.writeFillRect(snejkX, snejkY + 5, 6, 1, ST7735_RED);
     tft.writeFillRect(snejkX, snejkY + 6, 6, 6, ST7735_BLACK);
     break;
    case 90:
     tft.writeFillRect(snejkX + 1, snejkY, 5, 6, ST7735_GREEN);
     tft.writeFillRect(snejkX, snejkY, 1, 6, ST7735_RED);
     tft.writeFillRect(snejkX - 6, snejkY, 6, 6, ST7735_BLACK);
     break;
    case 180:
     tft.writeFillRect(snejkX, snejkY , 6, 5, ST7735_GREEN);
     tft.writeFillRect(snejkX, snejkY - 1, 6, 1, ST7735_RED);
     tft.writeFillRect(snejkX, snejkY - 7, 6, 6, ST7735_BLACK);
     break;
    case 270:
     tft.writeFillRect(snejkX, snejkY, 5, 6, ST7735_GREEN);
     tft.writeFillRect(snejkX + 5, snejkY, 1, 6, ST7735_RED);
     tft.writeFillRect(snejkX + 6, snejkY, 6, 6, ST7735_BLACK);
     break;
  }
}
/*****************************************/
/*
 * 1-Red
 * 2-Green
 * 3Blue
 * 4-Cyan
 * 5-Magenta
 * 7-White
 * 8-Lt Gray
 * 9-Dk Gray
 * dot - purple
 * x - orange
 * / - Brown
 * + - black
 * - - sandy
 */
void namaluj(byte kolor)
{
   switch(kolor)
   {
   case 1:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xF800);
    ostatniKolor = 0xF800;
    kursorX += 3;
    break;
   case 2:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x07E0);
    ostatniKolor = 0x07E0;
    kursorX += 3;
    break;
   case 3:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x001F);
    ostatniKolor = 0x001F;
    kursorX += 3;
    break;
   case 4:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x07FF);
    ostatniKolor = 0x07FF;
    kursorX += 3;
    break;
   case 5:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xF81F);
    ostatniKolor = 0xF81F;
    kursorX += 3;
    break;
   case 6:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xFFe0);
    ostatniKolor = 0xFFE0;
    kursorX += 3;
    break;
   case 7:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xFFFF);
    ostatniKolor = 0xFFFF;
    kursorX += 3;
    break;
   case 8:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x73AE);
    ostatniKolor = 0x73AE;
    kursorX += 3;
    break;
   case 9:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x52AA);
    ostatniKolor = 0x52AA;
    kursorX += 3;
    break;
   case 10:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xFDDA);
    ostatniKolor = 0xFDDA;
    kursorX += 3;
    break;
   case 11:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xFA60);
    ostatniKolor = 0xFA60;
    kursorX += 3;
    break;
   case 12:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x6204);
    ostatniKolor = 0x6204;
    kursorX += 3;
    break;
   case 13:
    tft.fillRect(kursorX, kursorY, 3, 3, 0xFF59);
    ostatniKolor = 0xFF59;
    kursorX += 3;
    break;
   case 14:
    tft.fillRect(kursorX, kursorY, 3, 3, 0x0000);
    ostatniKolor = 0x0000;
    kursorX += 3;
    break;
   }
}

void kalkuluj()
{

  if(error) 
  {
    wynik = 0.00;
    tft.println("");
    tft.println("ERROR");
  }
  switch(znakA)
  {
    case '*':
     wynik = a * b;
     break;
    case '/':
     wynik = a / b;
     break;
    case '+':
     wynik = a + b;
     break;
    case '-':
     wynik = a - b;
     break;  
  } wynikA = wynik;
  switch(znakB)
  {
    case '*':
     wynik = wynikA * c;
     break;
    case '/':
     wynik = wynikA / c;
     break;
    case '+':
     wynik = wynikA + c;
     break;
    case '-':
     wynik = wynikA - c;
     break;  
  } wynikB = wynik;
   switch(znakC)
  {
    case '*':
     wynik = wynikB * d;
     break;
    case '/':
     wynik = wynikB / d;
     break;
    case '+':
     wynik = wynikB + d;
     break;
    case '-':
     wynik = wynikB - d;
     break;  
  } wynikC = wynik;
   switch(znakD)
  {
    case '*':
     wynik = wynikC * e;
     break;
    case '/':
     wynik = wynikC / e;
     break;
    case '+':
     wynik = wynikC + e;
     break;
    case '-':
     wynik = wynikC - e;
     break;  
  } wynikD = wynik;
   switch(znakE)
  {
    case '*':
     wynik = wynikD * f;
     break;
    case '/':
     wynik = wynikD / f;
     break;
    case '+':
     wynik = wynikD + f;
     break;
    case '-':
     wynik = wynikD - f;
     break;  
  } wynikE = wynik;
   switch(znakF)
  {
    case '*':
     wynik = wynikE * g;
     break;
    case '/':
     wynik = wynikE / g;
     break;
    case '+':
     wynik = wynikE + g;
     break;
    case '-':
     wynik = wynikE - g;
     break;  
  } wynikF = wynik;
   switch(znakG)
  {
    case '*':
     wynik = wynikF * h;
     break;
    case '/':
     wynik = wynikF / h;
     break;
    case '+':
     wynik = wynikF + h;
     break;
    case '-':
     wynik = wynikF - h;
     break;  
  }
  

  if(aktywnyZnaczek >= 8) aktywnyZnaczek = 1;
  if(aktywnaZmienna >= 9) aktywnaZmienna = 1;

}

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

void WprowadzZnak()
{
  
  switch(klawisz) {
    case '1':
      dolaczCyfre(1);
      break;
    case '2':
      dolaczCyfre(2);
      break;
    case '3':
      dolaczCyfre(3);
      break;
    case '4':
      dolaczCyfre(4);
      break;
    case '5':
      dolaczCyfre(5);
      break;
    case '6':
      dolaczCyfre(6);
      break;
    case '7':
      dolaczCyfre(7);
      break;
    case '8':
      dolaczCyfre(8);
      break;
    case '9':
      dolaczCyfre(9);
      break;
    case '0':
      dolaczCyfre(0);
      break;
    case 'x':
     aktywnyZnak('*');
     if(aktywnaZmienna <= 8) aktywnaZmienna++;
     error = true;
     break;
    case '/':
      aktywnyZnak('/');
      if(aktywnaZmienna <= 8) aktywnaZmienna++;
       error = true;
     break;
    case '+':
      aktywnyZnak('+');
     if(aktywnaZmienna <= 8) aktywnaZmienna++;
     error = true;
     break;
    case '-':
     aktywnyZnak('-');
     if(aktywnaZmienna <= 8) aktywnaZmienna++;
     error = true;
     break;
    case 'm':
     tft.fillScreen(ST7735_BLACK);
     tft.setCursor(0, 0);
     tft.println("");
     
     switch(byte kolorek = random(7))
     {
      case 0:
       tft.setTextColor(ST7735_RED);
       break;
      case 1:
       tft.setTextColor(ST7735_BLUE);
       break;
      case 2:
       tft.setTextColor(ST7735_GREEN);
       break;
      case 3:
       tft.setTextColor(ST7735_CYAN);
       break;
      case 4:
       tft.setTextColor(ST7735_MAGENTA);
       break;
      case 5:
       tft.setTextColor(ST7735_YELLOW);
       break;
      case 6:
       tft.setTextColor(ST7735_WHITE);
       break;
     }
     wyzeruj();
     break;
    case '.':
     dot = true;
     break;
  }
  
}

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

void aktywnyZnak(char znak)
{
  stopienPrzecinka = 10;
  dot = false;
  
  switch(aktywnyZnaczek)
  {
    case 1:
     znakA = znak;
     aktywnyZnaczek++;
     break;
    case 2:
     znakB = znak;
     aktywnyZnaczek++;
     break;
    case 3:
     znakC = znak;
     aktywnyZnaczek++;
     break;

    case 4:
     znakD = znak;
     aktywnyZnaczek++;
     break;
    case 5:
     znakE = znak;
     aktywnyZnaczek++;
     break;
    case 6:
     znakF = znak;
     aktywnyZnaczek++;
     break;
    case 7:
     znakG = znak;
     aktywnyZnaczek++;
     break;
    case 8:
     error = true;
     kalkuluj();
     break;
  }
}

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

void wyzeruj()
{
  wynik = 0;
  wynikA = 0;
  wynikB = 0;
  wynikC = 0;
  wynikD = 0;
  wynikE = 0;
  wynikF = 0;
  wynikG = 0;
  a = 0;
  b = 0;
  c = 0;
  d = 0;
  e = 0; 
  f = 0;
  g = 0;
  h = 0;
  znakA = 0;
  znakB = 0;
  znakC = 0;
  znakD = 0;
  znakE = 0; 
  znakF = 0;
  znakG = 0;
  stopienPrzecinka = 10;
  aktywnaZmienna = 1;
  aktywnyZnaczek = 1;
  error = false;
  dot = false;;
}

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

void przecinkuj()
{
  switch(stopienPrzecinka)
  {
    case 10:
      stopienPrzecinka = 100;
      break;
    case 100:
      stopienPrzecinka = 1000;
      break;
    case 1000:
      stopienPrzecinka = 10000;
      break;
    case 10000:
      error = true;
      kalkuluj();
      break;
  }
}

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

void dolaczCyfre(double cyfra)
{
  error = false; 
  switch(aktywnaZmienna)
  {
  
   case 1:
    if(dot)
    {
    a = a + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else a = (a*10) + cyfra;
    break;
   /*****************************************/
   case 2:
    if(dot)
    {
    b = b + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else b = (b*10) + cyfra;
    break;
    /*****************************************/
   case 3:
    if(dot)
    {
    c = c + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else c = (c*10) + cyfra;
    break;
    /*****************************************/
   case 4:
    if(dot)
    {
    d = d + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else d = (d*10) + cyfra;
    break;
    /*****************************************/
   case 5:
    if(dot)
    {
    e = e + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else e = (e*10) + cyfra;
    break;
    /*****************************************/
   case 6:
    if(dot)
    {
    f = f + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else f = (f*10) + cyfra;
    break;
    /*****************************************/
   case 7:
    if(dot)
    {
    g = g + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else g = (g*10) + cyfra;
    break;
    /*****************************************/
   case 8:
    if(dot)
    {
    h = h + (cyfra / stopienPrzecinka);
    przecinkuj();
    } else h = (h*10) + cyfra;
    break;
  }
}

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

void wyczysc()
{
  tft.fillScreen(0x0000);
  tft.setCursor(0, 0);
}

 

Kod funkcji:

//funkcje sciagnijDzi, polozDzi odnoszą się do stosu wejściowego funkcji,
//podobnie jest z polozWej, czyli stosu wyjścia,
// i polozOp - stos z operatorami

void przeksztalcRPN()
{
  for(byte A = 1; A <= 11; A++)
  {
    String znak = sciagnijDzi(); 
        
    if(znak == "+" || znak == "-" || znak == "/" || znak == "x")
    {
         ify:
         String op1 = znak;
         String op2 = sciagnijOp();
         bool p1, p2;
         if(op1 == "+" || op1 == "-") p1 = 0;
         else p1 = 1;
         if(op2 == "+" || op2 == "-") p2 = 0;
         else p2 = 1;
         if(op2 == 0)
         {
          polozOp(op2);
          goto op;
         }
         if(p1 <= p2)
         {
          polozWej(op2);
          
          goto ify;
         }
         op:
         polozOp(znak);
       }
    else
    {
      polozWej(znak);
    }
    
  }
  polozWej(sciagnijOp());
//wynik jest w stosie "wejscie"
}

 

[Polecacz 101]

Produkcja i montaż PCB - wybierz sprawdzone PCBWay!
   • Darmowe płytki dla studentów i projektów non-profit
   • Tylko 5$ za 10 prototypów PCB w 24 godziny
   • Usługa projektowania PCB na zlecenie
   • Montaż PCB od 30$ + bezpłatna dostawa i szablony
   • Darmowe narzędzie do podglądu plików Gerber
Zobacz również » Film z fabryki PCBWay

[Treker (Damian Szymański)]

W takim razie, zgodnie z prośbą, przenoszę artykuł do innego działu. Może w takim razie uda się rozwiązać Twój problem? Na czym dokładnie utknąłeś? 😉

[Leoneq]

Gdzieś musi być błąd w algorytmie - lecz powinien dokładne robić to, co jest na wikipedii. Dlatego, zamiast przekształcić 2+2*2 na 22*2+, wypluwa mi 22  x 2     x. W kod wpatrywałem się dłuuugo, i nie mogę znaleźć błędu (może to coś na wikipedii jest nie tak?) Jeżeli z tym sobie poradzę, resztę powinienem już dokończyć szybko.

[deshipu]

To może zamiast się wpatrywać po prostu wypiszesz sobie zawartość wszystkich stosów i zmiennych w każdym kroku? To powinno ci ułatwić zrozumienie co jest nie tak.

[narbej]

Jak dla mnie, to jest najlepszy pomysł i opis projektu. Opis projektu i do czego służy - pełny szacun i dostałeś z mojej strony malutki serduszko.

Jeżeli chodzi o opis algorytmu na wikipedii - czy chodzi Ci o ten--> https://pl.wikipedia.org/wiki/Odwrotna_notacja_polska ?

Więc tam opisane są dwa  i w kilku wariantach [rekurencyjnie i "normalnie]. Więc mimo, że nie potrafię zrozumieć twojego algo, pomijając, że pomijasz z oczywistych powodów nawiasy, to i tak brawo, za własną interpretacje i za użycie niespotykanej instrukcji goto.

Brawo i gratuluję! 

[Leoneq]

@deshipu, właśni tak zrobiłem, dlatego na wyjściu podałem spacje - algorytm wykonuje za dużo operacji na operatorach, których jest 2.

@narbej, dziękuję za miłe słowa 🙂 algorytm opisany wyżej jest właśnie moją nieudolną próbą adaptacji algorytmu z wikipedii do Arduino.

[narbej]

Kilka pytań.

1. Po ewentualnej poprawnej konwersji na zapis ONP [RPN reverse Polish notation], twój kalkulator powinien obliczyć to wyrażenie. Może więc, na razie, powinieneś pominąć moduł konwersji, a skupić się na obliczaniu wyrażeń ONP. Twój kalkulator stanie się bardziej tajemniczy i to Ty będziesz od razu podawał mu do obliczeń odpowiednie argumenty, "ręcznie" przerobione w twoim umyśle na RPN. Czyli jak chcesz obliczyć 2+2*2, to podajesz mu [kalkulatorowi 😉] 2 2 * 2 + =
2. Tak z czystej ciekawości, do której klasy chodzisz, lub wprost, ile masz lat, oczywiście nie musisz odpowiadać na oba ani na żadne.
3. Nie myślałeś? Jednak powinieneś pomyśleć o jakiejś obudowie zabezpieczającej. Twój kalkulator stanie się jeszcze bardziej tajemniczy, a zawsze dla zainteresowanego/j kolegi/koleżanki, możesz go rozebrać i pokazać co jest w środku.

[Leoneq]

1. To już zrobiłem - kalkulator poprawnie liczy w ONP (albo miałem szczęście, ale wyszło 40 jak w wikipedii)

2. Chodzę do 8 klasy podstawówki, mam prawie 15 lat. Chyba widać to po jakości projektów 😉 

3. Właśnie widząc "gołą" elektronikę moi koledzy myśleli że bombe przyniosłem, czyli efekt jest.

Zresztą, jak znajdę chwilkę czasu to spróbuję zaimplementować funkcję do obliczania ONP.

[marek1707]

Z konwerterem notacji możesz powalczyć - to dobre ćwiczenie, ale ja przychylam się do pomysłu zostawienia wersji liczącej wyłącznie w RPN. Było przecież sporo takich konstrukcji, a niektóre osiągnęły status maszyn kultowych. Myślę tu m.in. o serii produktów firmy Hewlett-Packard a przede wszystkim jej słynnym HP-35 z lat siedemdziesiątych, który był w kosmosie i na biurkach chyba wszystkich znaczących ówcześnie naukowców, a dzisiaj jest rarytasem dla zbieraczy:

https://en.wikipedia.org/wiki/HP_calculators

https://techcrunch.com/2009/04/14/the-hp-34-the-most-important-reverse-polish-notation-calculator-in-the-world/?guccounter=1

Powstała też wersja HP-35s na.. 35 urodziny oryginalnej trzydziestkipiątki 🙂 Oprócz uproszczenia samych obliczeń (i sprzętowej konstrukcji kalkulatora - choć to nie ten przypadek bo masz tu uniwersalny procesor), RPN upraszacza także analizę wejścia z klawiatury. Argumenty są jednoznacznie zakończone przyciskiem "STO" (od "Store") i nie trzeba robić automatu interpretującego poszczególne naciśnięcia.

Wyobrażasz sobie zdziwienie ludzi, gdy nie znajdują klawisza "="? Zamiast tego jest jakieś dziwne  "STO" lub "Enter".. Przy odrobinie wprawy liczysz na tym tak jak na zwykłym "kalkulatorze dla szaraków" a z zewnątrz wygląda to jak magia. A z tą bombą to nie przesadzaj, dziś to już nie jest śmieszne skojarzenie. Już samo to, że robisz programowalną elektronikę pod koniec podstawówki jest fantastyczne, szacun. 

BTW: Czasem warto zaglądać na "kamień z Rostetty". Tu masz np. konwertery RPN w 33 językach.. 

https://rosettacode.org/wiki/Parsing/RPN_to_infix_conversion

[Leoneq]

@marek1707, dziękuję 🙂 Myślę, że kiedy ogarnę wprowadzanie danych do RPN, trochę przeedytuję post (urządzenie dość dużo zmienia działanie). Co do strony rosetty, już sam to wygooglowałem, ale nie lubię gotowców. Wolę sam rozumieć co napiszę. 

[narbej]

27 minut temu, marek1707 napisał:

RPN_to_infix_conversion

Tutaj raczej chodziło o konwersję w drugą stronę ....

Warto zauważyć, że wśród różnych wersji kalkulatorów HP, były jedne z, albo nawet pierwsze kalkulatory programowalne. A takiego kalkulatora, RPN i programowalnego, już za parę złotych w kiosku nie kupisz. A twój przecież taki jest. Możesz np dodać funkcje obliczającą pole i obwód, dla danej średnicy/promienia, obliczający pierwiastki równania kwadratowego itd - nie jestem na bieżąco z programem szkoły podst, córki już dawno po studiach, a wnuków jeszcze brak.

No i zamiast nad konwerterem, walcz np ze ściągawką. Ona służyć może, jeżeli jest dobrze napisana, także do utrwalania i porządkowania wiedzy, a nie do ściągania. Co jak te forum przeglądają twoi nauczyciele 😉

8 minut temu, Leoneq napisał:

Wolę sam rozumieć co napiszę. 

Brawo i tak trzymaj!!

Edytowano Styczeń 29, 2019 przez narbej

[Leoneq]

1. Nauczyciele nie przeglądają bo po co, wolą pić kawę

2. Co do programu nauczania - kiedy ja ogarniam sobie z kolegą arduino, STM32 czy Raspberry i stawiamy serwer WWW, cała klasa maluje kolejną laurkę w Paincie 🙂 8 klasa 🙂 

Z matematyki, przejrzałem sobie, pół książki to tw. pitagorasa, 1/4 to zadania procentowe i z treścią, reszta to geometria (koła to tylko pole, promień, obwód).