Prelucrare date achizitionate

[Liviu M]

Acum 9 ore, merck a spus:

 

In C,

Sorry, am sarit cumva-cumva peste explicatia asta, asa ca raspund acum. Multumesc!

 

Ah, si ca m-am uitat mai bine la rutina de coversie a lui Mircea. Daca o folosesti pe aia si inainte de scris pe card, nu-ti aliniaza numerele la dreapta, sa nu mai ai probleme cu NULL-urile?

[Liviu M]

Acum 49 minute, Liviu.Mihaiu a spus:

Putin mai sus este prezentată o idee pentru a folosi resurse minime ale uC.
Dacă vrea să puntem uC la treabă, putem scrie condensat toată rutina intr-o singura linie:

for(i=0;i<5;i++) Capacitance[i]=(int)(n/pow(10,4-i)) % 10 + '0';
 

N-am săpat prea adânc, da' la prima vedere pentru i=0 nu calculează corect, are un modulo în plus. Sau? 

 

LE Ba ar trebui să meargă. Că nu merită e altă poveste... 

Editat Iulie 1, 2021 de Liviu M

[Liviu M]

for(char i = 0, j = 4; i < 5; ++i, --j, n /= 10) Capacitate[j] = n % 10 + '0';

Tot o linie, da' indraznesc sa afirm ca mai economa. Cine da mai scurt si mai econom?

 

LE De fapt pot renunta la j:

for(char i = 0; i < 5; ++i, n /= 10) Capacitate[4-i] = n % 10 + '0';

 

Editat Iulie 1, 2021 de Liviu M

[Mircea]

2 hours ago, Liviu M said:

Daca o folosesti pe aia si inainte de scris pe card, nu-ti aliniaza numerele la dreapta, sa nu mai ai probleme cu NULL-urile?

Am confirmat ca le aliniaza la dreapta, sper ca ma crezi pe cuvant...

 

Pentru Liviu si Liviu, cum programele mele nu sunt prea complicate (in general), nu ma mai impiedic de limitarile memoriei disponibile. Optimizarea e la nivel de durata de executie mai curand, la memorie ma gandesc abia dupa.

[Liviu M]

Optimizările din ultimele posturi sunt doar la literele cu care e scris programul. 

Memoria și viteza pe de alta parte... 

[modoran]

Acum 12 ore, Liviu M a spus:

for(char i = 0, j = 4; i < 5; ++i, --j, n /= 10) Capacitate[j] = n % 10 + '0';

Tot o linie, da' indraznesc sa afirm ca mai economa. Cine da mai scurt si mai econom?

 

LE De fapt pot renunta la j:

for(char i = 0; i < 5; ++i, n /= 10) Capacitate[4-i] = n % 10 + '0';

 

 

Analizezi codul masina generat de compilator si foarte posibil sa fie cel mai optimizat dintre toate sau chiar identic in final

Editat Iulie 2, 2021 de modoran

[Liviu M]

Dacă mai găsesc codul de test de acum zeci de ani, pot să fac o comparație (în simulator) între cel cu scăderi și cel "pe o linie". 

 

[Liviu M]

Stiu ca nu intereseaza pe nimeni , da' am facut testele. Rezultatele cu xc8 lite, adica fara nici un fel de optimizare a codului (un compiler care optimizeaza probabil micsoreaza diferentele):

Nr: 59999
Scaderi: 

Memory Summary:
    Program space        used    A3h (   163) of  8000h words   (  0.5%)
    Data space           used     Dh (    13) of  1000h bytes   (  0.3%)
    EEPROM space         used     0h (     0) of   100h bytes   (  0.0%)
    Data stack space     used     0h (     0) of   FF0h bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     5h words   (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)


Target halted. Stopwatch cycle count = 751 (751 µs)

*******************************************************************
  for(char i=0;i<5;i++) buf[i]=(int)(iNr/pow(10,4-i)) % 10 + '0'; 

Memory Summary:
    Program space        used   9ADh (  2477) of  8000h words   (  7.6%)
    Data space           used    74h (   116) of  1000h bytes   (  2.8%)
    EEPROM space         used     0h (     0) of   100h bytes   (  0.0%)
    Data stack space     used     0h (     0) of   F8Ch bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     5h words   (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)
    
Target halted. Stopwatch cycle count = 140224 (140.224 ms)

*******************************************************************
  for(char i = 0; i < 5; ++i, iNr /= 10) buf[4-i] = iNr % 10 + '0';  

  Memory Summary:
    Program space        used    9Fh (   159) of  8000h words   (  0.5%)
    Data space           used    13h (    19) of  1000h bytes   (  0.5%)
    EEPROM space         used     0h (     0) of   100h bytes   (  0.0%)
    Data stack space     used     0h (     0) of   FE8h bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     5h words   (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)

Target halted. Stopwatch cycle count = 4842 (4.842 ms)   
 
*******************************************************************
  buf[0] = iNr/10000 + 48;
  buf[1] = (iNr/1000)%10 + 48;
  buf[2] = (iNr/100)%10 + 48;
  buf[3] = (iNr/10)%10 + 48;
  buf[4] = iNr%10 + 48;
  
Memory Summary:
    Program space        used    E1h (   225) of  8000h words   (  0.7%)
    Data space           used    18h (    24) of  1000h bytes   (  0.6%)
    EEPROM space         used     0h (     0) of   100h bytes   (  0.0%)
    Data stack space     used     0h (     0) of   FE8h bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     5h words   (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)

Target halted. Stopwatch cycle count = 3134 (3.134 ms)

 

Editat Iulie 2, 2021 de Liviu M
Completat Memory Summary ultimul test

[Mircea]

Care cod a durat 751us?

[Liviu M]

Asta.

In postarea originala (linkata in postul anterior), a fost remarcat ca cel mai defavorabil numar (de 5 cifre, pe 16 biti) e 59999, de-aia l-am folosit pe ala.

Editat Iulie 2, 2021 de Liviu M

[Liviu M]

Am completat datele ultimului test cu memoria ocupata, ca o pierdusem pe drum.

[Vizitator]

Varianta propusa de mine, cu pow(),  este cea mai 'interesanta' ca memorie ocupata si timp de compilare si executie  :)

 

 

 

46 minutes ago, Liviu M said:

Stiu ca nu intereseaza pe nimeni

Tu scrie. Si stai linistit. Sunt multi care urmaresc astfel de subiecte.

 

[Mircea]

E rapid, nu gluma codul propus. 

[Liviu M]

Codul rapid de mai sus era in conditiile in care conversia e intr-o functie dedicata.

Daca pun conversia in main(), arata chiar mai bine (pun la gramada codul complet si rezultatele):

 

#include <xc.h>

void main(void) {
  
  unsigned int iNr = 64999;
  unsigned char buf[5];
  
   buf[0] = 0;
   while (iNr > 10000){
      iNr -= 10000;
      buf[0] += 1;
   }
   buf[0] += '0';
   buf[1] = 0;
   while (iNr > 1000){
      iNr -= 1000;
      buf[1] += 1;
   } 
   buf[1] += '0';
   buf[2] = 0;
   while (iNr > 100){
      iNr -= 100;       
      buf[2] += 1;    
   }    
   buf[2] += '0';
   buf[3] = 0;
   while (iNr > 10){
      iNr -= 10; 
      buf[3] += 1;
   } 
   buf[3] += '0';
   buf[4] = (unsigned char)iNr + '0';
  
  while(1);
  
  return;
}

Memory Summary:
    Program space        used    63h (    99) of  8000h words   (  0.3%)
    Data space           used     Ah (    10) of  1000h bytes   (  0.2%)
    EEPROM space         used     0h (     0) of   100h bytes   (  0.0%)
    Data stack space     used     0h (     0) of   FF0h bytes   (  0.0%)
    Configuration bits   used     0h (     0) of     5h words   (  0.0%)
    ID Location space    used     0h (     0) of     4h bytes   (  0.0%)

Target halted. Stopwatch cycle count = 533 (533 µs)

 

Acum 17 minute, Liviu.Mihaiu a spus:

Varianta propusa de mine, cu pow(),  este cea mai 'interesanta' ca memorie ocupata si timp de compilare si executie 

Era clar ca asa o sa fie, intrebarea era "cat de mult".

Noroc ca xc vine si cu biblioteca math.h, ca altfel nu reuseam sa-l compilez.

 

Editat Iulie 2, 2021 de Liviu M

[Mircea]

UPDATE:

Am avut deja 2 runde de 12 ore de achizitionare. Cam 40k+ de linii in Excel.

 

Fisierul TXT ajunge pe la 1,5M.