Przetłumaczenie kodu z C na Delphi

Odpowiedz Nowy wątek
2017-05-30 09:01

Rejestracja: 6 lat temu

Ostatnio: 6 miesięcy temu

0

Witam,

mam prośbę - czy byłby ktoś na tyle miły i przetłumaczył poniższy kod z C na Delphi? Jako że dość dobrze rozumiem Delphi natomiast C znam tylko w podstawach, pragnę zrozumieć całość kodu. Sam kod dotyczy sterowania wyświetlaczami diodowymi za pomoca Arduino (moje nowe hobby :)) Z góry ślicznie dziękuję za pomoc!

#include <LedControl.h>

int DIN = 12;
int CS =  11;
int CLK = 10;
int ilosc_ekranow = 2;
String tekscik = "PRZYKLADOWY TEKST: WWW.ABC-RC.PL";

byte ascii_table[130][8];
LedControl lc=LedControl(DIN,CLK,CS,0);

void wypelnij()
{
ascii_table[32][0]=B00000000;
ascii_table[32][1]=B00000000;
ascii_table[32][2]=B00000000;
ascii_table[32][3]=B00000000;
ascii_table[32][4]=B00000000;
ascii_table[32][7]=5;

ascii_table[33][0]=B00000000;
ascii_table[33][1]=B01011111;
ascii_table[33][2]=B00000000;
ascii_table[33][7]=3;

ascii_table[34][0]=B00000000;
ascii_table[34][1]=B00001110;
ascii_table[34][2]=B00000000;
ascii_table[34][3]=B00001110;
ascii_table[34][4]=B00000000;
ascii_table[34][7]=5;

ascii_table[35][0]=B00000000;
ascii_table[35][1]=B00010100;
ascii_table[35][2]=B01111111;
ascii_table[35][3]=B00010100;
ascii_table[35][4]=B01111111;
ascii_table[35][5]=B00010100;
ascii_table[35][6]=B00000000;
ascii_table[35][7]=7;

ascii_table[36][0]=B00000000;
ascii_table[36][1]=B00100100;
ascii_table[36][2]=B00101010;
ascii_table[36][3]=B01111111;
ascii_table[36][4]=B00101010;
ascii_table[36][5]=B00100100;
ascii_table[36][6]=B00000000;
ascii_table[36][7]=7;

ascii_table[37][0]=B00000000;
ascii_table[37][1]=B01100010;
ascii_table[37][2]=B01100100;
ascii_table[37][3]=B00001000;
ascii_table[37][4]=B00010011;
ascii_table[37][5]=B00100011;
ascii_table[37][6]=B00000000;
ascii_table[37][7]=7;

ascii_table[38][0]=B00000000;
ascii_table[38][1]=B01010000;
ascii_table[38][2]=B00100010;
ascii_table[38][3]=B01010101;
ascii_table[38][4]=B01001001;
ascii_table[38][5]=B00110110;
ascii_table[38][6]=B00000000;
ascii_table[38][7]=7;

ascii_table[39][0]=B00000000;
ascii_table[39][1]=B00000011;
ascii_table[39][2]=B00000101;
ascii_table[39][3]=B00000000;
ascii_table[39][7]=4;

ascii_table[40][0]=B00000000;
ascii_table[40][1]=B01000001;
ascii_table[40][2]=B00100010;
ascii_table[40][3]=B00011100;
ascii_table[40][4]=B00000000;
ascii_table[40][7]=5;

ascii_table[41][0]=B00000000;
ascii_table[41][1]=B00011100;
ascii_table[41][2]=B00100010;
ascii_table[41][3]=B01000001;
ascii_table[41][4]=B00000000;
ascii_table[41][7]=5;

ascii_table[42][0]=B00000000;
ascii_table[42][1]=B00010100;
ascii_table[42][2]=B00001000;
ascii_table[42][3]=B00111110;
ascii_table[42][4]=B00001000;
ascii_table[42][5]=B00010100;
ascii_table[42][6]=B00000000;
ascii_table[42][7]=7;

ascii_table[43][0]=B00000000;
ascii_table[43][1]=B00001000;
ascii_table[43][2]=B00001000;
ascii_table[43][3]=B00111110;
ascii_table[43][4]=B00001000;
ascii_table[43][5]=B00001000;
ascii_table[43][6]=B00000000;
ascii_table[43][7]=7;

ascii_table[44][0]=B00000000;
ascii_table[44][1]=B00110000;
ascii_table[44][2]=B01010000;
ascii_table[44][3]=B00000000;
ascii_table[44][7]=4;

ascii_table[45][0]=B00000000;
ascii_table[45][1]=B00001000;
ascii_table[45][2]=B00001000;
ascii_table[45][3]=B00001000;
ascii_table[45][4]=B00001000;
ascii_table[45][5]=B00000000;
ascii_table[45][7]=6;

ascii_table[46][0]=B00000000;
ascii_table[46][1]=B01100000;
ascii_table[46][2]=B01100000;
ascii_table[46][3]=B00000000;
ascii_table[46][7]=4;

ascii_table[47][0]=B00000000;
ascii_table[47][1]=B00000010;
ascii_table[47][2]=B00000100;
ascii_table[47][3]=B00001000;
ascii_table[47][4]=B00010000;
ascii_table[47][5]=B00100000;
ascii_table[47][6]=B00000000;
ascii_table[47][7]=7;

ascii_table[48][0]=B00000000;
ascii_table[48][1]=B00111110;
ascii_table[48][2]=B01000001;
ascii_table[48][3]=B01000001;
ascii_table[48][4]=B00111110;
ascii_table[48][5]=B00000000;
ascii_table[48][7]=6;

ascii_table[49][0]=B00000000;
ascii_table[49][1]=B01000000;
ascii_table[49][2]=B01111111;
ascii_table[49][3]=B01000010;
ascii_table[49][4]=B00000000;
ascii_table[49][7]=5;

ascii_table[50][0]=B00000000;
ascii_table[50][1]=B01000110;
ascii_table[50][2]=B01001001;
ascii_table[50][3]=B01010001;
ascii_table[50][4]=B01100011;
ascii_table[50][5]=B01000010;
ascii_table[50][6]=B00000000;
ascii_table[50][7]=7;

ascii_table[51][0]=B00000000;
ascii_table[51][1]=B00110001;
ascii_table[51][2]=B01001011;
ascii_table[51][3]=B01000101;
ascii_table[51][4]=B01000001;
ascii_table[51][5]=B00100001;
ascii_table[51][6]=B00000000;
ascii_table[51][7]=7;

ascii_table[52][0]=B00000000;
ascii_table[52][1]=B00010000;
ascii_table[52][2]=B01111111;
ascii_table[52][3]=B00010010;
ascii_table[52][4]=B00010100;
ascii_table[52][5]=B00011000;
ascii_table[52][6]=B00000000;
ascii_table[52][7]=7;

ascii_table[53][0]=B00000000;
ascii_table[53][1]=B00111001;
ascii_table[53][2]=B01000101;
ascii_table[53][3]=B01000101;
ascii_table[53][4]=B01000101;
ascii_table[53][5]=B00100111;
ascii_table[53][6]=B00000000;
ascii_table[53][7]=7;

ascii_table[54][0]=B00000000;
ascii_table[54][1]=B00110000;
ascii_table[54][2]=B01001001;
ascii_table[54][3]=B01001001;
ascii_table[54][4]=B01001010;
ascii_table[54][5]=B00111100;
ascii_table[54][6]=B00000000;
ascii_table[54][7]=7;

ascii_table[55][0]=B00000000;
ascii_table[55][1]=B00000111;
ascii_table[55][2]=B00001001;
ascii_table[55][3]=B01110001;
ascii_table[55][4]=B00000001;
ascii_table[55][5]=B00000011;
ascii_table[55][6]=B00000000;
ascii_table[55][7]=7;

ascii_table[56][0]=B00000000;
ascii_table[56][1]=B00110110;
ascii_table[56][2]=B01001001;
ascii_table[56][3]=B01001001;
ascii_table[56][4]=B01001001;
ascii_table[56][5]=B00110110;
ascii_table[56][6]=B00000000;
ascii_table[56][7]=7;

ascii_table[57][0]=B00000000;
ascii_table[57][1]=B00011110;
ascii_table[57][2]=B00101001;
ascii_table[57][3]=B01001001;
ascii_table[57][4]=B01001001;
ascii_table[57][5]=B00000110;
ascii_table[57][6]=B00000000;
ascii_table[57][7]=7;

ascii_table[58][0]=B00000000;
ascii_table[58][1]=B00110110;
ascii_table[58][2]=B00110110;
ascii_table[58][3]=B00000000;
ascii_table[58][7]=4;

ascii_table[59][0]=B00000000;
ascii_table[59][1]=B00110110;
ascii_table[59][2]=B01010110;
ascii_table[59][3]=B00000000;
ascii_table[59][7]=4;

ascii_table[60][0]=B00000000;
ascii_table[60][1]=B01000001;
ascii_table[60][2]=B00100010;
ascii_table[60][3]=B00010100;
ascii_table[60][4]=B00001000;
ascii_table[60][5]=B00000000;
ascii_table[60][7]=6;

ascii_table[61][0]=B00000000;
ascii_table[61][1]=B00010100;
ascii_table[61][2]=B00010100;
ascii_table[61][3]=B00010100;
ascii_table[61][4]=B00010100;
ascii_table[61][5]=B00010100;
ascii_table[61][6]=B00000000;
ascii_table[61][7]=7;

ascii_table[62][0]=B00000000;
ascii_table[62][1]=B00001000;
ascii_table[62][2]=B00010100;
ascii_table[62][3]=B00100010;
ascii_table[62][4]=B01000001;
ascii_table[62][5]=B00000000;
ascii_table[62][7]=6;

ascii_table[63][0]=B00000000;
ascii_table[63][1]=B00000110;
ascii_table[63][2]=B00001001;
ascii_table[63][3]=B01010001;
ascii_table[63][4]=B00000001;
ascii_table[63][5]=B00000010;
ascii_table[63][6]=B00000000;
ascii_table[63][7]=7;

ascii_table[64][0]=B00000000;
ascii_table[64][1]=B00111110;
ascii_table[64][2]=B01000001;
ascii_table[64][3]=B01111001;
ascii_table[64][4]=B01001001;
ascii_table[64][5]=B00110010;
ascii_table[64][6]=B00000000;
ascii_table[64][7]=7;

ascii_table[65][0]=B00000000;
ascii_table[65][1]=B01111110;
ascii_table[65][2]=B00010001;
ascii_table[65][3]=B00010001;
ascii_table[65][4]=B00010001;
ascii_table[65][5]=B01111110;
ascii_table[65][6]=B00000000;
ascii_table[65][7]=7;

ascii_table[66][0]=B00000000;
ascii_table[66][1]=B00110110;
ascii_table[66][2]=B01001001;
ascii_table[66][3]=B01001001;
ascii_table[66][4]=B01001001;
ascii_table[66][5]=B01111111;
ascii_table[66][6]=B00000000;
ascii_table[66][7]=7;

ascii_table[67][0]=B00000000;
ascii_table[67][1]=B00100010;
ascii_table[67][2]=B01000001;
ascii_table[67][3]=B01000001;
ascii_table[67][4]=B01000001;
ascii_table[67][5]=B00111110;
ascii_table[67][6]=B00000000;
ascii_table[67][7]=7;

ascii_table[68][0]=B00000000;
ascii_table[68][1]=B00011100;
ascii_table[68][2]=B00100010;
ascii_table[68][3]=B01000001;
ascii_table[68][4]=B01000001;
ascii_table[68][5]=B01111111;
ascii_table[68][6]=B00000000;
ascii_table[68][7]=7;

ascii_table[69][0]=B00000000;
ascii_table[69][1]=B01000001;
ascii_table[69][2]=B01001001;
ascii_table[69][3]=B01001001;
ascii_table[69][4]=B01111111;
ascii_table[69][5]=B00000000;
ascii_table[69][7]=6;

ascii_table[70][0]=B00000000;
ascii_table[70][1]=B00000001;
ascii_table[70][2]=B00001001;
ascii_table[70][3]=B00001001;
ascii_table[70][4]=B01111111;
ascii_table[70][5]=B00000000;
ascii_table[70][7]=6;

ascii_table[71][0]=B00000000;
ascii_table[71][1]=B01111010;
ascii_table[71][2]=B01001001;
ascii_table[71][3]=B01001001;
ascii_table[71][4]=B01000001;
ascii_table[71][5]=B00111110;
ascii_table[71][6]=B00000000;
ascii_table[71][7]=7;

ascii_table[72][0]=B00000000;
ascii_table[72][1]=B01111111;
ascii_table[72][2]=B00001000;
ascii_table[72][3]=B00001000;
ascii_table[72][4]=B01111111;
ascii_table[72][5]=B00000000;
ascii_table[72][7]=6;

ascii_table[73][0]=B00000000;
ascii_table[73][1]=B01000001;
ascii_table[73][2]=B01111111;
ascii_table[73][3]=B01000001;
ascii_table[73][4]=B00000000;
ascii_table[73][7]=5;

ascii_table[74][0]=B00000000;
ascii_table[74][1]=B00000001;
ascii_table[74][2]=B01111111;
ascii_table[74][3]=B01000001;
ascii_table[74][4]=B01000000;
ascii_table[74][5]=B00100000;
ascii_table[74][6]=B00000000;
ascii_table[74][7]=7;

ascii_table[75][0]=B00000000;
ascii_table[75][1]=B01000001;
ascii_table[75][2]=B00100010;
ascii_table[75][3]=B00010100;
ascii_table[75][4]=B00001000;
ascii_table[75][5]=B01111111;
ascii_table[75][6]=B00000000;
ascii_table[75][7]=7;

ascii_table[76][0]=B00000000;
ascii_table[76][1]=B01000000;
ascii_table[76][2]=B01000000;
ascii_table[76][3]=B01000000;
ascii_table[76][4]=B01111111;
ascii_table[76][5]=B00000000;
ascii_table[76][7]=6;

ascii_table[77][0]=B00000000;
ascii_table[77][1]=B01111111;
ascii_table[77][2]=B00000010;
ascii_table[77][3]=B00001100;
ascii_table[77][4]=B00000010;
ascii_table[77][5]=B01111111;
ascii_table[77][6]=B00000000;
ascii_table[77][7]=7;

ascii_table[78][0]=B00000000;
ascii_table[78][1]=B01111111;
ascii_table[78][2]=B00010000;
ascii_table[78][3]=B00001000;
ascii_table[78][4]=B00000100;
ascii_table[78][5]=B01111111;
ascii_table[78][6]=B00000000;
ascii_table[78][7]=7;

ascii_table[79][0]=B00000000;
ascii_table[79][1]=B00111110;
ascii_table[79][2]=B01000001;
ascii_table[79][3]=B01000001;
ascii_table[79][4]=B01000001;
ascii_table[79][5]=B00111110;
ascii_table[79][6]=B00000000;
ascii_table[79][7]=7;

ascii_table[80][0]=B00000000;
ascii_table[80][1]=B00000110;
ascii_table[80][2]=B00001001;
ascii_table[80][3]=B00001001;
ascii_table[80][4]=B00001001;
ascii_table[80][5]=B01111111;
ascii_table[80][6]=B00000000;
ascii_table[80][7]=7;

ascii_table[81][0]=B00000000;
ascii_table[81][1]=B01011110;
ascii_table[81][2]=B00100001;
ascii_table[81][3]=B01010001;
ascii_table[81][4]=B01000001;
ascii_table[81][5]=B00111110;
ascii_table[81][6]=B00000000;
ascii_table[81][7]=7;

ascii_table[82][0]=B00000000;
ascii_table[82][1]=B01000110;
ascii_table[82][2]=B00101001;
ascii_table[82][3]=B00011001;
ascii_table[82][4]=B00001001;
ascii_table[82][5]=B01111111;
ascii_table[82][6]=B00000000;
ascii_table[82][7]=7;

ascii_table[83][0]=B00000000;
ascii_table[83][1]=B00110001;
ascii_table[83][2]=B01001001;
ascii_table[83][3]=B01001001;
ascii_table[83][4]=B01001001;
ascii_table[83][5]=B01000110;
ascii_table[83][6]=B00000000;
ascii_table[83][7]=7;

ascii_table[84][0]=B00000000;
ascii_table[84][1]=B00000001;
ascii_table[84][2]=B00000001;
ascii_table[84][3]=B01111111;
ascii_table[84][4]=B00000001;
ascii_table[84][5]=B00000001;
ascii_table[84][6]=B00000000;
ascii_table[84][7]=7;

ascii_table[85][0]=B00000000;
ascii_table[85][1]=B00111111;
ascii_table[85][2]=B01000000;
ascii_table[85][3]=B01000000;
ascii_table[85][4]=B01000000;
ascii_table[85][5]=B00111111;
ascii_table[85][6]=B00000000;
ascii_table[85][7]=7;

ascii_table[86][0]=B00000000;
ascii_table[86][1]=B00011111;
ascii_table[86][2]=B00100000;
ascii_table[86][3]=B01000000;
ascii_table[86][4]=B00100000;
ascii_table[86][5]=B00011111;
ascii_table[86][6]=B00000000;
ascii_table[86][7]=7;

ascii_table[87][0]=B00000000;
ascii_table[87][1]=B00111111;
ascii_table[87][2]=B01000000;
ascii_table[87][3]=B00111000;
ascii_table[87][4]=B01000000;
ascii_table[87][5]=B00111111;
ascii_table[87][6]=B00000000;
ascii_table[87][7]=7;

ascii_table[88][0]=B00000000;
ascii_table[88][1]=B01100011;
ascii_table[88][2]=B00010100;
ascii_table[88][3]=B00001000;
ascii_table[88][4]=B00010100;
ascii_table[88][5]=B01100011;
ascii_table[88][6]=B00000000;
ascii_table[88][7]=7;

ascii_table[89][0]=B00000000;
ascii_table[89][1]=B00000111;
ascii_table[89][2]=B00001000;
ascii_table[89][3]=B01110000;
ascii_table[89][4]=B00001000;
ascii_table[89][5]=B00000111;
ascii_table[89][6]=B00000000;
ascii_table[89][7]=7;

ascii_table[90][0]=B00000000;
ascii_table[90][1]=B01000011;
ascii_table[90][2]=B01000101;
ascii_table[90][3]=B01001001;
ascii_table[90][4]=B01010001;
ascii_table[90][5]=B01100001;
ascii_table[90][6]=B00000000;
ascii_table[90][7]=7;

ascii_table[91][0]=B00000000;
ascii_table[91][1]=B01000001;
ascii_table[91][2]=B01000001;
ascii_table[91][3]=B01111111;
ascii_table[91][4]=B00000000;
ascii_table[91][7]=5;

ascii_table[93][0]=B00000000;
ascii_table[93][1]=B01111111;
ascii_table[93][2]=B01000001;
ascii_table[93][3]=B01000001;
ascii_table[93][4]=B00000000;
ascii_table[93][7]=5;

ascii_table[94][0]=B00000000;
ascii_table[94][1]=B00000100;
ascii_table[94][2]=B00000010;
ascii_table[94][3]=B00000001;
ascii_table[94][4]=B00000010;
ascii_table[94][5]=B00000100;
ascii_table[94][6]=B00000000;
ascii_table[94][7]=7;

ascii_table[95][0]=B00000000;
ascii_table[95][1]=B01000000;
ascii_table[95][2]=B01000000;
ascii_table[95][3]=B01000000;
ascii_table[95][4]=B01000000;
ascii_table[95][5]=B00000000;
ascii_table[95][7]=6;

ascii_table[123][0]=B00000000;
ascii_table[123][1]=B01000001;
ascii_table[123][2]=B00110110;
ascii_table[123][3]=B00001000;
ascii_table[123][4]=B00000000;
ascii_table[123][7]=5;

ascii_table[124][0]=B00000000;
ascii_table[124][1]=B01111111;
ascii_table[124][2]=B00000000;
ascii_table[124][7]=3;

ascii_table[125][0]=B00000000;
ascii_table[125][1]=B00001000;
ascii_table[125][2]=B00110110;
ascii_table[125][3]=B01000001;
ascii_table[125][4]=B00000000;
ascii_table[125][7]=5;

ascii_table[126][0]=B00000000;
ascii_table[126][1]=B00001000;
ascii_table[126][2]=B00010000;
ascii_table[126][3]=B00001000;
ascii_table[126][4]=B00001000;
ascii_table[126][5]=B00010000;
ascii_table[126][6]=B00000000;
ascii_table[126][7]=7;
}

void setup(){
 Serial.begin(9600); 
 for (int i=0;i<ilosc_ekranow;i++)    //petla inicjalizujaca matryce
 {
 lc.shutdown(i,false);      // wyjscie z trybu uspienia
 lc.setIntensity(i,1);      // ustawienie jasnosci
 lc.clearDisplay(i);        // czyszczenie ekranu
 }

 /*for (int j1=0; j1<90; j1++)      //petla do wypelnienia ascii
  {
    for (int i1=0; i1<8; i1++)
        {
         ascii_table[i1][j1]=0;
          }
  }*/
}

void loop(){                  
    wypelnij();                 
    slideAscii(tekscik);
}

void printAscii(int ekran, int indeks)        //funkcja do stałego napisu
{
  int i = 0;
  for(i=0;i<8;i++)
  {
    lc.setRow(ekran,i,ascii_table[indeks][i]); 
    delay(50);
  }
}

int ile_lini(String tekst)              //funkcja liczaca ilosc lini do wyswietlenia
{
  int liczbowa[tekst.length()];                   //tablica zbierajaca liczby
  char znakowa[tekst.length()];                   //tablica zbierajaca znaki
  int linie;                                        //zmienna pomocnicza liczaca linie
  tekst.toCharArray(znakowa, tekst.length()+1);     //zamiana stringa na tablice char
  for (int i=0; i<tekst.length();i++)                 
      {
        liczbowa[i]=zamien_ascii(znakowa[i]);             //zamiana znakow na liczby
        linie = linie + ascii_table[liczbowa[i]][7];      //zliczenie ile lini z 7 pola ascii
        }
  return linie;
}

void slideAscii(String tekst)
{
  int lini = ile_lini(tekst);                         //ilosc lini tekstu
  byte pattern[lini+(16*ilosc_ekranow)];              //tablica ktora finalnie bedziemy wyswietlac

  int liczbowa[tekst.length()];                         //fragment przekopiowany z funkcji ile_lini
  char znakowa[tekst.length()];                         //
  tekst.toCharArray(znakowa, tekst.length()+1);         //
  for (int i=0; i<tekst.length();i++)                   //
      {                                                 //
        liczbowa[i]=zamien_ascii(znakowa[i]);           //
        //Serial.println(liczbowa[i]);                  //
        }                                               //
  int licznik = 0;                                      //zmienna liczaca ktory raz petla sie wypelnia
  for (int k=0;k<(8*ilosc_ekranow);k++)                 //wypelnienie pierwszego ekranu w pattern B00000000
      {
      pattern[licznik]=B00000000;
      Serial.println(pattern[licznik]);
      licznik++;
      }
  for (int i=0; i<tekst.length();i++)                             //wypelnianie napisem tablicy pattern
      {                                                           //zalezne od dlugosci tekstu
         //Serial.print("liczba: ");
         //Serial.println(i);

        for (int j=ascii_table[liczbowa[i]][7]; j>0;j--)          //oraz od ilosci lini w danym znaku
              {
                pattern[licznik] = ascii_table[liczbowa[i]][j-1];
                //Serial.println(pattern[licznik]);
                licznik++;
                }         
        }
  for (int k=0;k<(8*ilosc_ekranow);k++)                 //wypelnanie koncowego ekranu w pattern B00000000
      {
      pattern[licznik]=B00000000;
      Serial.println(pattern[licznik]);
      licznik++;
      }

      for(int k=0;k<(lini+(8*ilosc_ekranow));k++)
          {
          int pasy=0;
          for (int i=0;i<ilosc_ekranow;i++)                     //petla wypisujaca na matrycy
                {
                  for (int j=0;j<8;j++)                         //petla wewnetrzna wypisujaca na matrycy
                        {
                          lc.setRow(i,j,pattern[pasy+k]);           //lc.setRow funkcja wypisujaca
                          pasy++;                                   //pattern jest obiektem ktory wypisujemy
                          }                                         //pasy poniewaz jest to dodatkowa petla liczaca
                  }                                                 // +k aby napis mogl sie przesuwac

      delay(30);                                                  //opoznienie czyli predkosc przesuwania sie tekstu
           }
}

int zamien_ascii(char znak)       //zamiana znaku na ascii
{
if (znak==' '){return 32;}
if (znak=='!'){return 33;}
if (znak=='"'){return 34;}
if (znak=='#'){return 35;}
if (znak=='$'){return 36;}
if (znak=='%'){return 37;}
if (znak=='&'){return 38;}
if (znak=='('){return 40;}
if (znak==')'){return 41;}
if (znak=='*'){return 42;}
if (znak=='+'){return 43;}
if (znak==','){return 44;}
if (znak=='-'){return 45;}
if (znak=='.'){return 46;}
if (znak=='/'){return 47;}
if (znak=='0'){return 48;}
if (znak=='1'){return 49;}
if (znak=='2'){return 50;}
if (znak=='3'){return 51;}
if (znak=='4'){return 52;}
if (znak=='5'){return 53;}
if (znak=='6'){return 54;}
if (znak=='7'){return 55;}
if (znak=='8'){return 56;}
if (znak=='9'){return 57;}
if (znak==':'){return 58;}
if (znak==';'){return 59;}
if (znak=='<'){return 60;}
if (znak=='='){return 61;}
if (znak=='>'){return 62;}
if (znak=='?'){return 63;}
if (znak=='@'){return 64;}
if (znak=='A'){return 65;}
if (znak=='B'){return 66;}
if (znak=='C'){return 67;}
if (znak=='D'){return 68;}
if (znak=='E'){return 69;}
if (znak=='F'){return 70;}
if (znak=='G'){return 71;}
if (znak=='H'){return 72;}
if (znak=='I'){return 73;}
if (znak=='J'){return 74;}
if (znak=='K'){return 75;}
if (znak=='L'){return 76;}
if (znak=='M'){return 77;}
if (znak=='N'){return 78;}
if (znak=='O'){return 79;}
if (znak=='P'){return 80;}
if (znak=='Q'){return 81;}
if (znak=='R'){return 82;}
if (znak=='S'){return 83;}
if (znak=='T'){return 84;}
if (znak=='U'){return 85;}
if (znak=='V'){return 86;}
if (znak=='W'){return 87;}
if (znak=='X'){return 88;}
if (znak=='Y'){return 89;}
if (znak=='Z'){return 90;}
if (znak=='['){return 91;}
if (znak==']'){return 93;}
if (znak=='^'){return 94;}
if (znak=='_'){return 95;}
if (znak=='{'){return 123;}
if (znak=='|'){return 124;}
if (znak=='}'){return 125;}
if (znak=='~'){return 126;}
return 32;
}

Nienawidzę snobizmu, hate'rów... i dzieci NEO

Pozostało 580 znaków

2017-05-30 09:30

Rejestracja: 4 lata temu

Ostatnio: 38 sekund temu

Lokalizacja: Łódź

2

Poszukaj lepszego kodu w C, bo ten napisany jest okropnie... Pokaż co zrobiłeś tłumacząc i gdzie masz wątpliwości, to ktos Tobie pomoże....


Ogólnie na prace domowe mam stawki zaporowe. Czasem coś o programowaniu znajdzie się na mojej stronie

Pozostało 580 znaków

2017-05-30 10:28

Rejestracja: 6 lat temu

Ostatnio: 6 miesięcy temu

0

Witam raz jeszcze,

chciałabym np zrozumieć taki zapis tablicy:

ascii_table[126][0]=B00000000;
ascii_table[126][1]=B00001000;
ascii_table[126][2]=B00010000;
ascii_table[126][3]=B00001000;
ascii_table[126][4]=B00001000;
ascii_table[126][5]=B00010000;
ascii_table[126][6]=B00000000;
ascii_table[126][7]=7;

o ile pojedyncze wiersze rozumiem o tyle ostatniego zapisu nie rozumiem. Domyślam się że wszystkie wartości tablicy poza tą ostatnią są zapisane binarnie. A ostatnia jest zapisana w systemie dziesiętnym?

Kolejna rzecz to ten zapis:


tekst.toCharArray(znakowa, tekst.length()+1);

Nie wiem co tutaj się dzieje - czy do zmiennej tekst jest zapisywany wynik zapisu czy do zmiennej znakowa. W C troszke inaczej to wygląda niż w Delphi.

Chyba prościej będzie jak sama będę pisać kod od początku bo faktycznie ten kod to jest masakra :/

Pozdrawiam!


Nienawidzę snobizmu, hate'rów... i dzieci NEO

Pozostało 580 znaków

2017-05-30 10:45

Rejestracja: 4 lata temu

Ostatnio: 38 sekund temu

Lokalizacja: Łódź

1

o ile pojedyncze wiersze rozumiem o tyle ostatniego zapisu nie rozumiem. Domyślam się że wszystkie wartości tablicy poza tą ostatnią są zapisane binarnie. A ostatnia jest zapisana w systemie dziesiętnym?

Tak, ale to nie ma znaczenia - można by wszystko zapisać w jednym stylu, jest to pewnie kwestia, że komuś nie chciało się przeliczać, albo uważał, że tak będzie czytelniej, choć w to drugie wątpię, patrząc na styl.

toCharArray

to jest microsoftowy wynalazek - w sumie nie wiem po co on jest tu wykonywany, ale analiza tego jest dla mnie bezsensem, widząc jak reszta bezsensownie jest tworzona. Ktoś rozwiązuje problemy, które najpierw sam sobie tworzy.


Ogólnie na prace domowe mam stawki zaporowe. Czasem coś o programowaniu znajdzie się na mojej stronie
edytowany 1x, ostatnio: kaczus, 2017-05-30 10:45

Pozostało 580 znaków

2017-05-30 16:30
Moderator Delphi/Pascal

Rejestracja: 8 lat temu

Ostatnio: 7 godzin temu

Lokalizacja: Tuchów

2
ascii_table[126][0] = B00000000;

To jest po prostu wpisanie jednobajtowej wartości do komórki tablicy. Zapis B00000000 to jakieś makro, które pozwala używać binarnych literałów – tutaj jest to wytłumaczone. Czyli równie dobrze można by napisać tak:

ascii_table[126][0] = 0;

Tyle że nie będzie się widzieć tego jak wyglądają poszczególne bity. Z liczbą 0 nie ma problemu, bo wszystkie bity są zgaszone, jednak im większa liczba tym trudniej w głowie przekonwertować ją na postać binarną – stąd zapewne używanie makr.

We Free Pascalu (nie wiem jak z systemem binarnym w Delphi) istnieje możliwość zapisu liczbowych literałów w czterech różnych systemach, więc żadne makra i inne cuda na kiju nie są potrzebne:

var
  NumberB: Byte = %00010111;  // binarnie
  NumberO: Byte = &027;       // oktalnie
  NumberX: Byte = $17;        // heksadecymalnie
  NumberD: Byte = 23;         // decymalnie

Każda zmienna otrzyma taką samą wartość (zera wiodące są opcjonalne). Tak więc w Pascalu (ogólnie) można by zadeklarować taką tablicę w poniższy sposób:

var
  AsciiTable: array [0 .. 129, 0 .. 7] of Byte;

a następnie uzupełniać ją liczbami w taki sposób:

AsciiTable[33, 1] := %01011111;

Jednak zamiast uzupełniać komórki ręcznie po kolei, lepiej by było zadeklarować sobie stałą macierz i ją po prostu przekopiować do zmiennej tablicowej.


Natomiast funkcja zamien_ascii to wynik niewiedzy kodera, który ją naklepał…

Znaki użyte w tej funkcji zgadzają się z kolejnością znaków w standardzie ASCII (niektóre są pominięte), więc ta funkcja mogła by po prostu sprawdzać czy znak mieści się w odpowiednich zakresach i jeśli tak, zwrócić jego kod (tu koder nie popisał się), a jeśli się nie mieści to zwrócić kod znaku spacji.

W Pascalu można by ją napisać np. tak:

function CharToCode(AChar: Char): Byte;
begin
  if AChar in [' ' .. '&', '(' .. '[', ']' .. '_', '{' .. '~'] then
    Result := Ord(AChar)
  else
    Result := Ord(' ');
end;

edytowany 6x, ostatnio: furious programming, 2017-05-31 00:26
w C++14 jest 0b1101 - Azarien 2017-05-30 18:33
Owszem – w wątku, do którego podałem link, jest to opisane. - furious programming 2017-05-30 19:29

Pozostało 580 znaków

Odpowiedz

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0