OK Mégsem
Fórum témák

» Több friss téma
Fórum » CCS PIC Compiler
CCS PIC Compiler
 
Témaindító: (Felhasználó 1542), idő: Ápr 3, 2006
Lapozás: OK   50 / 118
(#) whalaky válasza vicsys hozzászólására (») Jan 12, 2011 /
 
Azt nem árultad el, hogy a
"Ilyesmi a skálázásom: ha érték 10-12 -ig akkor..., ha érték 12-14,4, akkor...., ha érték nagyobb mint 15, akkor... etc."-ban az értékek milyen típusúak. Ha valami egész, akkor vilmosd megolgása megoldás lehet.
Kb olyan mint pascalban a
case 10..12:
case 13,14,4:
...
case 15:
...
bár nem tudom mennyivel memória kímélőbb....

"Ha nem megy erőltesd!
Ha ekkor sem megy, vegyél elő nagyobb kalapácsot!"
(esetünkben PIC-et)
(#) vilmosd válasza vicsys hozzászólására (») Jan 12, 2011 /
 
Hali
Pl van egy 8 bites szamod, az ugye 0-255 koze esik. Kellene elagazast csinalni 12, 58, 92, 146, 222, nel. Meghatarozzuk a legnagyobb kozos osztot, majd elosztjuk az erteket a kozos osztoval. Kapunk valamilyen szamot, majd azt az elozo pelda alapjan odaadjuk a "switch-case" -nek elbiralasra. Persze ha sok a feltetel, es meg raadasul "float" tipusu a valtozonk, ez azert bonyolult.
(#) vicsys válasza whalaky hozzászólására (») Jan 12, 2011 /
 
Köszi!
Csak a játék kedvéért:
Hogyan adsz meg vizsgálatot a case-ben? Legyen például az ha érték 12,3 és 13,8 között van, akkor... Ezt szeretném látni, If nélkül a case-ben. Van egy olyan érzésem, hogy ez több vizsgálat esetén, csak if-el fog menni. Most a mem. méretétől egyenlőre tekintsünk el.
(#) vicsys válasza vilmosd hozzászólására (») Jan 12, 2011 /
 
Rátapintottál az érzékeny pontomra, -képletesen szólva... (sok vizsgálat és lehetőleg float)
(#) MPi-c válasza vicsys hozzászólására (») Jan 12, 2011 /
 
Már bocs, hogy én is bele... de tudjuk a switch-ről:
"Az utasítás úgy működik, hogy összehasonlítja egy kifejezés értékét több egész értékű állandó kifejezés értékével, és az ennek megfelelő utasítást hajtja végre. "

És, ha egészeket csinálnál a nem egészekből?
(#) trudnai válasza vicsys hozzászólására (») Jan 12, 2011 /
 
Miert ertelmetlen a switch..case? Annak amugy nem a memoria sporolas, hanem a futasi sebesseg az ertelme... Mert ahogy mondtam egy jo C fordito ha csak egy mod van ra a switch..case-bol ugrotablat general, igy nem kell neki gondolkodnia, csak ugrania...

De ha egy peldaval leirnad milyen feltetelek ill lehetseges ertekek lehetnem a valtozodban, akkor lehet konkretabban tudnank segiteni
(#) trudnai válasza vicsys hozzászólására (») Jan 12, 2011 /
 
switch..case csak egesz tipussal fog menni... Tehat eleve bukta, hacsak at nem alakitod egessze ahogy ez mar elhangzott.

Pl. felszorozzuk 10-es es vesszuk az egesz reszet, ekkor:

  1. switch ( (int) (valtozo*10) ) {
  2.     case 123: // 12,3 -tol...
  3.     case 124:
  4.     case 125:
  5.     case 126:
  6.     case 127:
  7.     case 128: // 12,8-ig...
  8.         CsinalunkValamit();
  9.         break;
  10.     ...
  11. }
(#) MPi-c válasza trudnai hozzászólására (») Jan 12, 2011 /
 
Pont erre a megoldásra gondoltam! :kalap: csak én hagytam volna vicsys-t agyalni...
(#) trudnai válasza vicsys hozzászólására (») Jan 12, 2011 /
 
Ha memoria sporolos kell, akkor pl:

  1. struct kicsiTablam_t {
  2.     float also;
  3.     float felso;
  4.     void (*fuggveny) ( );
  5. };
  6.  
  7. kicsiTablam_t tablacska[] = {
  8.     {  12.3,  12.8, &kisertek },
  9.     {  54.5,  65.2, &kozepertek },
  10.     { 100.1, 200.5, &nagyertek },
  11. };
  12.  
  13. #define TMERET ( sizeof(tablacska) / sizeof(kicsiTablem_t) )
  14.  
  15. kisertek()
  16. {
  17.     // csinalunk valamit itt a kisertekhez
  18. }
  19.  
  20. kozepertek()
  21. {
  22.     // csinalunk valamit itt a kozepertekhez
  23. }
  24.  
  25. nagyertek()
  26. {
  27.     // csinalunk valamit itt a nagyertekhez
  28. }
  29.  
  30. ...
  31. for ( i = 0; i < TMERET; i++ ) {
  32.     if( ( tablacska[i].also >= valtozo )
  33.     and ( tablacska[i].felso <= valtozo ) )
  34.     {
  35.         // vegrehajtjuk a kivant fuggvenyt...
  36.         tablacska[i].fuggveny();
  37.     }
  38. }


Hangulyozom nincs letesztelve, lehet rossz, lehet le sem fordul, csak gondolat ebresztonek szantam!
(#) trudnai válasza MPi-c hozzászólására (») Jan 12, 2011 /
 
Tudom, csak mar itt agyal rajta ket napja (vagy csak en vagyok turelmetlen es raadasul tul sok idom van )
(#) MPi-c válasza trudnai hozzászólására (») Jan 13, 2011 /
 
Ezt olvastam a fránya CCS manualban : "The compiler does not permit pointers to functions so that the compiler can know at compile time the complete call tree."
(#) trudnai válasza MPi-c hozzászólására (») Jan 13, 2011 /
 
Ertem, akkor marad ez a megoldas?

  1. struct kicsiTablam_t {
  2.     float also;
  3.     float felso;
  4.     int ertek;
  5. };
  6.  
  7. kicsiTablam_t tablacska[] = {
  8.     {  12.3,  12.8, 1 },
  9.     {  54.5,  65.2, 2 },
  10.     { 100.1, 200.5, 3 },
  11. };
  12.  
  13. #define TMERET ( sizeof(tablacska) / sizeof(kicsiTablem_t) )
  14.  
  15. ...
  16. for ( i = 0; i < TMERET; i++ ) {
  17.     if( ( tablacska[i].also >= valtozo )
  18.     and ( tablacska[i].felso <= valtozo ) )
  19.     {
  20.         // vegrehajtjuk a kivant fuggvenyt...
  21.         tempvalt = tablacska[i].ertek;
  22.     }
  23. }
  24.  
  25. switch ( tempvalt ) {
  26.     case 1:
  27.         kisertek();
  28.         break;
  29.     case 2:
  30.         kozepertek();
  31.         break;
  32.     case 3:
  33.         nagyertek();
  34.         break;
  35. }
(#) vicsys válasza trudnai hozzászólására (») Jan 13, 2011 /
 
Köszönöm mindenkinek! Ez a megoldás tettszik és frappáns! Na ez nem jutott volna eszembe. Le voltam ragadva az if/else -nél....
(#) trudnai válasza vicsys hozzászólására (») Jan 13, 2011 /
 
Orulok neki, ha segitett Amugy meg csak annyi, hogy ebben sima szekvencialis kereses folyik a tablan belul. Ha nagyon nagy a tabla akkor erdemes elgondolkodni, hogy binaris fa keresest csinaljon az ember -- az nem egy tul nagy valtoztatas ehhez kepest.

UI: Csak nem hagyott nyugodni ez a manualisan felallitott kiegyenlitett binaris fa otlet Meg sohasem csinaltam ilyet, de nem veletlen! A kod, mint lathato annyira bonyolult lesz a vegen, hogy nagyon nehez modositani rajta, vagy akar hibat keresni is... Ennek a 13 erteku lekerdezesnek az osszeallitasa eltartott egy darabig, elkepzelheted, hogy pl egy 100 elemu lekerdezes mennyi ideig tartana...

Cserebe valoszinuleg ez a legoptimalisabb amit el lehet erni. Ahogy lathato a tesztelesi eredmenybol (a forras file legaljan), a 13 elem mindegyik erteket 4 (ill. nehany esetben 3) lekerdezessel eleri. (A kod amugy gcc-re lett irva csupan a teszt kedveert es Linux alatt probaltam ki)

Ha a binaris keresest a tablara valositod meg, akkor hasonlo lekerdezes szamot erhetsz el, szemben a szekvencialistol ahol ha szerencsed van 1, ha nincs akkor 13 lekerdezest hajtasz vegre a kereses soran. Amiert a tablas megoldas picit lassabb lesz az ugye abbol adodik, hogy ott meg van a switch..case ugye, amit azert illene megnezni vajon ugro tablat fordit-e belole a CCS avagy if..else szekvenciakat...

test_binaryT...c		    
(#) whalaky válasza trudnai hozzászólására (») Jan 13, 2011 /
 
És egy kicsit továbbgondolva mi mindenre jó a rekurzió...
10 sorral minden meg van oldva.
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4.  
  5. typedef struct teszt_t {
  6.     float kerdes;
  7.     int   valasz;
  8. } teszt_t;
  9.  
  10. teszt_t teszt[] = {
  11.     {   0.3, 1 },
  12.     {   1.5, 2 },
  13.     {  10.1, 3 },
  14.     {  30.7, 4 },
  15.     {  50.0, 5 },
  16.     {  80.3, 6 },
  17.     { 100.4, 7 },
  18.     { 150.1, 8 },
  19.     { 180.3, 9 },
  20.     { 200.8, 10 },
  21.     { 270.2, 11 },
  22.     { 300.3, 12 },
  23.     { 510.1, 13 }
  24. };
  25.  
  26.  
  27. #define TMERET ( sizeof(teszt) / sizeof(teszt[0]) )
  28.  
  29. // ez a függvény a lelke!
  30. int bs( float value, int i1, int i2 )
  31. {
  32.     if ( i2 - i1 <= 1 ) {
  33.         return teszt_t( teszt[ i2 ] ).kerdes >= value ? teszt_t( teszt[ i2 ] ).valasz : teszt_t( teszt[ i1 ] ).valasz;
  34.     }
  35.     int idx = i1 + ( ( i2 - i1 ) / 2 );
  36.     if ( value < teszt_t( teszt[ idx ] ).kerdes ) {          
  37.         return bs( value, i1, idx - 1 );
  38.     } else {
  39.         return bs( value, idx, i2  );
  40.     }
  41. }
  42.  
  43.  
  44. int main()
  45. {
  46.         float x = 237.4;
  47.         int v;
  48.  
  49.         v = bs( x, 0, TMERET - 1 );
  50.  
  51.         printf( "valasz = %u\r\n", v );
  52.            
  53.         return 0;  
  54. }


így az elemek száma elvileg korlátlan, egyszerűbb a kód, a bővítéshez és módosításhoz nem kell hozzányúlni mert gond nélkül bővíthető, az egyetlen megkötés hogy a teszt[] rendezett legyen, de ez gondolom nem okoz nagy fejfájást.
(#) whalaky válasza whalaky hozzászólására (») Jan 13, 2011 /
 
Hoppá, most nézen, ha a legkisebb értéknél kisebb akkor hibás....
  1. #define ERROR_CODE              0;
  2.  
  3. int bs( float value, int i1, int i2 )
  4. {
  5.         if ( i2 - i1 <= 1 ) {
  6.                 if ( value < teszt_t( teszt[ i2 ] ).kerdes ) {
  7.                         return ERROR_CODE;
  8.                 } else {
  9.                         return teszt_t( teszt[ i2 ] ).kerdes >= value ? teszt_t( teszt[ i2 ] ).valasz : teszt_t( teszt[ i1 ] ).valasz;
  10.                 }
  11.         }
  12.     int idx = i1 + ( ( i2 - i1 ) / 2 );
  13.         if ( value < teszt_t( teszt[ idx ] ).kerdes ) {      
  14.                 return bs( value, i1, idx - 1 );
  15.         } else {
  16.                 return bs( value, idx, i2  );
  17.         }
  18. }

így már jó.
(#) trudnai válasza whalaky hozzászólására (») Jan 13, 2011 /
 
Ebben tokeletesen igazad van, csak abban nem voltam (vagyok) biztos, hogy a CCS-ben vajon mekkora a stack, es hogy milyen szintu rekurziot engedelyez meg (ha egyaltalan megenged).

Amugy van meg egy masik vonzata beagyazott forditok eseteben a rekurzionak. Sok C fordito (es itt most megintcsak nincs eziranyu tapasztalatom CCS-ben) nem hasznal igazi stack-et, hanem szimulalja azt indirekt memoria cimzo utasitasokkal (mivel pl 16F PIC-ben nincs memoria stack csak program szamlalora). Namost ez eleg nagy kodot general ha sok a lokalis valtozo, emiatt trukkoznek egyet, es meg csak szoftver stacket sem csinalnak ha nem szukseges.

Egeszen pontosan azt csinaljak, hogy un. pseudo-staket csinalnak, ami nem mas mint egy overlay-ed memoria terulet a lokalisok es fuggveny parameterek szamara. Ez azt jelenti, hogy nem kell stack frame-et lefoglalniuk a fuggveny belepesekor, es a valtozok hozzaferesenel is direkt cimzest tudnak hasznalni ami joval gyorsabb es kisebb kodot general. Egy-egy ilyen teruletet azonban mas fuggvenyek is hasznalhatnak, es a fordito gondoskodik arrol, hogy amig a fuggveny el (nem leptunk ki belole) addig a valtozok ne legyenek felul irva.

Ezt ugy erik el, hogy a forditas soran felterkepezik ki kit hiv, es igy a fuggvenyvaltozok reszere ugy jelolik ki a teruleteket, hogy azok soha ne tudjanak felul irodni egy masik fuggveny altal, mivel az sohasem hivodhat meg mikor meg a fuggvenyunk el.

Namost, emiatt sok kompromisszumot kell kotni. Pl ahogy mar szo volt rola a CCS nem enged fuggveny pointereket -- tobb, mint valoszinu, hogy ez is ennek koszonheto, hisz akkor nem tudna a fordito, hogy az adott fuggveny honnan hivodik meg. A masik pedig a rekurzio, nem tudom CCS engedi-e vagy sem, de nem csodalkoznek rajta, ha nem, hiszen akkor nem lenne lehetseges ez a fajta technologia. Az egyetlen lehetoseg akkor lenne, ha erre a fuggvenyre megiscsak szoftveresen emulalt stack-et alkalmazna, de akkor a futasi segessegen es a kodmereten ez rogton meg is latszana -- ki kell probalni persze.

Viszont ezt a binaris fa keresest amit leirtal meg lehet oldani rekurzio nelkul is.
(#) p_istvan válasza whalaky hozzászólására (») Jan 13, 2011 /
 
Szervusz!
Szép, de a CCS ismeri a rekurziót?
Más C-ben ugyan rövid lesz a kód, de igen nagy memória kell a veremhez, amiből a PIC nics túlságosan eleresztve...
Bocs, hogy beleszóltam:
István
(#) whalaky válasza p_istvan hozzászólására (») Jan 13, 2011 /
 
Igazatok lehet, PIC-ben nem próbáltam, de szerintem nem kéne hogy pampogjon miatta. Ha pedig már annyira kevés a program memória hogy az if-ek már nem férnek bele megoldás lehet.
Úgy gondolom egy próbát megér.
(#) source2 válasza p_istvan hozzászólására (») Jan 13, 2011 /
 
hi

ha a rekurzív függvényhívásra gondolsz, arra hibát dob.

üdv
(#) vicsys hozzászólása Jan 13, 2011 /
 
Nagyon sokat tanultam most Tőletek! (Na meg szép kis lavinát indítottam) Mégegyszer köszi a "brainstorming"-ot és segítséget!
(#) whalaky válasza p_istvan hozzászólására (») Jan 13, 2011 /
 
Való igaz, nem tűri a rekurziót. Bocs!
(#) whalaky hozzászólása Jan 25, 2011 /
 
Nincs meg valakinek a CCS PICEEC development kit rajza?
Hiába keresem, földön égen nem találom.....
(#) Buddha válasza sysy hozzászólására (») Jan 26, 2011 /
 
Az új változat engem is érdekelne, de sajna nincs 30MB-os leveles ládám.
Nincs feltöltve valahová esetleg?
(#) vilmosd válasza Buddha hozzászólására (») Jan 27, 2011 /
 
Sonsivri-n nincs?
(#) mps hozzászólása Feb 2, 2011 /
 
Sziasztok!
Egy használattal, vagy Mplab-bal, (vagy nem is tudom, hogy fogalmazzam) kapcsolatos kérdésem lenne. Kicsit zavart, hogy a könyvtár tele van mindenféle fájlokkal, ezért gondoltam csinálok egy külön könyvtárat, és egy párat átpakoltatok oda. Több helyen láttam, hogy a kimeneti fájloknak lehet külön könyvtár, no, ezt próbáltam össze hozni. Be is állítgattam, ahogy a mintákból kilestem. Tulajdonképpen működik, csak közben meg meg áll. Először egy :"pic c compiler I/O error 103." hibaüzenet. Leokézom. A compiler ablak csak a tálcán van, nem látni, azért alt+F4-el bezárom. Újabb hibaüzenet:"Mplab ide Fajled to load". Leokézom. Output ablakban pedig minden ok. Le is fordult.
Mi az ami nem tetszik neki?
Ja, a project menü, build options, directories- ban állítottam át az output directorit. Vagyis létrehoztam.
Előre is köszi a válaszokat!
(#) mps hozzászólása Feb 3, 2011 /
 
Szervusztok! Megint gondom van az adc-vel.
Az a bajom, hogy egyrészt nem sok köze van a valósághoz amit kiszámolok, másrészt a potit tekergetve szépen változik a másik érték is. A lábon mérve műszerrel természetesen stabil.
  1. #include <16F690.h>
  2.  
  3. #FUSES NOWDT                      //Watch Dog Timer
  4. #FUSES INTRC                       //HS Oscilator
  5. #FUSES NOPROTECT                //Code not protected from reading
  6. #FUSES NOBROWNOUT               //No brownout reset
  7. #FUSES NOMCLR                   //Master Clear pin used for I/O
  8. #FUSES NOCPD                    //No EE protection
  9. #FUSES NOPUT                    //No Power Up Timer
  10. #FUSES NOIESO                   //Internal External Switch Over mode disabled
  11. #FUSES NOFCMEN                  //Fail-safe clock monitor disabled
  12.  
  13. #use delay(clock=8000000)
  14.  
  15. #include <flex_lcd.c>
  16. #define VSS_VDD
  17.  
  18. Void ini_main(){
  19.  
  20.         setup_adc_ports (sAN0 | sAN2);
  21.         setup_adc(ADC_CLOCK_INTERNAL);
  22. }
  23.  
  24.  
  25. Void main(){
  26.  
  27. unsigned int32 i, mert, poti;
  28.  
  29. float kijel_ertek,potik;
  30. ini_main();
  31.  
  32. delay_ms(100);
  33. lcd_init();
  34.  
  35.  
  36. delay_ms(500);
  37. lcd_putc("Line Number 2");
  38. lcd_putc("\fHallo");
  39. while (1){
  40. set_adc_channel(0);             //"gyári" poti
  41. poti =read_adc();
  42. potik=(poti*4.76)/255;
  43.  
  44.        
  45. set_adc_channel(2);             //9700 sensor
  46. mert = read_adc();
  47. kijel_ertek=(mert*4.76)/255;
  48. delay_ms(100);
  49.  
  50.  
  51.  
  52.                                         lcd_putc('\f');
  53.                                         printf(lcd_putc,"%f",kijel_ertek);
  54.                                         lcd_putc("T:");
  55.                                         printf(lcd_putc,"%f",potik);
  56. delay_ms(500);
  57. }
  58. }

A 4,76 a pic tápja. Mit nem jól teszek? És, hogy lehet mind a 10 bitet kiolvasni? Előre is köszi!
(#) whalaky válasza mps hozzászólására (») Feb 3, 2011 / 1
 
így első ránézésre az hiányzik
#device adc=8
ezt pedig így
setup_adc_ports(sAN0|sAN2|VSS_VDD);

aztán próba cseresznye
(#) szkrep válasza mps hozzászólására (») Feb 3, 2011 / 1
 
Rögtön a legelső sor alá tedd be, hogy "#device adc=10", így 10 bites lesz a mérés (-> int16-ba fér bele).
A csatornaváltás és a mérés közé kell kb 10-20us delay (nem próbáltam kevesebbel), akkor csak az fog változni, aminek kell. Azért számolsz fura dolgokat, mert "poti*4,76" az "integer*float". Próbáld úgy, hogy
  1. set_adc_channel(0);
  2. delay_us(20);
  3. poti =read_adc();
  4. potik=poti;
  5. potik=(potik*4.76)/255; //vagy simán rögtön floatba rakod, de nem tudom, az tetszik-e neki
(#) mps válasza szkrep hozzászólására (») Feb 3, 2011 /
 
Köszi szépen mindkettőtöknek!
Működik! (Elviseli ha egyből floatba rakom)
Következő: »»   50 / 118
Bejelentkezés

Belépés
Hirdetés
XDT.hu
Az oldalon sütiket használunk a helyes működéshez. Bővebb információt az adatvédelmi szabályzatban olvashatsz. Megértettem