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

» Több friss téma
Fórum
Keresés
Lapozás: OK   1 / 1
(#) icserny válasza uli hozzászólására (») Ápr 30, 2014
Ezen az oldalon mindjárt az első mintapélda is tartalmazza az sw_uart_outdec() függvényt, amelyet könnyen át lehet írni LCD kijelzésre (a függvény nevét, meg az egy karaktert kiíró sw_uart_putc() hívásokat kell megváltoztatni benne.
(#) szitko hozzászólása Márc 12, 2013
Sziasztok.

Egy kicsit bizonytalan vagyok. Összehoztam egy egyszerű fordulatszámmérőt, de nem vagyok benne biztos, hogy jól számoltam-e.
A hardverről csak annyit, hogy egy CD-ből kioperált motorra ragasztottam egy mágnest, és elé raktam egy HALL szenzort (TLE4905), és a jelét egy ellenállás osztón keresztül kapja meg a g2231 capture modulja. (természetesen 100nF-al szűrve)
Beállítottam a motor fordulatszámát ~6000-re, de szerintem nem forog annyit a motor. Hogy tudnám azt leellenőrizni, hogy jó-e a mért értékem?
Prog:
  1. while(1){
  2.           if(uart){
  3.                _DINT();
  4.                P1OUT ^= BIT0;
  5.                long captured=0, cap_val=0;
  6.                unsigned int captured_rpm=0, captured_hz=0;
  7.                for(char j=1; j<6;j++){
  8.                     cap_val += capture_buffer[j];
  9.                }
  10.                captured = cap_val / 5;
  11.                captured_hz = frequency / captured;
  12.                captured_rpm = (captured_hz<<2)+(captured_hz<<1);
  13.                sw_uart_puts("\r\nFrequency = ");
  14.                sw_uart_outdec(captured_hz,0);
  15.                sw_uart_puts(" Hz Fordulat = ");
  16.                sw_uart_outdec(captured_rpm,0);
  17.                sw_uart_puts(" RPM");
  18.           }
  19.           __low_power_mode_0();
  20.      }
  21. }
  22.  
  23. #pragma vector=TIMERA1_VECTOR
  24. __interrupt void TimerA1(void){
  25.      new_capture = TACCR1;
  26.      capture_buffer[count++] = new_capture - old_capture;
  27.      if (count==6){
  28.           count=0;
  29.           uart=1;
  30.           TACCTL1 &= ~CCIFG;
  31.           __low_power_mode_off_on_exit();
  32.      }
  33.      old_capture = new_capture;
  34.      TACCTL1 &= ~CCIFG;
  35. }
A hozzászólás módosítva: Márc 12, 2013

Capture_2.jpg
hardv_2.jpg		   
(#) szitko válasza icserny hozzászólására (») Márc 10, 2013
Valóban!
Köszönöm. Egy másik MCU-val (g2252) előállítottam, szkóp és freki mérő szerint pontosan 500Hz-et. Ezt mérem a g2231-el, a lenti programmal, és a kiírt eredmény "1974". Nem 2000 kéne legyen?
Kiíró és számoló rutin:
  1. while(1){
  2.           if(uart){
  3.                _DINT();
  4.                P1OUT ^= BIT0;
  5.                captured=0;
  6.           for(char j=1; j<6;j++){
  7.                captured += capture_buffer[j];
  8.           }
  9.           captured /=5;
  10.                sw_uart_outdec(captured,0);
  11.                sw_uart_puts("\r\n");
  12.           }
  13.           __low_power_mode_0();
  14.      }

Capture_2.jpg		    
(#) szitko válasza ban.laszlo hozzászólására (») Jan 20, 2013
A program elején (#define LCM_PIN_RS BIT0......) található az LCD bekötése:
LCD RS=P1.0, LCD EN=P1.1 stb.
Ezek után, az "int main(){" részben vedd ki kommentből az inicializálást, és a képernyő törlést, állítsd be a kurzor pozíciót, és az UART küldés után, elé, rakd be a HD44780_outdec..... sort.
(#) icserny hozzászólása Nov 20, 2012
Az MSP430G2553 hardveres UART full duplex használatához portoltam a PICula projektemben kidolgozott szoftveres bufferelésű (gyűrű táras) és interruptos kezelésű uart_putc(), uart_getc() függvényeket.

Használata: A projektekbe fel kell venni a hw_uart_buf.c állományt, s a fenti függvényket használó fordítási egységekbe (pl. főprogram) be kell csatolni hw_uart_buf.h fejléc állományt.

Egy kis bónusz: IAR EW esetén ha felüldefiniáljuk a putchar() függvényt, akkor a printf() függvény is használható a kiírásra. Ugye, milyen egyszerű? Mintapélda:
  1. #include <msp430.h>
  2. #include <stdint.h>
  3. #include <stdio.h>
  4. #include "hw_uart_buf.h"
  5.  
  6. int putchar(int outChar) {
  7.   uart_putc((uint8_t)outChar);
  8.   return outChar;
  9. }
  10.  
  11. char c;
  12. int main( void ) {
  13.   WDTCTL = WDTPW + WDTHOLD;            //Letiltjuk a watchdog időzítőt
  14.   DCOCTL = CALDCO_1MHZ;                //DCO beállítása a gyárilag kalibrált
  15.   BCSCTL1 = CALBC1_1MHZ;               //1 MHz-es frekvenciára  
  16.   uart_init(BPS_9600);
  17.   printf("NLIsten hozott a Launchpad projekthez!");
  18.   printf("hello_print program (hw_uart_buf)NL");
  19.   while (1) {
  20.     c=uart_getc();
  21.     printf("Vett karakter: %c = %dNL",c,c);
  22.   }
  23. }



Ha a printf() függvényt nem akarjuk használni, akkor a kiíratást a hw_uart_buf.c állományban definiált (itt már többször bemutatott) függvények segitségével is végezhetjük. Például így:
  1. #include <msp430.h>
  2. #include <stdint.h>
  3. #include "hw_uart_buf.h"
  4.  
  5. char c;
  6. int main( void ) {
  7.   WDTCTL = WDTPW + WDTHOLD;            //Letiltjuk a watchdog időzítőt
  8.   DCOCTL = CALDCO_1MHZ;                //DCO beállítása a gyárilag kalibrált
  9.   BCSCTL1 = CALBC1_1MHZ;               //1 MHz-es frekvenciára  
  10.   uart_init(BPS_9600);
  11.   uart_puts("NLIsten hozott a Launchpad projekthez!NL");
  12.   uart_puts("hello_int program (hw_uart_buf)NL");
  13.   while (1) {
  14.     c=uart_getc();
  15.     uart_puts("Vett karakter: ");
  16.     uart_putc(c);
  17.     uart_puts(" = ");
  18.     uart_outdec((int32_t)c,0);
  19.     uart_puts(" NL");
  20.   }
  21. }


Megjegyzések:
1. Sajnos, a fórummotor nem engedi berakni a newline karaktereket, ezért NL-lel helyettesítettem!
2. Az IAR EW projekt opcióknál célszerű a printf függvény használatát "Auto"-ra állítani, hogy fölösleges formátumok kezelésével ne tömje tele a programunkat.

hw_uart_buf.c
hw_uart_buf.h
hello_print.png		  
(#) icserny hozzászólása Okt 1, 2012
HIBAIGAZÍTÁS:

Hibát találtam a mintaprogramjaimban használt számkiírató eljárás működésében: Ha a kiírandó érték a 10-zel történő osztásoknál "elfogy", mielőtt a tizedespontot kiírnánk, akkor a tizedes pont nem kerül kiírásra, s így hamis lesz a kiírt érték. Például 0.075V helyett 75V eredményt kapunk!

Javítás: A hiba orvoslására figyelnünk kell azt is, hogy legalább annyi számjegyet mindenképp írassunk ki, mint ahány tizedesjegyet ki akartunk íratni.

Példa: Az alábbi példában legalább egy számjegyet kiíratunk a tizedespont előtt, tehát az értéktelen nulla egész is kiírásra kerül (pl. .735 helyett 0.735).
  1. /**------------------------------------------------------------
  2.  * Decimális kiíratás adott számú tizedesjegyre.
  3.  *-------------------------------------------------------------
  4.  * data - a kiírandó szám (előjelesen)
  5.  * ndigits - a kiírandó tizedesek száma
  6.  */
  7. void sw_uart_outdec(int32_t data, uint8_t ndigits) {
  8.   static char sign, s[12];
  9.   uint8_t i;
  10.   i=0; sign='+';
  11.   if(data<0) { sign='-'; data = -data;}
  12.     do {
  13.       s[i]=data%10 + '0';
  14.       data=data/10;
  15.       i++;
  16.       if(i==ndigits) {s[i]='.'; i++;}
  17.     } while(data > 0 || i < ndigits+2);
  18.     sw_uart_putc(sign);
  19.     do {
  20.       sw_uart_putc(s[--i]);
  21.     } while(i);
  22. }

További módosítási lehetőség: A sign='+'; utasításban a pluszjel helyett szóközt is írhatunk a fölösleges előjel kiíratásának elkerülésére.
A hozzászólás módosítva: Okt 1, 2012
(#) icserny válasza ban.laszlo hozzászólására (») Szept 6, 2012
Nézz szét a topikban ("outdec" a varázsszó), találsz rá megoldást! A hőmérsékletet tizedfok egységekre konvertáld, s a kiíratásnál jelezzük, hogy egy tizedesre kérjük a kiíratást.

Ugyanezt a módszert használom soros porti kiíratásnál is. Bővebben: link.
(#) icserny válasza szitko hozzászólására (») Júl 12, 2012
Nem szép dolog, hogy az átlagolást nem kettő hatványa szerint csinálod! (16 vagy 32 minta esetén az osztás jobbra léptetéssel megoldható).

A negatív számokat én a kiíratásnál ellenőrzöm, az if(data<0) { sign='-'; data = -data;} sorban.

Unsigned változó esetén így kellene: if((a=b)>32767) a= 65536-a; (Itt a az unsigned16 b pedig az előjeles változó)


  1. /**------------------------------------------------------------
  2.  * Decimális kiíratás adott számú tizedesjegyre.
  3.  *-------------------------------------------------------------
  4.  * data - a kiírandó előjeles szám (int32_t)
  5.  * ndigits - a kiírandó tizedesek száma (uint8_t)
  6.  */
  7. void sw_uart_outdec(int32_t data, uint8_t ndigits) {
  8.   static char sign, s[12];
  9.   int8_t i;
  10.   i=0; sign=' ';
  11.   if(data<0) { sign='-'; data = -data;}
  12.     do {
  13.       s[i]=data%10 + '0';
  14.       data=data/10;
  15.       i++;
  16.       if(i==ndigits) {s[i]='.'; i++;}
  17.     } while(data>0);
  18.     sw_uart_putc(sign);
  19.     do {
  20.       sw_uart_putc(s[--i]);
  21.     } while(i);
  22. }


A te kódrészleted számomra értelmezhetetlen, mert a változó típusokat nem adtad meg benne.
(#) icserny hozzászólása Júl 4, 2012
A belső hőmérő használata gyári kalibrációs adatokkal

Az MSP430G2452 és MSP430G2553 mikrovezérlők az ADC-hez is tartalmaznak gyári kalibrációs adatokat. A fejléc állományokban azonban nincs definiálva hozzájuk szimbolikus név, ezért vagy a programunkba, vagy a fejléc állományokba helyezzük el az alábbi sorokat:
  1. /* ADC10 Calibration Data - added by I. Cserny */
  2. __no_init unsigned __READ int CAL_ADC_25T85 @ 0x10EA;
  3. __no_init unsigned __READ int CAL_ADC_25T30 @ 0x10E8;
  4. __no_init unsigned __READ int CAL_ADC_25VREF_FACTOR @ 0x10E6;
  5. __no_init unsigned __READ int CAL_ADC_15T85 @ 0x10E4;
  6. __no_init unsigned __READ int CAL_ADC_15T30 @ 0x10E2;
  7. __no_init unsigned __READ int CAL_ADC_15VREF_FACTOR @ 0x10E0;
  8. __no_init unsigned __READ int CAL_ADC_OFFSET @ 0x10DE;
  9. __no_init unsigned __READ int CAL_ADC_GAIN_FACTOR @ 0x10DC;


A definíciókból kihagytam a volatile módosítót, feltételezve, hogy programfutás közben úgysem változnak ezek az adatok...

A CAL_ADC_GAIN_FACTOR és az CAL_ADC_OFFSET elvileg az ADC-ből kiolvasott eredmény korrekciójához kell. Nálam ezek annyira közel esnek 1-hez és 0-hoz, hogy nem érdemes veszkődni vele.

A mellékelt programban a 2,5 V-os belső referenciát használjuk, ezért a belső hőmérő kiolvasott értékének átszámításához a 2,5 V-os referenciával 30 és 85 fokon mért értékeket használjuk a C-fokra történő átszámításhoz, lineáris összefüggést feltételezve:

  1. TCelsius = 55 * (ADC10MEM - CAL_ADC_25T30)/(CAL_ADC_25T85 - CAL_ADC_25T30) + 30;


Vagyis a 30 fokhoz viszonyítunk, s az 55 fokos különbségnél (85 C - 30 C ) kapott gyári értékekből határozzuk meg a meredekséget is.

A tapasztalat szerint az így kiszámolt érték kb. 3 fokkal fölé lőtt a szobahőmérőnek, ezért a továbbiakban 30 fok helyett csak 27 fokot használok a képletben. Ha tizedfokokat is ki akarunk íratni (bár sok értelme nincs), akkor a fenti képletben 10-zel kell szorozni a konstansokat (tehát 55 helyett 550, 30 helyett 300, vagy 27 helyett 270).

A mellékelt mintaprogramban a P1.5 bemenetre kapcsolt feszültséget (0 - 2,5 V) is mérjük, valamint a 11. csatornában a VDD/2 feszültséget is. Utóbbiból meghatározhatjuk a tápfeszültséget, felhasználva, hogy most független referenciánk van. A feszültségeket millivoltokban célszerű kiszámolni.

Ha takarékoskodni akarunk a mérési idővel, akkor nem túl nagy csalás, ha 1023 helyett 1024-gyel osztunk (hogy léptetéssel megoldható legyen), de a programban nem éltem ezzel a lehetőséggel.

A kiírást a korábban már ismertetett outdec() függvénnyel végezzük, ahol második paraméterként a levágandó tizedesjegyek számát kell megadni (hőmérésnél 1, mV-ban kiszámolt feszültségnél pedig 3).

A program érdekessége, hogy nem használunk benne float változót, s a kiíratáshoz a korábban bemutatott egyirányú szoftveres UART kezelést használjuk.

A mellékelt képen P1.5 összevissza kóvályog, mert csak a felszedett zajt mérte...

main.c
adc_simple_r...png		   
(#) icserny válasza monsun hozzászólására (») Márc 2, 2012
Már többször felmerült ez a kérdés, itt nézz körül!
(#) icserny válasza colosseum hozzászólására (») Feb 22, 2012
Idézet:
„Van egy LCD kijelzőm amire kiíratom a hőmérsékletet , de csak egész számként megy, ezt szeretném mondjuk 2 tizedesig vagy egyig növelni.”
Akkor jól félreértettem az előző kérdést!
A mostanira ez a javaslatom:
  1. IntDegC = ((temp - 673) * 423) / 1024;
  2. lcd_write(0xC7,0);
  3. outdec(IntDegC,0);

A fenti sorok helyett ezzel próbálkoznék:
  1. IntDegC = ((temp - 673) * 4230) / 1024;
  2. lcd_write(0xC7,0);
  3. outdec(IntDegC,1);
(#) colosseum válasza szitko hozzászólására (») Feb 22, 2012
Pont ezt linkeltem be, de ha jobban megnézed csak element14-től lehet rendelni, viszont csak a szingapuri központból ahonnan csak Kina, Taiwan , etc helyekre lehet rendelni.
Én is TI-s Touch Pad KIt-re gondolok, nem másra.Ők a gyártók velük beszélek közvetlenül.

Ezért írtam ha valaki szeretne ilyet akkor szóljon, mert rajta vagyok az ügyön.

Más:
Icserny köszönöm a válaszod, lehet nem jól írtam le h mit akarok Van egy LCD kijelzőm amire kiíratom a hőmérsékletet , de csak egész számként megy, ezt szeretném mondjuk 2 tizedesig vagy egyig növelni.
Isten ments az msp430->PC kommunikációtol.
Forrás:



  1. #include "io430.h"
  2.     #include "stdint.h"
  3.     #include "intrinsics.h"
  4.      
  5.      
  6.     /* LCD port és vezérlo" bitek megadása */
  7.     #define LCD_PORT     P1OUT
  8.     #define LCD_PORT_DIR P1DIR
  9.     #define LCD_MASK     BIT7+BIT6+BIT5+BIT4
  10.     #define LCD_RS       P2OUT_bit.P6
  11.     #define LCD_RS_DIR   P2DIR_bit.P6
  12.     #define LCD_E         P2OUT_bit.P7
  13.     #define LCD_E_DIR    P2DIR_bit.P7
  14.      
  15.      
  16.     /**-----------------------------------------------
  17.     * Inline függvény, amely egy regiszter valamelyik
  18.     * bitcsoportját atomi mu"velettel módosítja
  19.     *-----------------------------------------------
  20.     * param reg a módosítandó regiszter neve
  21.     * param val a beírandó érték (helyiérték-helyesen!)
  22.     * param mask a módosítandó bitcsoportot kijelölo" maszk
  23.     */
  24.     #define ChangeBits(reg,val,mask) reg^=((reg^val)&mask)
  25.      
  26.     /**----------------------------------------------
  27.     *   Késlelteto" eljárás (1 - 65535 ms)
  28.     *-----------------------------------------------
  29.     * param delay a késleltetés ms egységben megadva
  30.     */
  31.     void delay_ms(uint16_t delay) {
  32.              uint16_t i;
  33.              for(i=0; i<delay; i++) {
  34.                __delay_cycles(1000);
  35.              }
  36.     }
  37.      
  38.     /**----------------------------------------------
  39.     *   LCD Enable bemenet pulzálása
  40.     *-----------------------------------------------
  41.     */
  42.     void lcd_toggle_E() {
  43.              LCD_E = 1;
  44.                __delay_cycles(500);
  45.              LCD_E = 0;
  46.                __delay_cycles(500);
  47.     }
  48.      
  49.     /**----------------------------------------------
  50.             *   Egy bájt kiküldése az LCD vezérlo"jének
  51.             *-----------------------------------------------
  52.             * param val a kiírandó érték
  53.             * param cmd regiszterválasztó bit (0: parancs, 1: adat)
  54.             */
  55.     void lcd_write(uint8_t val, uint8_t cmd) {
  56.              LCD_RS = cmd;
  57.              ChangeBits(LCD_PORT,(val&0xF0),LCD_MASK);
  58.              lcd_toggle_E();
  59.              ChangeBits(LCD_PORT,((val&0x0F)<<4),LCD_MASK);
  60.              lcd_toggle_E();
  61.              __delay_cycles(1000);
  62.     }
  63.      
  64.     /*-----------------------------------------------
  65.     *   LCD kijelzo" inicializálása
  66.     *-----------------------------------------------
  67.     */
  68.     void lcd_init (void){
  69.     //-- Az LCD port inicializálása
  70.              ChangeBits(LCD_PORT,0x00,LCD_MASK);
  71.              ChangeBits(LCD_PORT_DIR,LCD_MASK,LCD_MASK);
  72.              P2SEL = 0;
  73.              LCD_RS = 0;
  74.              LCD_RS_DIR = 1;
  75.              LCD_E = 0;
  76.              LCD_E_DIR = 1;
  77.              delay_ms(100);                      //40ms várakozás bekapcsolás után
  78.     //-- Az LCD vezérlo"jének inicializálása:
  79.     //-- 1. szoftveres LCD reset: 0x30 (8-bites mód) kiírása háromszor
  80.     //-- 2. 4-bites üzemmód beállítása
  81.     //-- 3. Képernyo"törlés, kurzor kikapcsolása
  82.              ChangeBits(LCD_PORT,0x30,LCD_MASK);
  83.              lcd_toggle_E ();
  84.              delay_ms(5);                        //várjunk legalább 4.1ms-ot
  85.              lcd_toggle_E ();
  86.              __delay_cycles(100);                //várjunk legalább 100us-ot
  87.              lcd_toggle_E ();
  88.              __delay_cycles(40);                 //várjunk legalább 37us-ot
  89.              ChangeBits(LCD_PORT,0x20,LCD_MASK); //0x20 = 4-bites üzemmód
  90.              lcd_toggle_E ();
  91.              delay_ms(5);                        //várjunk legalább 4.1ms-ot
  92.     //-- Innen kezdve minden bájtot két félbájtként kell kiírni! ------
  93.              lcd_write(0x28,0);                  // display mód beállítás
  94.              delay_ms(5);                        //várjunk legalább 4.1ms-ot
  95.              lcd_write(0x08,0);                  // display letiltás
  96.              lcd_write(0x01,0);                  // képernyo"törlés
  97.              lcd_write(0x0C,0);                  // display be, cursor, és villogás ki
  98.     }
  99.      
  100.     /**----------------------------------------------
  101.     *  Karakterfüzér kiírása az LCD-re
  102.     *-----------------------------------------------
  103.     * param p_str karakterfüzér mutató (nullával lezárt stringre mutat)
  104.     */
  105.     void lcd_puts(char* p_str) {
  106.              char c;
  107.              while ((c=*p_str)) {
  108.                  lcd_write(c,1);
  109.                  p_str++;
  110.              }
  111.     }
  112.      
  113.     void outdec(long data, unsigned int ndigits) {
  114.     static char sign, s[12];
  115.     unsigned int i;
  116.             i=0; sign='+';
  117.             if(data<0) { sign='-'; data = -data;}
  118.             do {
  119.                     s[i]=data%10 + '0';
  120.                     data=data/10;
  121.                     i++;
  122.                     if(i==ndigits) {s[i]='.'; i++;}
  123.             } while(data>0);
  124.             lcd_write(sign,1);
  125.             do{
  126.                     lcd_write(s[--i],1);
  127.             } while(i);
  128.     }
  129.  
  130. long temp;
  131. long IntDegC;
  132.     int main(void) {
  133.              WDTCTL = WDTPW + WDTHOLD;           //watchdog letiltása
  134.  
  135.              ADC10CTL1 = INCH_10 + ADC10DIV_3;         // Temp Sensor ADC10CLK/4
  136.              ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + ADC10IE;
  137.              __enable_interrupt();                     // Enable interrupts.
  138.              TACCR0 = 30;                              // Delay to allow Ref to settle
  139.              TACCTL0 |= CCIE;                          // Compare-mode interrupt.
  140.              TACTL = TASSEL_2 | MC_1;                  // TACLK = SMCLK, Up mode.
  141.              LPM0;                                     // Wait for delay.
  142.              TACCTL0 &= ~CCIE;                         // Disable timer Interrupt
  143.              __disable_interrupt();
  144.                                          
  145.              P1DIR |= BIT0;
  146.              P2DIR |= BIT5;
  147.              P2OUT_bit.P5 = 1;               //Mivel az Lcd kijelzőn van egy pnp így magasra állítom
  148.              lcd_init();
  149.              lcd_puts("  En szobam  ");
  150.              lcd_write(0xC0,0);                  //A második sor elejére lép
  151.              lcd_puts("Temp : ");
  152.              lcd_puts("+1  ");
  153.              lcd_write(0xDF,1);
  154.              lcd_puts("C");
  155.              while(1){
  156.                 ADC10CTL0 |= ENC + ADC10SC;             // Sampling and conversion start
  157.               __bis_SR_register(CPUOFF + GIE);
  158.               temp = ADC10MEM;
  159.               IntDegC = ((temp - 673) * 423) / 1024;
  160.              lcd_write(0xC7,0);
  161.              outdec(IntDegC,0);
  162.              P1OUT ^= BIT0;
  163.              delay_ms(1000);
  164.              }
  165.              
  166.     }
  167. // ADC10 interrupt service routine
  168. #pragma vector=ADC10_VECTOR
  169. __interrupt void ADC10_ISR (void)
  170. {
  171.   __bic_SR_register_on_exit(CPUOFF);        // Clear CPUOFF bit from 0(SR)
  172. }
  173.  
  174. #pragma vector=TIMER0_A0_VECTOR
  175. __interrupt void ta0_isr(void)
  176. {
  177.   TACTL = 0;
  178.   LPM0_EXIT;                                // Exit LPM0 on return
  179. }


Egyelőre még csak ilyen ctrl+c/v de már írom a header fájlt az LCD-mhez minden féle opcióval.
(#) icserny válasza balux33 hozzászólására (») Okt 2, 2011
C nyelvű programozáshoz sok ötlet meríthető a honlapomon található PIC18 és PIC24 tananyagokból.
  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.             lcd_write(sign,1);
  17.             do{
  18.                     lcd_write(s[--i],1);
  19.             } while(i);
  20.     }



Az első paraméter a kiírandó szám (előjeles 32 bites egész), a második paraméter a levágandó tizedesek száma.

Például, ha a feszültség mV egységekben van megadva, akkor outdec(3300,3) hatására +3.300 íródik ki.

Ha a hőmérséklet tizedfokokban adott, akkor
outdec(273,1) hatására +27.3 íródik ki. Természetesen az ADC-ből kiolvasott értéket előbb skálázni kell, hogy tizedfokokra alakítsuk.
Következő: »»   1 / 1
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