No changes between revisions
/Designs/Measuring_instruments/LCTmetr01A/SW/lc.c |
---|
0,0 → 1,883 |
//********************************************************************** |
// LCT-METER/PULSER |
//********************************************************************** |
// (c) OK1XGL 2004 |
// verze 1.00 - uvodni verze 10.1.2004 |
// verze 1.01 - pridano ukladani vlastni Cp/Lp do pameti EEPROM |
// - pridano ukladani stavu (mod, parametry modu ) do pameti EEROM |
// |
// |
// Popis funkcnosti: |
// ----------------- |
// Meri kapacitu, indukcnost, teplotu a jako doplnek obsahuje generator impulzu. |
// Jednotlive druhy mereni se prepinaji stiskem tlacitka MODE. Stiskem tlacitka NUL lze |
// vynulovat mereni (odecteni vlivu mericich privodu, u mereni teploty odecteni napr. pro mereni otepleni). |
// |
// Mereni L a C: |
// ------------- |
// Mereni se provadi merenim kmitoctu mericiho oscilatoru. Neznama Lx se pripojuje do serie s vnitrni L oscilatoru. |
// Neznama Cx se pripojuje paralelne k vnitrni C oscilatoru. Vypocet nezname Cx/Lx se provadi pomoci nasledujicich vzorcu: |
// Cx=((f1^2/f2^2)-1)*C Lx=((f1^2/F2^2)-1)*L |
// Pripadne se od vysledku odecte hodnota Cv nebo Lv, ktera se ziska stisknutim NUL |
// f1 - kmitocet mericiho oscilatoru, ke kteremu neni pripojena zadna Lx nebo Cx, ziska se pri kalibraci |
// f2 - kmitocet mericiho oscilatoru s pripojenou neznamou Lx nebo Cx |
// C - kapacita vnitrniho C oscilatoru, ziska se pri kalibraci |
// L - indukcnost vnitrni L oscilatoru, ziska se kalibraci |
// |
// Kalibrace: |
// ---------- |
// Provadi se pri zapnuti pristroje a probiha takto: |
// Zmeri se kmitocet mericiho oscilatoru f1 ,ke kteremu neni pripojena zadna Lx nebo Cx. |
// Pripoji se kalibracni kondenzator Ck o zname hodnote, mel by byt co nejpresnejsi a nejstabilnejsi. |
// Zmeri se kmitocet mericiho oscilatoru f2. |
// Vypoctou se hodnoty L a C podle vzorcu: |
// C=(Ck*F2^2)/(F1^2-F2^2) L=(1/(4*PI^2*F1^2*C) |
// Odpoji se kalibracni kondenzator Ck a pristroj je pripraven k mereni L a C |
// |
// |
// Mereni teploty: |
// --------------- |
// Kladna merici svorka je pripojena primo na vstup procesoru. Pro mereni teploty se pouziva teplomer |
// fy Dallas DS18B20, se kterym se komunikajue po I2C sbernici. |
// |
// |
// Generovani pulzu: |
// ----------------- |
// Kladna merici svorka je pripojena primo na vstup procesoru. Jsou generovany kladne pulzy se zvolenou sirkou. |
// Nulove pulzy maji stejnou sirku, tedy perioda je dvojnasobek sirky pulzu. |
// |
// |
// |
// Poznamky k implementaci: |
// ------------------------ |
// |
// 1) mereni L a C |
// ---------------- |
// Zakladem je mereni kmitoctu. Presnost mereni byla zvolena na 4Hz, tedy merici perioda bude 250ms. Pro citani impulzu je |
// pouzit 16 bitovy citac TMR1, ktery je rozsiren o dalsich 8 bitu promennou counter_H. Pretecenim TMR1 se v preruseni zvysi |
// hodnota counter_H o jednicku. Merici periodu odmeruje 8 bitovy citac TMR0, kteremu je predrazen preddelic :256. Cita |
// takty procesoru. TMR0 pretece kazdych 50ms. Promenna sampler_H obsahuje pocet potrebnych 50ms jednotek pro dosazeni |
// pozadovaneho casu. Prommena sampler_H se dekrementuje v preruseni. Po uplynuti merici periody (250ms) se zastavi citani |
// TMR1, ktery spolu s hodnotou v counter_H bude obsahovat mereny kmitocet s presnosti 4Hz. |
// Promenou freq_done se oznami ukonceni mereni kmitoctu. Hodnota v TMR1 a counter_H se prevede na realne cislo, ktere se |
// dale pouzije pro vypocty. |
// |
// 2) mereni teploty |
// ----------------- |
// Vyuziva se teplomeru fy Dallas DS18B20, ktery komunikuje po I2C sbernici. Pro tento mod se sepne rele, ktere pripoji |
// kalibracni kondenzator Ck. Tim dojde k pripojeni svorek na vstup portu pro teplomer. Mereni teploty probiha tak, ze se |
// vysle prikaz do teplomeru aby zmeril teplotu a po uplynuti potrebne doby konverze se z teplomeru precte zmerena teplota a |
// zobrazi se. Pro odmereni doby konverze se vyuziva mereni frekvence, ktere trva 250ms. |
// |
// 3) Generovani pulzu |
// ------------------- |
// Pro tento mod se sepne rele, ktere pripoji kalibracni kondenzator Ck. Tim dojde k pripojeni svorek na vystup portu |
// pro pulser. Pro generovani pulzu je vyuzivana jednotka PWM1 pro pulzy do sirky 1ms a pro pulzy delsi pak jednotka CCP1. |
// Generovani pulzu PWM1 jednotkou je zcela autonomni, jednotce se nastavi perioda (dvojnasobek sirky pulzu) a sirka pulzu |
// a generovani probiha mez zasahu programu. Jednotka CCP1 generuje periodicke preruseni po dobe urcene sirkou pulzu. |
// Vlastni impulz je generovan v preruseni, kde se periodicky strida nastaveni portu do log.1 a do log.0 |
// |
// 4) Cteni tlacitek |
// ----------------- |
// Pro cteni tlacitek je vyuzivano preruseni od zmeny na portu B. Pri zmene stavu nektereho z tlacitek toto preruseni |
// nastavi promenou freq_done. Na miste v programu, kde se testuje tato promenna se precte stav tlacitek a podle |
// jejich stavu se dal pokracuje. |
// |
// 5) Zakladni smycky programu |
// --------------------------- |
// Hlavni smycka programu je koncipovana jako stavovy automat, kdy jednotlive stavy predstavuji jednotlive mody mereni. |
// V jednotlivych stavech se volaji hlavni funkce jednotlivych modu mereni. Tyto funkce jsou koncipovany jako stavove |
// automaty, ktere provedou podle potreby uvodni akci a dale sleduji stav promenne freq_done. Na zaklade tohoto stavu |
// pokracuji dale nebo prechazeji do stavu jineho. freq_done ma tyto stavy: |
// F_PEACE -klidovy stav |
// F_DONE- mereni kmitoctu dokonceno |
// F_KEY- mereni kmitoctu preruseno stiskem nejakeho tlacitka. |
// Stav F_DONE je vyuzivan v modu mereni Lx a Cx a dale v modu mereni teploty se vyuziva k odmerovani casu. |
// Pri stavu F_KEY se precte stav tlacitek a pri stisku tlacitka MODE se opousti hlavni funkce aktivniho modu mereni a |
// prechazi se zpet se do hlavni smycky programu. V hlavni smycce programu se nasledne prejde do nasledujiciho modu mereni. |
// Pri stisku tlacitka NUL se provede pozadavana akce, a zustava se v danem modu mereni. |
#include <16f876.h> |
#include <16F877_reg.h> |
#include "lc.h" |
#include <lcd.c> |
#include <tm.c> |
#include <math.h> |
//#define FREQ // jen mereni frekvence mericiho oscilatoru, urceno pro jeho kalibraci |
// pripojime citac na vystup mericiho oscilatoru a musi ukazovat totez co je na displeji, pokud tomu tak neni, |
// napravu provedeme zmenou konstanty CORIG v lc.h pripadne zmenou kondenzatoru u oscilatoru procesoru |
/*****************************************************/ |
/************* PRERUSOVACI RUTINY ********************/ |
/*****************************************************/ |
#USE FAST_IO(A) |
#USE FAST_IO(B) |
#USE FAST_IO(C) |
// prerusovaci rutina spolecna pro vsechny preruseni, napsana v assembleru, protoze cecko to dela neefektivne |
#int_GLOBAL |
void int_handler() |
{ |
// uloz W, STATUS a PCLATH |
#asm |
movwf W_TMP |
swapf STATUS,W |
clrf STATUS |
movwf F_TMP |
movf PCLATH,W |
movwf PCLATH_TMP |
clrf PCLATH |
btfss PIR1,_TMR1IF |
goto NO_T1_L |
// preruseni od timeru1 |
incf counter_h,F // +1 na nejvyssim radu citace impulzu |
bcf PIR1,_TMR1IF // nuluj priznak preruseni |
// pokracujeme hned testem preruseni od timeru0 (odmeruje periodu mereni) |
NO_T1_L: |
btfss INTCON,_T0IF |
goto NO_T0_L // na dalsi druhy preruseni |
// preruseni od timeru 0 |
bcf INTCON,_T0IF // nuluj priznak preruseni |
movlw CORIG // pridane spozdeni, aby byl odmereny cas timerem 0 presne |
movwf INT_TMP |
LOOP: |
decfsz INT_TMP,F |
goto LOOP |
nop |
movlw TIME_1S_L // znovu natahni timer0 |
movwf TMR0 |
decf sampler_H,F // -1 na citaci opakovani zakladni periody timeru0 |
btfss STATUS,_Z // perioda mereni vyprsela? |
goto END_INT_L // koncime,abychom nezdrzovali dalsimi zdroji preruseni na nich jiz casove nezalezi |
nop |
nop |
nop |
nop |
bcf T1CON,_TMR1ON // zastav citani impulzu |
movlw F_DONE |
movwf freq_done // priznak ukonceni citani - mereni OK |
bcf INTCON,_T0IE // zakaz preruseni od timeru0 |
goto END_INT_L // koncime,abychom nezdrzovali dalsimi zdroji preruseni na nich jiz casove nezalezi |
NO_T0_L: |
btfss INTCON,_RBIF |
goto NO_RB_L |
// preruseni od tlacitek na brane B |
movf PORTB,W |
movlw F_KEY |
movwf freq_done // nastav priznak , ze mereni frekvence nedopadlo dobre (stisknuto nektere z tlacitek) |
bcf INTCON,_RBIF |
goto END_INT_L |
NO_RB_L: |
btfss PIR1,_CCP1IF |
goto END_INT_L |
// preruseni od komparacni jednotky, pouziva se pouze v rezimu pulser pro generovani pulzu od 1ms vyse |
// nasledujici konstrukce zajistuje pro 1 i 0 nastaveni pinu ve stejny okamzik, doba do bodu B je tez stejna |
btfss INT_TMP,0 |
goto A |
btfsc INT_TMP,0 |
bcf PORTC,2 |
goto B |
A: |
bsf PORTC,2 |
goto B |
B: |
comf INT_TMP,F // priste budeme nastavovat opacnou hodnotu |
bcf PIR1,_CCP1IF // nuluj priznak preruseni od CCP1 jednotky |
END_INT_L: |
// obnov W, STATUS a PCLATH |
movf PCLATH_TMP,W |
movwf PCLATH |
swapf F_TMP,W |
movwf STATUS |
swapf W_TMP,F |
swapf W_TMP,W |
#endasm |
} // int_handler |
/**************************************************/ |
/*********** FUNKCE MERENI KMITOCTU ***************/ |
/**************************************************/ |
// zahajeni mereni frekvence |
// |
void start_freq() |
{ |
#asm |
bcf T1CON,_TMR1ON // zastav citac TMR1 |
clrf TMR1L // nuluj citac TMR1, ktery cita vstupni implulzy |
clrf TMR1H |
clrf counter_H |
movlw F_PEACE |
movwf freq_done // nuluj priznak dokonceni mereni frekvence |
bsf T1CON,_TMR1ON // spust citac TMR1 |
movlw TIME_1S_L // natahni casovac TMR0, ktery meri periodu mereni |
movwf TMR0 |
movlw TIME_1S_H |
movwf sampler_H |
bcf INTCON,_T0IF // nuluj priznak preruseni od timeru0 |
bsf INTCON,_T0IE // povol preruseni od timeru0 |
#endasm |
} // start_freq |
// zmereni frekvence a jeji umocneni |
// |
float mfreq_sqr() |
{ |
float f; |
start_freq(); // odstartuj mereni frekvence |
while(freq_done==F_PEACE); // cekej na dokonceni zmereni frekvence |
f=F_CORRECT*(float)make32(counter_H,get_timer1()); // preved zmerenou frekvennci na float |
#ifdef FREQ |
return(f); // pro mereni frekvence vracej frekvenci |
#else |
return(f*f); // vrat kvadrat |
#endif |
} // mfreq_sqr |
/*******************************************************************/ |
/*********** FUNKCE PRO PREPINANI TYPU MERENI (rele) ***************/ |
/*******************************************************************/ |
// prepne rele na mod mereni C |
// |
rele_measure_C() |
{ |
output_high(RE1_B); |
output_high(RE2_B); |
delay_ms(RELE_PULSE); |
output_low(RE1_B); |
output_low(RE2_B); |
} // rele_measure_C |
// prepne rele na mod mereni L |
// |
rele_measure_L() |
{ |
output_high(RE1_A); |
output_high(RE2_B); |
delay_ms(RELE_PULSE); |
output_low(RE1_A); |
output_low(RE2_B); |
} // rele_measure_L |
// prepne rele na kalibraci a tez na mody mereni teploty a pulser |
// |
rele_calib() |
{ |
output_high(RE1_B); |
output_high(RE2_A); |
delay_ms(RELE_PULSE); |
output_low(RE1_B); |
output_low(RE2_A); |
} // rele_calib |
/*******************************************************************/ |
/*********** POMOCNE FUNKCE JEDNOTLIVYCH MODU MERENI ***************/ |
/*******************************************************************/ |
// vraci cislo radu (0=1E0, 1=1E3 2=1E6 atd.) a upravi parametr aby byl do 999.999 |
// |
int8 range(float &Xv) |
{ |
int8 ret_val; |
ret_val=0; |
while(fabs(Xv)>1E3) |
{ |
Xv=Xv*1E-3; |
ret_val++; |
} |
return(ret_val); |
} // range |
// vraci pocet celych cislic realneho argumentu |
// |
int8 num_int_digit(float X) |
{ |
int8 ret_val; |
ret_val=1; |
while(fabs(X)>1E1) |
{ |
X=X*1E-1; |
ret_val++; |
} |
return(ret_val); |
} // num_int_digit |
// smaze 1.radek LCD displeje |
// |
clr_1Line() |
{ |
int8 i; |
lcd_gotoxy(1,1); |
for(i=0;i<16;i++) lcd_putc(' '); |
lcd_gotoxy(1,1); |
} |
//cekani na uvolneni tlacitek |
// |
wait_release_keys() |
{ |
while(!input(NUL_KEY) || !input(MODE_KEY)) delay_ms(20); // cekej na uvolneni tlacitka |
freq_done=F_PEACE; |
} // wait_release_keys |
// kalibrace |
// |
void calibration(float &f1_sqr, float &C, float &L) |
{ |
float f2_sqr; |
lcd_putc("\f"); |
printf(lcd_putc,CALIB_MSG); |
rele_measure_C(); // rele do stavu odpojeni kalibracniho kondenzatoru a oscilator musi bezet |
delay_ms(FREQ_CALM_TIME); // pockej na ustaleni oscilatoru |
// mereni f2 |
rele_calib(); // pripni kalibracni kondenzator |
delay_ms(FREQ_CALM_TIME); // pockej na ustaleni oscilatoru |
f2_sqr=mfreq_sqr(); // zmer kvadrat f2 |
// vypocet C a L |
C=(C_CALIB*f2_sqr)/(f1_sqr-f2_sqr); // C1 v pF |
L=1e9/(39.4784176*f1_sqr*C*1e-12); // L1 v nH |
/* |
// zobraz zmerene kalibracni hodnoty |
lcd_putc("\f"); |
printf(lcd_putc,"C=%3.2f pF",C); |
lcd_gotoxy(1,2); |
printf(lcd_putc,"L=%3.2f nH",L); |
while(input(NUL_KEY)); // cekej na stisk klavesy |
lcd_putc("\f"); |
*/ |
} // calibration |
/******************************************************************/ |
/*********** HLAVNI FUNKCE JEDNOTLIVYCH TYPU MERENI ***************/ |
/******************************************************************/ |
// mereni L |
// |
#inline |
void measure_L(float &f1_sqr,float &C,float &L) |
{ |
float f2_sqr; // kvadrat kmitoctu mericiho oscilatoru s pripojenou Lx |
float X; // zmerena hodnota Lx |
float Xp; // vlastni Lp (odecita se od vysledku) |
float Xv; // vysledna hodnota Lx |
int8 prefix; // index do poli urcijici pismenko radu |
int8 Xp_p; // pointer na promennou Xp |
int8 ee_adr; // adresovy citac pameti EEROM |
// vyzvedni vlastni indukcnost |
ee_adr=LP_ADR_LOW; |
for(Xp_p=&Xp;Xp_p<&Xp+4;Xp_p++) *Xp_p=read_eeprom(ee_adr++); |
for(;;) |
{ |
f2_sqr=mfreq_sqr(); // zmer kvadrat F2 |
if(freq_done!=F_DONE) // zmerena frekvence neni platna (stisknuto nektere z tlacitek) |
{ |
if(!input(MODE_KEY)) break; // stisknuto tlacitko mode, koncime |
if(!input(NUL_KEY)) |
{ |
// stisknuto tlacitko NULL, poznamenej si vlastni L |
Xp=X; |
// uloz vlastni indukcnost |
ee_adr=LP_ADR_LOW; |
for(Xp_p=&Xp;Xp_p<&Xp+4;Xp_p++) write_eeprom(ee_adr++,*Xp_p); |
clr_1Line(); |
lcd_gotoxy(9,1); |
printf(lcd_putc,"0 nH"); |
wait_release_keys(); // cekej na uvolneni tlacitka |
} |
} else |
{ |
if(f2_sqr<1E2) // bezi oscilator? (kmitocet pod 10Hz povazujeme za nebezici oscilator) |
{ |
// oscilator NEBEZI |
clr_1Line(); |
printf(lcd_putc,CONNECT_LX_MSG); |
} else |
{ |
// oscilator BEZI |
X=(f1_sqr/f2_sqr-1)*L; // vypocti hodnotu Lx |
Xv=X-Xp; // odecti vlastni L |
// zobraz hodnotu Lx |
clr_1Line(); |
prefix=range(Xv); // uprav rozsah a zjisti cislo radu |
lcd_gotoxy(6-num_int_digit(Xv),1); // umisti hodnotu tak, aby radova carka zustavala na stejnem miste |
if(Xv>=0F) lcd_putc(' '); // kladne cislo nema minus, vloz mezeru |
if(prefix==0) printf(lcd_putc," %3.0f",Xv); // u nH zobrazuj jen cela cisla |
else printf(lcd_putc,"%6.3f",Xv); // u ostatnich na 3 desetinna mista |
// zobraz jednotky |
lcd_gotoxy(12,1); |
lcd_putc(L_PREFIX[prefix]); |
lcd_putc('H'); |
} |
} |
} // od hlavni smycky (for(;;)) |
} // measure_L |
// mereni C |
// |
#inline |
void measure_C(float &f1_sqr,float &C,float &L) |
{ |
float f2_sqr; // kvadrat kmitoctu mericiho oscilatoru s pripojenou Cx |
float X; // zmerena hodnota Cx |
float Xp; // vlastni Cp (odecita se od vysledku) |
float Xv; // vysledna hodnota Cx |
int8 prefix; // index do poli s pismenky radu |
// int8 pom; |
int8 Xp_p; // pointer do promenne Xp |
int8 ee_adr; |
// vyzvedni vlastni kapacitu |
ee_adr=CP_ADR_LOW; |
for(Xp_p=&Xp;Xp_p<&Xp+4;Xp_p++) *Xp_p=read_eeprom(ee_adr++); |
for(;;) |
{ |
f2_sqr=mfreq_sqr(); // zmer F2 |
if(freq_done!=F_DONE) // zmerena frekvence neni platna (stisknuto nektere z tlacitek) |
{ |
if(!input(MODE_KEY)) break; // stisknuto tlacitko mode, koncime |
if(!input(NUL_KEY)) |
{ |
// stisknuto tlacitko NULL, poznamenej si vlastni Cp |
Xp=X; |
// uloz vlastni kapacitu |
ee_adr=CP_ADR_LOW; |
for(Xp_p=&Xp;Xp_p<&Xp+4;Xp_p++) write_eeprom(ee_adr++,*Xp_p); |
clr_1Line(); |
lcd_gotoxy(6,1); |
printf(lcd_putc,"0.00 pF"); |
wait_release_keys(); // cekej na uvolneni tlacitka |
} |
} else |
{ |
if(f2_sqr<1E2) // bezi oscilator? (kmitocet pod 10Hz povazujeme za nebezici oscilator) |
{ |
// oscilator NEBEZI |
clr_1Line(); |
printf(lcd_putc,Error_Cx_MSG); |
} else |
{ |
// oscilator BEZI |
X=(f1_sqr/f2_sqr-1)*C; // vypocti hodnotu Cx nebo Lx |
Xv=X-Xp; // odecti vlastni Cp |
// zobraz hodnotu Cx |
clr_1Line(); |
prefix=range(Xv); // uprav rozsah a zjisti cislo radu |
lcd_gotoxy(6-num_int_digit(Xv),1); // umisti hodnotu tak, aby radova carka zustavala na stejnem miste |
if(Xv>=0F) lcd_putc(' '); // kladne cislo nema minus, vloz mezeru |
if(prefix==0) printf(lcd_putc,"%5.2f",Xv); // u pF zobrazuj na 2 mista |
else printf(lcd_putc,"%6.3f",Xv); // u ostatnich na 3 mista |
// zobraz jednotky |
lcd_gotoxy(12,1); |
lcd_putc(C_PREFIX[prefix]); |
lcd_putc('F'); |
} |
} |
} // od hlavni smycky (for(;;)) |
} // measure_C |
// mereni teploty |
// |
#separate |
void measure_T() |
{ |
int8 record[10]; // bafr pro ulozeni zaznamu z teplomeru |
int8 i; |
int8 stat; // stavovy automat mereni teploty |
int8 wait; // pro odmereni casu prevodu teplomeru |
int1 delta; // oznamuje, ze merime rozdil teplot |
float temp; // zmerena teplota |
float temp_p; // odecitana hodnota teploty pri mereni rozdilu teplot |
float temp_v; // vysledna teplota |
stat=T_MEASURE; // zahajime mereni teploty |
delta=0; // nemerime teplotni rozdil |
temp_p=0; // nic od zmerene teploty neodecitame |
for(;;) |
{ |
if(freq_done==F_KEY) // stisknuto nejake tlacitko |
{ |
if(!input(MODE_KEY)) // stisknuto tlacitko mode, koncime |
{ |
#USE STANDARD_IO(A) |
#USE STANDARD_IO(B) |
#USE STANDARD_IO(C) |
output_float(TM_PIN); // TM jako vstup, muze zustat jako vystup pri preruseni mereni |
#USE FAST_IO(A) |
#USE FAST_IO(B) |
#USE FAST_IO(C) |
break; |
} |
if(!input(NUL_KEY)) // stisknuto tlacitko NULL, budeme merit rozdil teplot, zapamatuj si aktualni teplotu |
{ |
temp_p=temp; // zapamatuj si aktualni hodnotu teploty |
delta=1; // oznam, ze merime rozdil teplot |
stat=T_MEASURE; |
clr_1line(); |
lcd_gotoxy(6,1); |
printf(lcd_putc,"0.0 \20\21C"); // \20 je znak delta \21 je znak stupen |
wait_release_keys(); // cekej na uvolneni tlacitka |
} |
} |
// STAVOVY AUTOMAT MERENI TEPLOTY |
switch(stat) |
{ |
case T_WAIT: |
if(--wait==0) stat=T_DISPLAY; // cekej az teplomer zmeri frekvenci |
break; |
case T_DISPLAY: |
if(!TM_present()) |
{ |
// teplomer NENI pritomen |
clr_1line(); |
printf(lcd_putc,CONNECT_TEMP_MSG); |
temp_p=0; // nuluj pripadnou teplotu pro odecteni |
delta=0; // zrus pripadne mereni rozdilu teplot |
} else |
{ |
// teplomer JE pritomen |
TM_write_byte(0xCC); // prikaz preskoc na dalsi sadu prikazu |
TM_write_byte(0xBE); // prikaz precti zmerenou teplotu |
for(i=0;i<9;i++) record[i]=TM_read_byte(); // precti zaznam do buferu |
if(TM_check_CRC(record,9)) // kontrola CRC |
{ |
// vypocet teploty viz datasheet |
record[0]=record[0]>>1; // zahod rad 2^-1, |
if(bit_test(record[1],0)) bit_set(record[0],7); // je-li cislo zaporne, je treba nejvyssi bit nastavit na 1 |
temp=(float)make16(record[1],record[0]); // prechod na realna cisla |
temp=temp-0.25+((0x10-(float)record[6])/0x10); // zvetseni presnosti na 12 bitu |
temp_v=temp-temp_p; |
clr_1line(); |
lcd_gotoxy(6-num_int_digit(temp_v),1); // umisti udaj tak, aby radova carka byla porad na stejnem miste |
if(temp_v>=0F) lcd_putc(' '); // pri kladne hodnote zobraz misto minus mezeru |
printf(lcd_putc,"%4.1f ",temp_v); |
if(delta) lcd_putc('\20'); // pri mereni rozdilu teplot zobraz znak delta |
lcd_putc('\21'); // znak stupne |
lcd_putc('C'); |
} |
} |
stat=T_MEASURE; // prejdi do stavu vyvolani mereni teploty |
case T_MEASURE: |
if(!TM_present()) |
{ |
// teplomer NENI pritomen |
clr_1line(); |
printf(lcd_putc,CONNECT_TEMP_MSG); |
temp_p=0; // nuluj pripadnou teplotu pro odecteni |
delta=0; // zrus pripadne mereni rozdilu teplot |
} else |
{ |
// teplomer JE pritomen |
TM_write_byte(0xCC); // prikaz preskoc na dalsi sadu prikazu |
TM_write_byte(0x44); // prikaz zmer teplotu |
#USE STANDARD_IO(A) |
#USE STANDARD_IO(B) |
#USE STANDARD_IO(C) |
output_high(TM_PIN); // vystup do 1, zajistuje napajeni behem mereni teploty |
#USE FAST_IO(A) |
#USE FAST_IO(B) |
#USE FAST_IO(C) |
wait=CONV_WAIT; |
stat=T_WAIT; // prejdi do stavu cekani na dokonceni mereni (konverze) |
} |
break; |
} // od switch |
mfreq_sqr(); // zastupuje zde spozdeni 250ms, ktere lze prerusit stiskem tlacitka |
} // od for(;;) |
} // measure_T |
// generovani pulzu |
// |
#separate |
void pulser() |
{ |
int8 pulse; |
#USE STANDARD_IO(A) |
#USE STANDARD_IO(B) |
#USE STANDARD_IO(C) |
output_high(PULSER_PIN); // pin pulseru naorientuj jako vystup |
#USE FAST_IO(A) |
#USE FAST_IO(B) |
#USE FAST_IO(C) |
INT_TMP=0; // pouzije se jako zrcadlo vystupniho pinu generatoru pulzu (vystup do 0) |
setup_timer_0(RTCC_EXT_L_TO_H); // zastav TMR0, vadil by nam v preruseni, (preruseni od nej zastavuje TMR1) |
pulse=read_eeprom(WIDTH_ADR); // vyzvedni naposledy pouzitou sirku impulzu |
for(;;) |
{ |
clr_1line(); |
switch(pulse) |
{ |
case P_10US: |
printf(lcd_putc,PULSE_10us_MSG); |
setup_timer_2(T2_DIV_BY_1,20-1,1); // perioda 20us |
setup_ccp1(CCP_PWM); // generujeme pomoci PWM jednotky |
CCP_1 = 20/2; // strida 1:1 |
break; |
case P_20US: |
printf(lcd_putc,PULSE_20us_MSG); |
setup_timer_2(T2_DIV_BY_1,40-1,1); // perioda 40us |
setup_ccp1(CCP_PWM); // generujeme pomoci PWM jednotky |
CCP_1 = 40/2; // strida 1:1 |
break; |
case P_50US: |
printf(lcd_putc,PULSE_50us_MSG); |
setup_timer_2(T2_DIV_BY_1,100-1,1); // perioda 100us |
setup_ccp1(CCP_PWM); // generujeme pomoci PWM jednotky |
CCP_1 = 100/2; // strida 1:1 |
break; |
case P_100US: |
printf(lcd_putc,PULSE_100us_MSG); |
setup_timer_2(T2_DIV_BY_1,200-1,1); // perioda 200us |
setup_ccp1(CCP_PWM); // generujeme pomoci PWM jednotky |
CCP_1 = 200/2; // strida 1:1 |
break; |
case P_200US: |
printf(lcd_putc,PULSE_200us_MSG); |
setup_timer_2(T2_DIV_BY_4,100-1,1); // perioda 400us |
setup_ccp1(CCP_PWM); // generujeme pomoci PWM jednotky |
CCP_1 = 100/2; // strida 1:1 |
break; |
case P_500US: |
printf(lcd_putc,PULSE_500us_MSG); |
setup_timer_2(T2_DIV_BY_4,250-1,1); // perioda 1000us |
setup_ccp1(CCP_PWM); // generujeme pomoci PWM jednotky |
CCP_1 = 250/2; // strida 1:1 |
break; |
case P_1MS: |
setup_timer_2(T2_DISABLED,0,1); |
printf(lcd_putc,PULSE_1ms_MSG); |
setup_ccp1(CCP_COMPARE_RESET_TIMER); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
setup_timer_1(T1_INTERNAL | T1_DIV_BY_1); |
CCP_1 =1000; // pulz 1ms - perioda 2ms |
enable_interrupts(INT_CCP1); // povol preruseni od CCP1 jednotky |
break; |
case P_2MS: |
printf(lcd_putc,PULSE_2ms_MSG); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
CCP_1 =2000; // pulz 2ms - perioda 4ms |
break; |
case P_5MS: |
printf(lcd_putc,PULSE_5ms_MSG); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
CCP_1 =5000; // pulz 5ms - perioda 10ms |
break; |
case P_10MS: |
printf(lcd_putc,PULSE_10ms_MSG); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
CCP_1 =10000; // pulz 10ms - perioda 20ms |
break; |
case P_20MS: |
printf(lcd_putc,PULSE_20ms_MSG); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
CCP_1 =20000; // pulz 20ms - perioda 40ms |
break; |
case P_50MS: |
printf(lcd_putc,PULSE_50ms_MSG); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
CCP_1 =50000; // pulz 50ms - perioda 100ms |
break; |
case P_500MS: |
printf(lcd_putc,PULSE_500ms_MSG); // generujeme pomoci CPP1 jednotky ( portem se hejbe v preruseni) |
setup_timer_1(T1_INTERNAL | T1_DIV_BY_8); |
CCP_1 =62500 ; // pulz 500ms - perioda 1000ms |
break; |
case P_5US: |
printf(lcd_putc,PULSE_5us_MSG); |
disable_interrupts(INT_CCP1); // zakaz preruseni od CCP1, pro kratke casy ji nepouzivme, pouzivame PWM jednotku |
setup_timer_2(T2_DIV_BY_1,10-1,1); // perioda 10us |
setup_ccp1(CCP_PWM); // pouzivame PWM jednotku |
CCP_1 = 10/2; // strida 1:1 |
break; |
} // od switch |
while(freq_done!=F_KEY); // cekame na stisk nejakeho tlacitka |
if(!input(MODE_KEY)) // stisknuto tlacitko MODE, koncime |
{ |
// uved preruseni a nastaveni timeru1 do puvodniho stavu a konci mod |
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_256); // pro mereni periody vzorkovani (500ms) |
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); // pro citani vzorku// |
bit_clear(*T1CON,_TMR1ON); // zastav citani impulzu |
disable_interrupts(INT_CCP1); // cakaz preruseni od CCP1 ednotky |
#USE STANDARD_IO(A) |
#USE STANDARD_IO(B) |
#USE STANDARD_IO(C) |
output_float(PULSER_PIN); // vystup pulseru jako vystup |
#USE FAST_IO(A) |
#USE FAST_IO(B) |
#USE FAST_IO(C) |
break; // koncime |
} |
if(!input(NUL_KEY)) // stisknuto tlacitko WIDTH |
{ |
if(pulse==P_5US) pulse=P_10US; // po dosazeni stavu P_5US se posloupnost opakuje |
else pulse++; |
write_eeprom(WIDTH_ADR,pulse); // uloz novou sirku impulzu |
wait_release_keys(); // cekej na uvolneni tlacitek po nastaveni sirky pulzu |
} |
} |
} // pulser |
/*************************************************/ |
/******** HLAVNI FUNKCE PROGRAMU ****************/ |
/*************************************************/ |
void main() |
{ |
float f1_sqr; // kvadrat kmitoctu mericiho scilatoru bez pripojene Lx nebo Cx |
float C; // hodnota kondenzatoru v mericim oscilatoru v pF (ziska se kalibraci) |
float L; // hodnota indukcnosti v mericim oscilatoru v nH (ziska se kalibraci) |
int8 MODE; // promenna stavoveho automatu hlavni smycky (mod mereni) |
int1 _calib; // priznak, ze jiz doslo ke kalibraci |
// nastaveni citacu |
port_b_pullups(TRUE); // zapnu puulupy na brane B (pro tlacitka) |
setup_timer_0(RTCC_INTERNAL | RTCC_DIV_256); // pro mereni periody vzorkovani (500ms) |
setup_timer_1(T1_EXTERNAL | T1_DIV_BY_1); // pro citani impulzu z mericiho oscilatoru |
bit_clear(*T1CON,_TMR1ON); // zastav citani impulzu |
//nastaveni vstupu a vystupu |
#USE STANDARD_IO(A) |
#USE STANDARD_IO(B) |
#USE STANDARD_IO(C) |
output_low(RE1_A); // signaly relatek jako vystupy a do 0 |
output_low(RE1_B); |
output_low(RE2_A); |
output_low(RE2_B); |
output_float(PULSER_PIN); // signal pro pulser jako vstup |
output_float(TM_PIN); // vstup pro TM jako vstup |
output_float(TM_PULLUP); // zapni pullup pro TM |
output_low(PIN_C1); // nepouzit,dej do 0 |
output_low(PIN_C3); // nepouzit,dej do 0 |
#USE FAST_IO(A) |
#USE FAST_IO(B) |
#USE FAST_IO(C) |
lcd_init(); |
lcd_define_char(0,LCD_CHAR_DELTA); // nadefinovani znaku delta |
lcd_define_char(1,LCD_CHAR_DEC); // nadefinovani znaku stupen |
rele_measure_C(); // rele do stavu odpojeni kalibracniho kondenzatoru a oscilator musi bezet |
input_b(); |
enable_interrupts(INT_TIMER1); // povol preruseni od citace impulzu mericiho oscilatoru |
enable_interrupts(INT_RB); // povol preruseni od tlacitek |
enable_interrupts(GLOBAL); |
#ifdef FREQ |
// pro kalibraci mereni kmitoctu |
for(;;) { |
f1_sqr=mfreq_sqr(); |
lcd_putc("\f"); |
printf(lcd_putc,"F=%6.2f KHz",f1_sqr*1E-3); |
delay_ms(500); |
} |
#endif |
// UVOD |
lcd_putc("\f"); |
printf(lcd_putc,VERSION_MSG); |
lcd_gotoxy(1,2); |
printf(lcd_putc,COPYRIGHT_MSG); |
delay_ms(FREQ_CALM_TIME); // pockej na ustaleni oscilatoru |
f1_sqr=mfreq_sqr(); // zmer f1 |
_calib=0; // kalibrace neni provedena |
freq_done=F_PEACE; |
mode=read_eeprom(MODE_ADR); // vyzvedni naposledy pouzity mod |
// VLASTNI MERICI SMYCKA |
for(;;) |
{ |
switch(mode) |
{ |
case MODE_C: // mereni Cx |
if(!_calib) |
{ |
calibration(f1_sqr,C,L); // proved kalibraci (vypocti L a C) |
_calib=1; // poznamenej si, ze se kalibrace uz provedla |
} |
rele_measure_C(); |
lcd_gotoxy(1,2); |
printf(lcd_putc,MODE_CX_NULL_MSG); |
measure_C(f1_sqr,C,L); |
// prechazime na mereni L |
mode=MODE_L; |
break; |
case MODE_L: // mereni Lx |
if(!_calib) |
{ |
calibration(f1_sqr,C,L); // proved kalibraci (vypocti L a C) |
_calib=1; // poznamenej si, ze se kalibrace uz provedla |
} |
rele_measure_L(); |
lcd_gotoxy(1,2); |
printf(lcd_putc,MODE_LX_NULL_MSG); |
measure_L(f1_sqr,C,L); |
// prechazime na mereni T |
mode=MODE_T; |
break; |
case MODE_T: // merei teploty |
rele_calib(); |
lcd_gotoxy(1,2); |
printf(lcd_putc,MODE_TMP_NULL_MSG); |
bit_clear(*T1CON,_TMR1ON); // zastav TMR1, vadil by |
measure_T(); |
// prechazime na generovani pulzu |
mode=MODE_P; |
break; |
case MODE_P: // generovani pulzu |
rele_calib(); |
lcd_gotoxy(1,2); |
printf(lcd_putc,MODE_PLZ_WIDTH_MSG); |
pulser(); |
// prechazime na mereni C |
mode=MODE_C; |
break; |
} // od switch |
write_eeprom(MODE_ADR,mode); // uloz ktery mod je nyni aktivni |
wait_release_keys(); // cekej na uvolneni tlacitek |
delay_ms(10); |
} // for(;;) |
} // main |
// End of File |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |