ElectroYou

Per una applicazione radioamatoriale, vorrei convertire un numero intero < 999
nelle corrispondenti lettere di testo. Dopo varie ore di lavoro, all'inizio il lavoro sembrava più facile, la lingua italiana è piena di eccezioni, pur scrivendo in modo barbaro sono riuscito nell'intento. Gradirei suggerimenti e consigli su come occupare meno memoria di programma oppure ricevere una funzione scritta meglio. Allego il programma.

Codice: Seleziona tutto

//17/2/023  scrive un numero di tre cifre decimali in lettere
const String U1 = "uno", U2="due",U3="tre",U4="quattro",U5="cinque",U6 = "sei",U7 = "sette",U8="otto",U9="nove",U10="dieci";
const char *vet_U[] = {"zero","uno", "due","tre","quattro","cinque","sei","sette","otto","nove","dieci"} ;
const String DICI = "dici", ANT = "ant";
const String U20 = "vent",U30 = "trent", U40 = "quar",U50 = "cinqu", U60="sess", U70="sett",U80="ott",U90="nov";
//const char *vet_D[] = {"null", "dec", "vent", "trent", "quar", "cinqu", "sess","sett", "ott","nov"};
const String CENTO = "cento", MILA = "mila";
int N,NI,NU,ND,NC,NDU, N1,N5;
String testo,testU,testoC;


void selezunita() { if(NU>0 && NU<=9){testU = vet_U[NU];}  } 
 
void legginumero()
{

//cerca se ci sono delle centnaia
NC = NI/100;
N = NI - NC*100;// numero (decine e unità) inferiore a 100

if (NC > 0)
{ if (NC == 1) {testoC = CENTO;} else {testoC = vet_U[NC]+CENTO;} } else  {testoC = "";}

if (NC == 0 &&  N==0) { testo = vet_U[N];}else{testo="";} //non scrive zero se il numero è solo centinaia
if (N> 0 && N <=10) { testo = vet_U[N];} //
if (N == 11){testo = "un"+DICI;}
if (N == 12){testo = "do"+DICI;}
if (N == 13){testo = "tre"+DICI;}
if (N == 14){testo = "quattor"+DICI;}
if (N == 15){testo = "quin"+DICI;}
if (N == 16){testo = "se"+DICI;}
if (N == 17){testo = DICI+"as"+U7;}
if (N == 18){testo = DICI+U8;}
if (N == 19){testo = DICI+"ann"+U9;}

ND = N/10; //numero delle decine
if (N == 20){testo = U20+"i";}
if (N>20 && N< 30) {  NU = N-20; selezunita(); if (NU==1 || NU==8){ testo = U20+testU;} else {testo= U20+"i"+testU;} }

/*
for (N1= 30;N1<= 90;N1=N1+10)
{
if (N == N1){testo =vet_D[N1/10] +"a";}
if (N>N1 && N<(N1+10)) {NU = N-N1;  selezunita();if (NU==1 || NU==8){ testo = vet_D[N1/10]+testU;} else { testo = vet_D[N1/10]+"a"+testU;} }
}
//  questa variante  da errore di compilazione
*/

  N1=30;
if (N == N1){testo = U30+"a";}
if (N>N1 && N< (N1+10)) {NU = N-N1;  selezunita();if (NU==1 || NU==8){ testo = U30+testU;} else { testo = U30+"a"+testU;} }

  N1 = 40;
if (N == N1){testo = U40+ANT+"a";}
if (N>N1 && N< (N1+10)) { NU = N-N1;selezunita(); if (NU==1 || NU==8){ testo = U40+ANT+testU;} else { testo = U40+ANT+"a"+testU;}   }

  N1 = 50;
if (N == N1){testo = U50+ANT+"a";}
if (N>N1 && N<( N1+10)) { NU = N-N1;  selezunita(); if (NU==1 || NU==8){ testo = U50+ANT+testU;} else { testo = U50+ANT+"a"+testU;}   }

  N1 = 60;
if (N == N1){testo = U60+ANT+"a";}
if (N>N1 && N<( N1+10)) { NU = N-N1;  selezunita();  if (NU==1 || NU==8){ testo = U60+ANT+testU;} else { testo = U60+ANT+"a"+testU;} }

   N1 = 70;
if (N == N1){testo = U70+ANT+"a";}
if (N>N1 && N<( N1+10)) { NU = N-N1;  selezunita();  if (NU==1 || NU==8){ testo = U70+ANT+testU;} else { testo = U70+ANT+"a"+testU;} }

   N1 = 80;
if (N == N1){testo = U80+ANT+"a";}
if (N>N1 && N<( N1+10)) { NU = N-N1;  selezunita();  if (NU==1 || NU==8){ testo = U80+ANT+testU;} else { testo = U80+ANT+"a"+testU;} }

    N1 = 90;
if (N == N1){testo = U90+ANT+"a";}
if (N>N1 && N<( N1+10)) { NU = N-N1;  selezunita();  if (NU==1 || NU==8){ testo = U90+ANT+testU;} else { testo = U90+ANT+"a"+testU;} }

testo = testoC+testo;
}


void setup()
{  Serial.begin(9600); // open the serial port at 9600 bps:
//legginumero();
  for ( NI = 0; NI<500; NI=NI+1)
  { legginumero();
   Serial.print( testo);Serial.print("  ");
   N5 = N5 +1; if (N5==10){N5=0; Serial.println(" ");}
  }
}



void loop()
{ //non utilizzato



Non conosco Arduino ma molti linguaggi hanno delle funzioni dedicate per convertire gli interi in testo, tanto più che è un problema abbastanza comune

Ho cercato in rete se qualcuno l'avesse già affrontato:
https://circuits4you.com/2018/03/09/how ... n-arduino/
https://stackoverflow.com/questions/791 ... on-arduino
https://forum.arduino.cc/t/how-to-conve ... ext/573255

E' ambiguo, non intendevo cifre o caratteri numerici, proprio lettere, come nell'esempio dei risultati:

Codice: Seleziona tutto

zero  uno  due  tre  quattro  cinque  sei  sette  otto  nove   
dieci  undici  dodici  tredici  quattordici  quindici  sedici  diciassette  diciotto  diciannnove   
venti  ventuno  ventidue  ventitre  ventiquattro  venticinque  ventisei  ventisette  ventotto  ventinove   
trenta  trentuno  trentadue  trentatre  trentaquattro  trentacinque  trentasei  trentasette  trentotto  trentanove   
quaranta  quarantuno  quarantadue  quarantatre  quarantaquattro  quarantacinque  quarantasei  quarantasette  quarantotto  quarantanove   
cinquanta  cinquantuno  cinquantadue  cinquantatre  cinquantaquattro  cinquantacinque  cinquantasei  cinquantasette  cinquantotto  cinquantanove   
sessanta  sessantuno  sessantadue  sessantatre  sessantaquattro  sessantacinque  sessantasei  sessantasette  sessantotto  sessantanove   
settanta  settantuno  settantadue  settantatre  settantaquattro  settantacinque  settantasei  settantasette  settantotto  settantanove   
ottanta  ottantuno  ottantadue  ottantatre  ottantaquattro  ottantacinque  ottantasei  ottantasette  ottantotto  ottantanove   
novanta  novantuno  novantadue  novantatre  novantaquattro  novantacinque  novantasei  novantasette  novantotto  novantanove   
cento  centouno  centodue  centotre  centoquattro  centocinque  centosei  centosette  centootto  centonove   
centodieci  centoundici  centododici  centotredici  centoquattordici  centoquindici  centosedici  centodiciassette  centodiciotto  centodiciannnove   
centoventi  centoventuno  centoventidue  centoventitre  centoventiquattro  centoventicinque  centoventisei  centoventisette  centoventotto  centoventinove   
centotrenta  centotrentuno  centotrentadue  centotrentatre  centotrentaquattro  centotrentacinque  centotrentasei  centotrentasette  centotrentotto  centotrentanove   
centoquaranta  centoquarantuno  centoquarantadue  centoquarantatre  centoquarantaquattro  centoquarantacinque  centoquarantasei  centoquarantasette  centoquarantotto  centoquarantanove   
centocinquanta  centocinquantuno  centocinquantadue  centocinquantatre  centocinquantaquattro  centocinquantacinque  centocinquantasei  centocinquantasette  centocinquantotto  centocinquantanove   
centosessanta  centosessantuno  centosessantadue  centosessantatre  centosessantaquattro  centosessantacinque  centosessantasei  centosessantasette  centosessantotto  centosessantanove   
centosettanta  centosettantuno  centosettantadue  centosettantatre  centosettantaquattro  centosettantacinque  centosettantasei  centosettantasette  centosettantotto  centosettantanove   
centoottanta  centoottantuno  centoottantadue  centoottantatre  centoottantaquattro  centoottantacinque  centoottantasei  centoottantasette  centoottantotto  centoottantanove   
centonovanta  centonovantuno  centonovantadue  centonovantatre  centonovantaquattro  centonovantacinque  centonovantasei  centonovantasette  centonovantotto  centonovantanove   
duecento  duecentouno  duecentodue  duecentotre  duecentoquattro  duecentocinque  duecentosei  duecentosette  duecentootto  duecentonove   
duecentodieci  duecentoundici  duecentododici  duecentotredici  duecentoquattordici  duecentoquindici  duecentosedici  duecentodiciassette  duecentodiciotto  duecentodiciannnove   
duecentoventi  duecentoventuno  duecentoventidue  duecentoventitre  duecentoventiquattro  duecentoventicinque  duecentoventisei  duecentoventisette  duecentoventotto  duecentoventinove   
duecentotrenta  duecentotrentuno  duecentotrentadue  duecentotrentatre  duecentotrentaquattro  duecentotrentacinque  duecentotrentasei  duecentotrentasette  duecentotrentotto  duecentotrentanove   
duecentoquaranta  duecentoquarantuno  duecentoquarantadue  duecentoquarantatre  duecentoquarantaquattro  duecentoquarantacinque  duecentoquarantasei  duecentoquarantasette  duecentoquarantotto  duecentoquarantanove   
duecentocinquanta  duecentocinquantuno  duecentocinquantadue  duecentocinquantatre  duecentocinquantaquattro  duecentocinquantacinque  duecentocinquantasei  duecentocinquantasette  duecentocinquantotto  duecentocinquantanove   
duecentosessanta  duecentosessantuno  duecentosessantadue  duecentosessantatre  due

In effetti è un problema non da poco

Un numero a tre cifre non si scrive nominando le sue cifre singolarmente ma esprimendosi con una modalità complessa

Anche i numeri a due cifre hanno la stessa caratteristica, seppure meno complessa, mente quelli ad una sola cifra sono "fortunati"

Forse, la strada più veloce è quella di istruire il radioamatore a pronunciare qualsiasi numero come sequenza delle sue cifre singolarmente

Tra l'altro, da mie reminiscenze in ambito militare mi pare che in particolari situazioni e/o contesti operativi, fosse prescritto di usare quel tipo di notazione (forse la chiamavano "esplicita" ma non sono sicuro) nelle comunicazioni via radio

Usare un array di stringhe ? Non so lo spazio occupato......Ti serve una flash esterna o un SD

L'italiano non è strutturato come per esempio l'inglese, sono quasi più le eccezioni che non

Non puoi farlo leggere lettera per lettera?

Dirò senz'altro una cavolata, anche perché non ho capito bene cosa devi fare e specialmente nell'ambito dei radioamatori, i numeri più frequenti che sapevo io erano i rapporti che si dà, ad esempio 599+20.
Io abitualmente converto i numeri in lettere, specialmente quando devo mettere un prezzo su un articolo e non voglio che gli altri lo capiscano, in linea di massima e faccio in questo modo:
-Di ogni cifra scrivo la prima lettera.
Esempio : 599+20 > C N N + D Z.
E' una soluzione ovvia, ma non è subito intuibile. C'è un piccolo inghippo nel 6 con il 7 che si può ovviare aggiungendo alla S un punto per indicare 7 > S.
0 > Z
1 > U
2 > D
3 > T
4 > Q
5 > C
6 > S
7 > S.
8 > O
9 > N

Premetto che è il mio è un gioco autodidattico obsoleto.
Prevedo di trasmettere la stringa di testo in codice morse.
La trasmissione è di un beacon di potenza limitata in VHF che trasmette qualche dato telemetrico ( esempio temperatura , tensione alimentazione) ad ascoltatori che decodificano mediocremente ad orecchio.
I numeri trasmessi in lettere sono più facili da decodificare delle cifre, in quanto le lettere sono composte da meno elementi (punti, linee).
Inoltre la ridondanza del numero trasmesso in lettere ne facilita la comprensione.
Per esempio il numero 15 in morse è: .---- .....
la parola quindici è: --.- ..- .. -. -.. .. -.-. ..

Sono conscio che il tutto è obsoleto e di una efficienza modesta rispetto a una trasmissione RTTY 50 baud, per non parlare del packet APRS, PSK31 WSPR e simili.
Confermo che un aiuto a scrivere una funzione che occupa meno memoria programmi e dati mi è utile.
Esistono dei programmi decodificatori morse che sono efficaci e decodificano le cifre ad alta velocità.


p.s. Setteali, thanks per il suggerimento, mi può venire utile in un altro contesto.

Ora ho capito del perché, in effetti è vero, secondo me parzialmente, anche se io non sono per niente un asso in CW, il numero essendo tutti lunghi uguali dallo 0 al 9, si distinguono bene i 5 caratteri. Questo senza niente togliere alla tua ricerca.


P.S.
Mi fa piacere che tu lo possa utilizzare in altro contesto, il sistema che ho scritto.

Su Arduino sarebbe meglio evitare la classe String che usa la memoria dinamica. Meglio una stringa statica in C "liscio" (array di char).

Codice: Seleziona tutto

char testo[32];
const char* vet_U[] = {
    "zero",     "uno",     "due",   "tre",
    "quattro",  "cinque",  "sei",   "sette",
    "otto",     "nove",    "dieci"
};

//-------------------------------------------------

void setup()
{
    Serial.begin(115200);
    for(uint16_t n=0; n<40; n++)
    {
        Serial.println(converti(testo, n));
    }
}

void loop()
{
}

//-------------------------------------------------

char* converti(char* str, uint16_t ni)
{
  // estraggo unita` decine centinaia
  uint8_t uni = ni % 10;
  uint8_t dec = (ni / 10) % 10;
  uint8_t cen = ni / 100;

  // stringa di partenza vuota
  str[0] = '\0';

  // elabora centinaia
  if (cen > 0)
  {
      if (cen > 1) strcat(str, vet_U[cen]);
      strcat(str, "cento");
  }

  // elabora decine e unita`
  if (dec > 0)
  {
      if (1 == dec)
      {
          if      (0 == uni) strcat(str, "dieci");
          else if (1 == uni) strcat(str, "undici");
          else if (2 == uni) strcat(str, "dodici");
          else if (3 == uni) strcat(str, "tredici");
          else if (4 == uni) strcat(str, "quattordici");
          else if (5 == uni) strcat(str, "quindici");
          else if (6 == uni) strcat(str, "sedici");
          else if (7 == uni) strcat(str, "diciassette");
          else if (8 == uni) strcat(str, "diciotto");
          else               strcat(str, "diciannove");
      }
      else
      {
          if      (2 == dec) strcat(str, "vent");
          else if (3 == dec) strcat(str, "trent");
          else if (4 == dec) strcat(str, "quarant");
          else if (5 == dec) strcat(str, "cinquant");
          else if (6 == dec) strcat(str, "sessant");
          else if (7 == dec) strcat(str, "settant");
          else if (8 == dec) strcat(str, "ottant");
          else               strcat(str, "novant");

          if      (0 == uni) strcat(str, (2 == dec) ? "i" : "a");
          else if (1 == uni) strcat(str, "uno");
          else
          {
              if (8 != uni) strcat(str, (2 == dec) ? "i" : "a");
              strcat(str, vet_U[uni]);
          }
      }
  }

  // elabora unita` se decine == 0
  if (0 == dec  &&  (0 == cen  ||  0 != uni))
  {
      strcat(str, vet_U[uni]);
  }

  return str;
}