Skocz do zawartości

Pomocna odpowiedź

//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 😉

  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites

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"
}

 

  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites

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ś? 😉

  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites

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.

Udostępnij ten post


Link to post
Share on other sites

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.

  • Lubię! 2

Udostępnij ten post


Link to post
Share on other sites

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ę! 

  • Lubię! 2

Udostępnij ten post


Link to post
Share on other sites

@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.

Udostępnij ten post


Link to post
Share on other sites

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.
  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites

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.

  • Lubię! 2

Udostępnij ten post


Link to post
Share on other sites

@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ę. 

  • Lubię! 1

Udostępnij ten post


Link to post
Share on other sites
(edytowany)
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 przez narbej
  • Lubię! 2

Udostępnij ten post


Link to post
Share on other sites

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). 

  • Lubię! 2

Udostępnij ten post


Link to post
Share on other sites

Dołącz do dyskusji, napisz odpowiedź!

Jeśli masz już konto to zaloguj się teraz, aby opublikować wiadomość jako Ty. Możesz też napisać teraz i zarejestrować się później.
Uwaga: wgrywanie zdjęć i załączników dostępne jest po zalogowaniu!

Gość
Dołącz do dyskusji! Kliknij i zacznij pisać...

×   Wklejony jako tekst z formatowaniem.   Przywróć formatowanie

  Dozwolonych jest tylko 75 emoji.

×   Twój link będzie automatycznie osadzony.   Wyświetlać jako link

×   Twoja poprzednia zawartość została przywrócona.   Wyczyść edytor

×   Nie możesz wkleić zdjęć bezpośrednio. Prześlij lub wstaw obrazy z adresu URL.


×
×
  • Utwórz nowe...