Fórum témák

» Több friss téma
Fórum » PIC programozása C nyelven, C-Compiler
Lapozás: OK   61 / 153
(#) _vl_ válasza Amarton hozzászólására (») Szept 1, 2012 /
 
A tömb első elemére mutató pointert szokás C-ben átadni. Azt viszont neked kell tudni, hogy a tömb mekkora, mert ez az információ a pointerré alakítás közben elveszik.
  1. unsigned array1[] = { 1, 2, 3, 4, 5, 6 };
  2. unsigned array2[] = { 10, 20, 30 };
  3. unsigned fv (unsigned *a, unsigned x, unsigned y)
  4. {
  5.   return a[x] * a[y];
  6. }
  7.  
  8. void main()
  9. {
  10.   fv(array1, 2, 4);
  11.   fv(array2, 0, 1);
  12. }
(#) Amarton hozzászólása Szept 8, 2012 /
 
A pic32 starter kitben van egy 18F4550-es PIC, ami össze van kötve a pic32-vel.
Ennek a 18-as PIC-nek hozzá lehet jutni a hex fájljához?
(#) icserny válasza Amarton hozzászólására (») Szept 8, 2012 /
 
Tudtommal nem, a Microchip nem tette közzé a kódot.

Találtam viszont egy német nyelvű topikot ezzel kapcsolatban: Bővebben: link
A hozzászólás módosítva: Szept 8, 2012
(#) diablo hozzászólása Szept 16, 2012 /
 
Sziasztok!
Két fix pontos számot hogy lehetne beszorozni egymással viszonylag egyszerűen? Pl. 8,24 * 42,56 = 350,6944
Én most magamtól csak annyit tudnék csinálni, hogy felszorzom őket 100-zal, (824 * 4256 = 3506944) majd az eredményt beosztom 10000-rel.
Pontosabban:
egészrész = eredmény / 10000; (2 byte)
törtrész = eredmény % 10000; (2 byte)
De szerintem ez megölné a procit, nagyon lassú lenne. Amúgy a törtrész elég lenne 2 tizedes jegy pontossággal is.
Ti hogy csinálnátok?
(#) _vl_ válasza diablo hozzászólására (») Szept 16, 2012 /
 
Nem értem... A fixpontos szám lényege, hogy integerben tárolom, eleve felszorozva mondjuk esetedben 100-zal. Azaz 8,24 helyett az van tárolva, hogy 824. Ezek után minek szorozgatni még?
(#) diablo válasza _vl_ hozzászólására (») Szept 16, 2012 /
 
Nem is a szorzáson volt a hangsúly. Nyilván nem fogok a PIC-ben egy float konstanst tárolni, hogy felszorozhassam 100-zal.
Az osztást tartom elég időigényesnek, meg mondjuk a 2 nagy szám szorzását is (824 * 4256). Amiből mellesleg az egyik érték változhat 200,00-ig is, tehát 20000-rel kellene szoroznom. Nem tudom, hogy egy 8 bites PIC mennyi idő alatt tudná ezt kiszámolni. Véleményem szerint jobb volna ha külön integer-ben tárolnám az egészrészt és a törtrészt, ahogy az összeadásnál is tettem. Mert az eredményből úgyis csak az egészrészt tudom felhasználni (de kell a törtrésszel is számolni a pontosság miatt) és egyszerűbb ha mondjuk az alsó integert elhagyom ami reprezentálja a törtszámokat és nem elosztom az eredményt 100-zal vagy ne adj Isten 10000-rel. De akár ezekből az összeadásokból is származhatna a tört szám és akkor már szorozgatni is kellene, hogy megkapjam pl. a 824-et.
Egy példa: 160 * 9,2 = 1472
Vagyis a PIC-be egy 92 értékű konstanst hozok létre, és ezzel végzem a műveleteket.
Tehát 160*92=14720
De ehhez hozzá kellene adnom még egy egész számot is ami legyen 78. Igen ám de ahhoz, hogy a 78-at hozzá tudjam adni és helyes eredményt kapjak muszáj felszoroznom 10-zel, vagyis 780-at kell hozzáadni, különben az eredmény 10-zel való leosztásakor ('/', '%') helytelen eredményt kapok. Tehát mégiscsak kell szoroznom.

Egyébként kicsit utána nézve a dolognak (na nem nagyon, mert nem sok érthető dolgot találtam ez ügyben) azt találtam, hogy a fix pontos műveleteket egyáltalán nem így végzik ahogy leírtam meg ahogy te is írtad, hanem úgy hogy pl. a 0,5-öt úgy tárolják le egy külön integer változóban, hogy az 16384-nek feleljen meg, a 0,05 pedig 1638-nak és így tovább. Szóval én azt vártam volna, hogy valaki az ilyen számokkal történő műveletvégzések lényegét leírná. De lehet, hogy rossz helyen keresgéltem, mert számomra elég pontatlannak tűnik ez a módszer.
Az viszont biztos, hogy külön tárolják az egészrészt és a törtrészt.

De ha ti sem ismertek hatékonyabb módszert a fent említett osztásos módszernél, akkor inkább hagyjuk az egészet.
(#) icserny válasza diablo hozzászólására (») Szept 16, 2012 /
 
Idézet:
„egészrész = eredmény / 10000; (2 byte)
törtrész = eredmény % 10000; (2 byte)”
Nem tudom, hogy van-e értelme külön tárolni az egészrészt és törtrészt. Én feszültséget mV, hőmérsékletet tizedfok egységekben számolok, s az egészrész meg a törtrész kiszámítása helyett csak kiíratásnál határozom meg a tizedespont helyét. Lásd például ezen az oldalon! Az outdec() függvény így néz ki:
  1. /** Decimális kiíratás adott számú tizedesjegyre.
  2.  * \param data a kiírandó szám (előjelesen)
  3.  * \param ndigits a kiírandó tizedesek száma
  4.  */
  5. void outdec(long data, unsigned int ndigits) {
  6. static char sign, s[12];
  7. unsigned int i;
  8.         i=0; sign='+';
  9.         if(data<0) { sign='-'; data = -data;}
  10.         do {
  11.                 s[i]=data%10 + '0';
  12.                 data=data/10;
  13.                 i++;
  14.                 if(i==ndigits) {s[i]='.'; i++;}
  15.         } while(data>0);
  16.         _user_putc(sign);
  17.         do{
  18.                 _user_putc(s[--i]);
  19.         } while(i);
  20. }

(#) diablo válasza icserny hozzászólására (») Szept 16, 2012 /
 
Helló!
Ha csak én is kiíratni szeretném akkor nem bajlódnék vele, de nekem számolni is kell a törtrésszel és a PIC-be nagy sebességgel érkező impulzusok számát is hozzá kell adnom a törtszámhoz, aminél ha nem tárolom külön az egész- és törtrészt akkor az impulzusok számát fel kellene szoroznom 10-zel, 100-zal, hogy helyes eredményt kapjak az összeadás végén. De most hogy futási időben ugyanott vagyok-e ezzel a külön tárolással mintha beszoroznám az impulzusszámot, azt még át kell gondolnom. De valószínűleg lassabb lenne, mert ami most elfér 2 bájton ahhoz lehet 4 bájtra lenne szükségem ha a ti módszereteket használnám. A számolás végén meg úgyis be kell osztanom és elhagynom a tizedes törtet, mert kijelezni nem akarom, csak a belső számítási folyamatnál van szükség rá.
(#) Hp41C válasza diablo hozzászólására (») Szept 17, 2012 / 1
 
Szia!

Egy átmeneti megoldás, ha a 350,6096649169921875 megfelel a 350.6944 helyett.

Használjunk 4 byte -os egészeket a műveletek végzésére, a bináris törtpont legyen középen. Ekkor a 8.42 * 42.56 az alábbi longint szorzásra vezet : 0x83D * 0x2A8F. Elvégezve a 0x15E9C13 értéket kapjuk. Értelmezve a 0x15E egészet és 0x9C13 törtrészt: 350 + ( 39955/ 65536) = 350.6096649169921875 értékhez jutunk.
A fenti módszer szerint végezzük a szorzást, de elvégezhetjük az összeadást is. Pl. ha egy egészet (dec. -49 ) akarunk a fenti számhoz hozzáadni, akkor megtehetjük az alábbi módon:
0x15E9C13 + ( dec -49) = 0x15E9C13 + 0xFFCF0000 = 0x012D9C13 átszámolva: 301.6096649169921875

A műveletekhez nem kellett szorozni, osztani, csak a számokat 16.16 bites (bináris egész).(bináris tört) formában kell megadni.

BCD konvertálás a kijelzéshez:
Nem kell osztást és moduló művelet végezni (egy 24 bites számnál ez 16 egész osztás, azaz 256 léptetés, ha valaki megnézi az assembly kódot...). Elég a léptetés művelet (a fenti esetet véve csak 24 db.). Ez a rutin egy 24 bites számot konvertál 8 digit pakolt BCD formára 24 léptetéssel és korrigálással - osztás és moduló nélkül.
(#) trudnai válasza diablo hozzászólására (») Szept 17, 2012 /
 
Miert nem jo neked amugy a float tipussal szamolni?

Itt egy lehetseges megoldas ahol a tort resz es az egesz resz kulon van szedve:

  1. #define tizedesek 100
  2.  
  3. unsigned a_egesz =  8; unsigned a_tort = 24;
  4. unsigned b_egesz = 42; unsigned b_tort = 56;
  5.  
  6. szorzas()
  7. {
  8.  
  9.     unsigned c_egesz  = ( a_egesz * b_egesz )
  10.                       + ( ( a_egesz * b_tort  ) /  tizedesek )
  11.                       + ( ( a_tort  * b_egesz ) /  tizedesek )
  12.                       + ( ( a_tort  * b_tort  ) / ( tizedesek * tizedesek ) );
  13.  
  14.     unsigned c_tort   = ( ( a_egesz * b_tort  ) % tizedesek )
  15.                       + ( ( a_tort  * b_egesz ) % tizedesek )
  16.                       + ( ( a_tort  * b_tort  ) / tizedesek );
  17.  
  18.     printf( "c = %u.%u", c_egesz, c_tort );
  19. }
(#) trudnai válasza Hp41C hozzászólására (») Szept 18, 2012 /
 
Szia, en meg mindig probalom kibogozni mire gondoltal. Azt irod:

Idézet:
„Ekkor a 8.42 * 42.56 az alábbi longint szorzásra vezet : 0x83D * 0x2A8F. Elvégezve a 0x15E9C13 értéket kapjuk”


Ahol a 0x8 az ugye dec 8 az stimmel, 0x2A az is stimmel mert az dec 42, name a 0x3D es a 0x8F az mar nem tunik jonak, mert nem .42 ill .56 ... Hogyan jott ki neked ez az ertek?

(#) Hp41C válasza trudnai hozzászólására (») Szept 18, 2012 /
 
Szia!
Idézet:
„Idézet:
„Ekkor a 8.42 * 42.56 az alábbi longint szorzásra vezet : 0x83D * 0x2A8F. Elvégezve a 0x15E9C13 értéket kapjuk”

Sajnos már itt elírtam, eredetileg 8.24 * 42.56 -ről volt szó. A többi jó.
Ezek bináris törtszámok:
  1. 0x08 0x3d  =>  8 + ( 61 / 256) =  8.23828125
  2. 0x2A 0x8F  => 42 + (143 / 256) = 42.55859375
(#) trudnai válasza Hp41C hozzászólására (») Szept 18, 2012 /
 
Ja, ertem mar mit csinalsz, vegulis 256-tal felszorzod a tort reszt, hogy egeszeket kapj, es azzal szamolsz, majd pedig kiirasnal pedig be kell szorozni 100-al utana elosztani 65536-tal, hogy integerkent kiirhato legyen.

Amugy meg mindig azt mondanam a beepitett floatokkal egyszerubb es gyorsabb lenne szamolni.
(#) fordkapcs hozzászólása Szept 18, 2012 /
 
Sziasztok! PIC programozásban nagyon kezdő vagyok. Viszont C nyelven már programoztam (PC-n).
A közeljövőben PIC18F-el kellene egy áramkört építenem, ami analóg értékeket mér (12bites felbontással), és kb. 2x 15...20 digitális In/Out adatot fogad/küld, illetve soros porton (UART - RS232) is fogadja/továbbítja az adatokat. Valamint 2x16-os karakteres LCD-n is kellene adatokat megjelenítenie.
A kérdésem, melyik C fordítót lenne érdemes használnom? Melyiknek elég jó pl. a helpje, hogy gyorsan beletanuljak, és viszonylag hamar érhessek el eredményt? Melyikben van sok függvény gyárilag megvalósítva (hogy ne nekem kelljen megírni), pl. soros port kezelés pufferelés, LCD kezelés stb... Tehát merre induljak el?
Esetleg konkrét PIC tipust is tud valaki ajánlani a feladatra (ami később is beszerezhető lesz - tehát pl. nem kifutó tipus)?
A hozzászólás módosítva: Szept 18, 2012
(#) diablo válasza Hp41C hozzászólására (») Szept 18, 2012 /
 
Szia!
Valami ilyesmire gondoltam én is, hogy csak tologatni kelljen a biteket. A pontosság talán megfelel. Köszi!

Egyébként ha C-ben azt írom le, hogy x/256 vagy x/65536, akkor a fordító igaz tudni fogja, hogy csak tologatni kell, nem kell a << és >> operátorokat használnom?
(#) Hp41C válasza trudnai hozzászólására (») Szept 18, 2012 /
 
Szia! Egy float szorzás gyors, de egy összeadás már nem. Hiszen két float számot összeadni csak úgy lehet, hogy előbb azonos kitevőre kell hozni őket, aztán összeadni és végül visszanormálni a float alakra. A fenti számolásomban nincs 256 -tal, 65536 -tal való szorzás vagy osztás, hiszen azt a megfelelő byte elővételével vagy beírásával meg lehet tennni. Az összeadás egy longint összeadás, persze az összeadandókat a megfelelő helyiértékre kell beírni, a többit ki kell nullázni. A szorszásnál van egy kis stikli. (8 bit egész és 8 bit tört) szorozva (8 bit egész és 8 bit tört) -tel ad (16 bit egész és 16 bit tört) -et. A kiírási BCD formára hozáskor lesz még egy szorzás (10 annyiadik hatványával, ahány tizedest szeretnénk). Magához a BCD átalakításhoz elég az egészek és a törtrész bitszámának megfelelő számú léptetés. Összességében jóval kevesebb művelet, mint a 8.24 * 42.56 + 0.23 művelet float számokkal elvégezve...
(#) diablo válasza trudnai hozzászólására (») Szept 18, 2012 /
 
Ti mondtátok, hogy ne számoljak float-okkal mert időigényes, úgyhogy ne gyere nekem most azzal, hogy használjak float-ot!
(#) wolf84 hozzászólása Szept 18, 2012 /
 
Sziasztok!

olyan problémám van beviszek 7 ascii számot ebből szertnék ki vonni másik 7 ascci számot ezt hogy tudnám megvalósítani?
lenti kódom nincs benne a kivonás csak átalakítás hogy majd eltudjam végezni a kivonást 4 ascii karakterig jó csak utána - eredményt kapok az 5. számtól...
előre is köszönöm a válaszokat!!!

  1. int res;
  2. unsigned char Lcd_temp[7];                                    
  3. unsigned char K1[7];                                    // 1 számláló kezdő érték mentés helye
  4.  
  5.                                strConstCpy(K1, kp_buf);  // mentem a keypad buffert a K1
  6.                                 res = atoi(K1);
  7.                                 IntToStr(res, Lcd_temp);
  8.                                 LCD_Out(2, 4, "       ") ;
  9.                                 LCD_Out(2, 4, Lcd_temp) ;
A hozzászólás módosítva: Szept 18, 2012
(#) Hp41C válasza wolf84 hozzászólására (») Szept 18, 2012 /
 
Szia!

Az unsigned int általában 16 bites, azaz maximális ábrázolható szám 65536. Használj unsigned long típust, abban elvégezheted a 7 decimális számjeggyel történő számítást.
A hozzászólás módosítva: Szept 18, 2012
(#) wolf84 válasza Hp41C hozzászólására (») Szept 18, 2012 /
 
Kösszi a segítséget! már majd nem jó, csak Longtostr-nél át másolom a LCD_temp-be belevisz 4 karaktert pluszba vagyis 4-helyi értékel később írja ki LCD_Out(2, 4, Lcd_temp) ; vagyis a 4 helyi értékbe nincs semmi azt is kiírja ezt valahogy ki lehetne küszöbölni?
(#) wolf84 válasza wolf84 hozzászólására (») Szept 18, 2012 /
 
elöző kérdésemet át fogalmazom
char Lcd_temp[6];
ebből hogy lesz "Lcd_temp[13];" vagyis longtostr hogy rak bele plusz karaktert ha 7 karaktere van definálva Lcd_temp?
(#) Hp41C hozzászólása Szept 18, 2012 /
 
Sziasztok!
Ismerkedek az új XC8 fordítóval. A rutinok forrását nézegetve találtam egypár gyöngyszemet:
cos.c:
  1. #include        <math.h>
  2. #ifdef  i8086
  3. extern int      _use8087;
  4. extern double   _cos87(double);
  5. #endif
  6. #define PI      3.14159265358979
  7. #define TWO_PI  6.28318530717958
  8. #define HALF_PI 1.570796326794895
  9. double
  10. cos(double f)
  11. {
  12. #ifdef  i8086
  13.         if(_use8087)
  14.                 return _cos87(f);
  15. #endif
  16.         /* cos is pi/2 out of phase with sin, so ... */
  17.         if(f > PI)
  18.                 return sin(f - (PI+HALF_PI));
  19.         return sin(f + HALF_PI);
  20. }

Ezek után nem meglepő a sin.c és a tan.c is tartalmas i8086 és i8087 -re való utalásokat.
Még az is lehet, hogy a 6 lábú PIC10F320 mellé beköthetünk egy levedlett Intel 8087 kooprocesszort is?
(#) icserny válasza Hp41C hozzászólására (») Szept 18, 2012 /
 
Idézet:
„a 6 lábú PIC10F320 mellé beköthetünk egy levedlett Intel 8087 kooprocesszort is?”
Nem, ez akkor kell, ha a PIC10F320-ra írt alkalmazást PC-re portolod.
(#) Hp41C válasza icserny hozzászólására (») Szept 19, 2012 /
 
Idézet:
„PIC10F320-ra írt alkalmazást PC-re portolod”
Aggódok... Akkor miért nincs a többi float műveletben? A szegény szerencsétlen Pentum mit_tudom_én_hány kénytelen lesz a float osztást, szorzást, összeadást stb. maga megcsinálni a kooprocesszora helyett. Kicsit sánta ez így...

Én inkább a slendriánságot vélem felfedezni...
(#) trudnai válasza Hp41C hozzászólására (») Szept 20, 2012 /
 
Szerintem nem erdemes teljesen bele bonyolodni ebbe, egyreszt nem tudjuk (vagy legalabbis en nem tudom), hogy milyen mas platformokra is szeretnek forditani a kodot, masreszt azt sem tudjuk, az azon a platformon hasznalt X vagy Y fordito amivel az eredeti kodot forditani szandekoztak milyen definiciokat keszit ha a target Pentium pl (konnyen lehet ott van az az i8086 is).

A lenyeg a Te semszogodbol most, hogy toroldd ki az ifdef-ek kozotti reszeket, neked az most ugy sem kell es igy tisztabban fogod latni mit csinal a kod...
(#) wolf84 hozzászólása Szept 21, 2012 /
 
sziasztok!

mikroc-vel van pár rossz tapasztalatom... melyik fórdított lenne érdemes helyette használnom... amivel nincs annyi gond mint a mikrocvel....
előre is köszi válaszotokat!
(#) Peppe válasza wolf84 hozzászólására (») Szept 21, 2012 /
 
Mi a bajod a MikroC-vel én azt használom és tökéletes. Komoly rendszert(PIC18+uSD+MP3 decoder+LCD+RS-485+RS232) is meglehet benne írni. 2 éve használom és nem váltanék másra. Igen vannak betegségei de melyik fordítónak nincs?

Ha leírod a problémád lehet tudunk rajta segíteni.
A hozzászólás módosítva: Szept 21, 2012
(#) wolf84 válasza Peppe hozzászólására (») Szept 22, 2012 /
 
Szia

előre is bocsi nem a másik topicba írtam!!!
Én is sok mindent megcsináltam már vele dallas kulcsos eeprom szimulálása stb...
eddig jó tapasztalataim voltak mikrocvel.
de jártam már úgy is vele hogy,
TRISA = 0b1101111;
de muszáj volt beírni utána hogy
TRISA7_bit = 1;
mert valahogy nem lett bemenet az a láb. persze többi láb jó beállt.

de a beépített keypad lib-el is úgy jártam csak 8 gombnál kifagyott a program, persze a többi gombott olvasta rendesen ezért váltottam másik keypad lib-re.

mostani kódnál az egyik dolog amit nem értek ha én lefoglalom pl. lcd_temp 7karatere hogy írhat bele többet? oké tudom nullákat is kiratom de akkor is
másik dolog egyik helyen múködik atol parcs máshol nem... érdekes

  1. #include        "keypad_lib.h"          // keypad library header, includes also user's settings
  2.  
  3. // LCD module connections
  4. sbit LCD_RS at RB4_bit;
  5. sbit LCD_EN at RB5_bit;
  6. sbit LCD_D4 at RB0_bit;
  7. sbit LCD_D5 at RB1_bit;
  8. sbit LCD_D6 at RB2_bit;
  9. sbit LCD_D7 at RB3_bit;
  10.  
  11. sbit LCD_RS_Direction at TRISB4_bit;
  12. sbit LCD_EN_Direction at TRISB5_bit;
  13. sbit LCD_D4_Direction at TRISB0_bit;
  14. sbit LCD_D5_Direction at TRISB1_bit;
  15. sbit LCD_D6_Direction at TRISB2_bit;
  16. sbit LCD_D7_Direction at TRISB3_bit;
  17. // End LCD module connections
  18.  
  19.  
  20.  unsigned long res1;
  21.  unsigned long res2;
  22.  unsigned long x;
  23.  
  24.   char txt3[] = "Lcd4bit";
  25.  
  26. char tovabb;
  27. unsigned char Lcd_temp3[6];                                    // 1 számláló kezdõ érték mentés helye
  28. unsigned char Lcd_temp1[6];                                    // 1 számláló kezdõ érték mentés helye
  29. unsigned char Lcd_temp2[6];                                    // 1 számláló kezdõ érték mentés helye
  30.  
  31.  
  32. signed char K1[7];                                    // 1 számláló kezdõ érték mentés helye
  33. signed char V1[7];                                    // 1 számláló vég érték mentés helye
  34. static char K2[7];                                    // 2 számláló kezdõ érték mentés helye
  35. static char V2[7];                                    // 2 számláló vég érték mentés helye
  36. static char K3[7];                                    // 3 számláló kezdõ érték mentés helye
  37. static char V3[7];                                    // 3 számláló vég érték mentés helye
  38. static char K4[7];                                    // 4 számláló kezdõ érték mentés helye
  39. static char V4[7];                                    // 4 számláló vég érték mentés helye
  40. static char K5[7];                                    // 5 számláló kezdõ érték mentés helye
  41. static char V5[7];                                    // 5 számláló vég érték mentés helye
  42.  
  43.  
  44.  
  45.  
  46. void strConstCpy(char *dest,  char *source){  //ram to ram
  47.      while(*source)
  48.         *dest++ = *source++;
  49.        
  50.         *dest = 0;
  51.       }
  52.      
  53. void    interrupt(void)
  54.         {
  55.         if (TMR0IF_bit){
  56.                 kp_isr() ;                      // call keypad service routine
  57.  
  58.                   TMR0H         = 0x05;
  59.                   TMR0L         = 0xFF;
  60.  
  61.                   TMR0IF_bit = 0;
  62.                 }
  63.         }
  64.  
  65. void    main()
  66.         {
  67.    //OSCCON = 0b01110011 ; // INTERNAL OSC 16MHZ
  68.        OSCCON = 0b01100011 ; // INTERNAL OSC 8MHZ
  69.   //OSCCON = 0b01010011 ; // INTERNAL OSC 4MHZ
  70.  
  71.                 ANSELA  = 0;
  72.         ANSELB  = 0;
  73.         ANSELC  = 0;
  74.         ANSELD  = 0;
  75.  
  76.         CM1CON0 = 0x00;   // Disable comparators
  77.         CM2CON0 = 0x00;   // Disable comparators
  78.  
  79.         ADCON1 = 0x0F;  // Disable Analog functions All pins as digital I/O
  80.  
  81.         /*
  82.          * init LCD
  83.          */
  84.                 Lcd_Init();                              // Initialize LCD
  85.                 Lcd_Cmd(_LCD_CLEAR);                     // Clear display
  86.  
  87.                  Lcd_Cmd(_LCD_CURSOR_OFF);                // Cursor off
  88.                  kp_flush() ;                            // BEJEGYZÉS buffer törlése
  89.  
  90.         /*
  91.          * init keypad and library
  92.          */
  93.         kp_init() ;
  94.  
  95.         /*
  96.          * configure timer0 rollover interrupt
  97.          * period is Fosc / 4 / 256
  98.          */
  99.              T0CON         = 0x88;
  100.   TMR0H         = 0x05;
  101.   TMR0L         = 0xFF;
  102.   GIE_bit         = 1;
  103.   TMR0IE_bit         = 1;
  104.   tovabb =0 ;
  105.  
  106.    while (1){
  107.                     Lcd_Cmd(_LCD_CLEAR);               // Clear display
  108.                     Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
  109.                     Lcd_Out(1,6,txt3);
  110.                     Delay_ms(1500);
  111.                     Lcd_Cmd(_LCD_CLEAR);               // Clear display
  112.                     tovabb = 1;
  113.                     do{
  114.                      if(kp_hit())                    // ha a gombot lenyomják
  115.                         {
  116.                         LCD_Cmd(_LCD_CURSOR_OFF) ;                       // nincs kurzor
  117.  
  118.                         if(kp_enter())                                  //  ha az enter gomb megnyomása
  119.                                 {
  120.                                 strConstCpy(K1, kp_buf);
  121.                                 kp_flush() ;                            // BEJEGYZÉS buffer törlése
  122.                                 tovabb = 0;
  123.                                 res1 = atol(K1);                        // itt möködik
  124.                                 LongIntToStrWithZeros(res1, Lcd_temp1);  // elmentem a késõbbi ellenõrzéshez
  125.                                 continue;                              // nem volt itt valamiért ki fagyott
  126.                                 }
  127.  
  128.                         LCD_Chr(1, 16, kp_last()) ;                     // megjeleníteni utolsó karakter gépeltek be
  129.  
  130.                         LCD_Out(1, 1, "       ") ;             //  törlése régi buffer megjelenítése
  131.                         LCD_Out(1, 1, kp_buf) ;                         // megjeleníteni aktuális puffer
  132.  
  133.                         LCD_Cmd(_LCD_BLINK_CURSOR_ON) ;
  134.                         }
  135.                       } while ( tovabb == 1);
  136.                         tovabb = 1;
  137.                     do{
  138.                      if(kp_hit())                    // ha a gombot lenyomják
  139.                         {
  140.                         LCD_Cmd(_LCD_CURSOR_OFF) ;                       // nincs kurzor
  141.  
  142.                         if(kp_enter())                                  //  ha az enter gomb megnyomása
  143.                                 {
  144.                                 strConstCpy(V1, kp_buf);
  145.                                 kp_flush() ;                            // BEJEGYZÉS buffer törlése
  146.                                 tovabb = 0;
  147.                                 res2 = atol(V1);
  148.                                 LongIntToStrWithZeros(res2, Lcd_temp2);
  149.                                 continue;
  150.                                 }
  151.  
  152.                         LCD_Chr(1, 16, kp_last()) ;                     // megjeleníteni utolsó karakter gépeltek be
  153.  
  154.                         LCD_Out(1, 1, "       ") ;             //  törlése régi buffer megjelenítése
  155.                         LCD_Out(1, 1, kp_buf) ;                         // megjeleníteni aktuális puffer
  156.  
  157.                         LCD_Cmd(_LCD_BLINK_CURSOR_ON) ;                  // blink cursor
  158.                         }
  159.                       } while ( tovabb == 1);
  160.                         tovabb = 1;
  161.  
  162.                         // elsõ ellemõrzés ki iratom  keypad mentett buffert
  163.                          Lcd_Cmd(_LCD_CLEAR);               // Clear display
  164.                         Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
  165.                         LCD_Out(1, 1, K1) ;
  166.                         LCD_Out(2, 1, V1) ;
  167.                         delay_ms(2500);
  168.                          // második ellenõrzés ki iratom atol után vissza alakított számokat
  169.                          Lcd_Cmd(_LCD_CLEAR);               // Clear display
  170.                         Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
  171.                         LCD_Out(1, 1, Lcd_temp1) ;
  172.                         LCD_Out(2, 1, Lcd_temp2) ;
  173.                         delay_ms(2500);
  174.  
  175.                         // ez már itt nem müködik
  176.                         Lcd_Cmd(_LCD_CLEAR);               // Clear display
  177.                         Lcd_Cmd(_LCD_CURSOR_OFF);          // Cursor off
  178.                         res1 = atol(K1);
  179.                         LongIntToStrWithZeros(res1, Lcd_temp1);
  180.                         LCD_Out(1, 1, Lcd_temp1) ;
  181.                         res2 = atol(V1);
  182.                         LongIntToStrWithZeros(res2, Lcd_temp2);
  183.                         LCD_Out(2, 1, Lcd_temp2) ;
  184.                         Delay_ms(2500);
  185.  
  186.                         //ez se mûködött
  187.                         res1 = atol(K1);
  188.                         res2 = atol(V1);
  189.  
  190.                          x = res1 - res2;    //figyelek ne lehessen minusz
  191.                                              // hogy lehetne amúgy minusz számjegyû számot lekezelni?
  192.  
  193.                          LongIntToStrWithZeros(x, Lcd_temp3);
  194.                          LCD_Out(2, 1, Lcd_temp3) ;                         // megjeleníteni aktuális puffer
  195.                          Delay_ms(4500);
  196.  
  197.                }
  198.         }


előre is köszi a segítséget!
A hozzászólás módosítva: Szept 22, 2012
(#) Peppe válasza wolf84 hozzászólására (») Szept 22, 2012 /
 
Idézet:
„TRISA = 0b1101111;
de muszáj volt beírni utána hogy
TRISA7_bit = 1;
mert valahogy nem lett bemenet az a láb. persze többi láb jó beállt.”


Na igen ez betegség, ilyenbe már többször belefutottam én is.
Melyik verziót használod? A legújabb már okés ilyen hibákra.

Az hogy lefoglalsz 7 karaktert nem azt jelenti, hogy csak 7 karaktert enged beleírni futási időben. Futási időben akár 1000karaktert is beleírhatsz csak felül fog írni más változókat. Ebből lehet később hibás számítás vagy lefagyás.
A parancs anomália már érdekes. Ezt is meg kell debugollni.

(#) wolf84 válasza Peppe hozzászólására (») Szept 22, 2012 /
 
hát pedig a legújabb verzió volt... bemenet probléma
7 karakter oké hogy tobbit bele írja de hogy olvassa ki?
amúgy ha elhagyom a withzero parancsot akkor is úgyan úgy rossz...

A hozzászólás módosítva: Szept 22, 2012
Következő: »»   61 / 153
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