Go to most recent revision | Blame | Last modification | View Log | Download
CCS PCM C Compiler, Version 3.221, 27853 21-VIII-05 18:18
Filename: C:\PIC\jump\miho\DART.LST
ROM used: 834 words (20%)
Largest free fragment is 2048
RAM used: 25 (14%) at main() level
42 (24%) worst case
Stack: 6 worst case (3 in main + 3 for interrupts)
*
0000: MOVLW 00
0001: MOVWF 0A
0002: GOTO 1C8
0003: NOP
0004: MOVWF 7F
0005: SWAPF 03,W
0006: CLRF 03
0007: MOVWF 21
0008: MOVF 7F,W
0009: MOVWF 20
000A: MOVF 0A,W
000B: MOVWF 28
000C: CLRF 0A
000D: SWAPF 20,F
000E: MOVF 04,W
000F: MOVWF 22
0010: MOVF 77,W
0011: MOVWF 23
0012: MOVF 78,W
0013: MOVWF 24
0014: MOVF 79,W
0015: MOVWF 25
0016: MOVF 7A,W
0017: MOVWF 26
0018: MOVF 7B,W
0019: MOVWF 27
001A: BCF 03.7
001B: BCF 03.5
001C: MOVLW 8C
001D: MOVWF 04
001E: BTFSS 00.3
001F: GOTO 022
0020: BTFSC 0C.3
0021: GOTO 039
0022: BTFSS 0B.5
0023: GOTO 026
0024: BTFSC 0B.2
0025: GOTO 03B
0026: MOVF 22,W
0027: MOVWF 04
0028: MOVF 23,W
0029: MOVWF 77
002A: MOVF 24,W
002B: MOVWF 78
002C: MOVF 25,W
002D: MOVWF 79
002E: MOVF 26,W
002F: MOVWF 7A
0030: MOVF 27,W
0031: MOVWF 7B
0032: MOVF 28,W
0033: MOVWF 0A
0034: SWAPF 21,W
0035: MOVWF 03
0036: SWAPF 7F,F
0037: SWAPF 7F,W
0038: RETFIE
0039: BCF 0A.3
003A: GOTO 089
003B: BCF 0A.3
003C: GOTO 0B7
.................... // DART01A verze programu 1.00
.................... // (c)miho 2005
....................
.................... #include "DART.h"
.................... // DART01A verze programu 1.00
.................... // (c)miho 2005
....................
.................... #include ".\lib\16F88.h" // standardni definice konstant
.................... //////// Header file for the PIC16F88
.................... #device PIC16F88
.................... #list
.................... #include ".\lib\16F88_Reg.h" // standardni definice vsech FSR
.................... #list
....................
....................
.................... #device adc=8 // AD prevodnik jen na 8 bitu
.................... #define xclock 4168000 // muj konkretni PIC je trochu rychlejsi
.................... #use delay(clock=xclock,restart_wdt)
0176: MOVLW 3D
0177: MOVWF 04
0178: MOVF 00,W
0179: BTFSC 03.2
017A: GOTO 18C
017B: MOVLW 01
017C: MOVWF 78
017D: MOVLW BF
017E: MOVWF 77
017F: CLRWDT
0180: DECFSZ 77,F
0181: GOTO 17F
0182: DECFSZ 78,F
0183: GOTO 17D
0184: MOVLW 58
0185: MOVWF 77
0186: DECFSZ 77,F
0187: GOTO 186
0188: NOP
0189: CLRWDT
018A: DECFSZ 00,F
018B: GOTO 17B
018C: RETLW 00
.................... #fuses INTRC_IO, NOWDT, NOPUT, NOPROTECT, NOBROWNOUT, MCLR, NOLVP, NOCPD, NODEBUG, CCPB3
....................
....................
....................
.................... #define BEEP0 PIN_A6 // pipak, prvni vystup
.................... #define BEEP1 PIN_A7 // pipak, druhy vystup
.................... #define PWM PIN_B3 // PWM vystup pro menic
.................... #define REFPOWER PIN_B1 // napajeni zdroje Vref
.................... #define MOTOR PIN_B2 // zapinani motoru
.................... #define SW0 PIN_B7 // konfiguracni prepinac 0
.................... #define SW1 PIN_B6 // konfiguracni prepinac 1
....................
....................
.................... void InitRS232()
.................... // Inicializace HW RS232
.................... {
.................... SPBRG=xclock/9600/16-1; // ryclost 9600Bd
.................... RCSTA=0b10000000; // enable USART
.................... TXSTA=0b00100100; // BRGH=1, TX enable
.................... }
....................
....................
.................... void Putc(char c)
.................... // Posilani znaku pres HW RS232
.................... {
.................... while(TRMT==0); // cekej na prazdny TX buffer
*
010B: BSF 03.5
010C: BTFSC 18.1
010D: GOTO 110
010E: BCF 03.5
010F: GOTO 10B
.................... TXREG=c; // predej data
0110: BCF 03.5
0111: MOVF 41,W
0112: MOVWF 19
.................... }
0113: RETLW 00
....................
....................
.................... // Globalni promenna pro data posilana na SSP
.................... // Nastavuje se funkci MotorPatternSet()
.................... // Vyuziva se v prerusovaci rutine IntSSP()
.................... unsigned int8 MotorPattern; // aktualni data pro SSP jednotku
....................
....................
.................... void MotorPatternSet(unsigned int Gear)
.................... // Na zaklade rychlosti nastavi MotorPattern pro SSP
.................... // Rychlost 0 znamena stop, rychlost 8 je maximum
.................... {
.................... // Tabulka rychlost -> pattern pro SSP
.................... unsigned int8 const ExpTab[8] = {0x02,0x06,0x0e,0x1e,0x3e,0x7e,0xfe,0xff};
....................
.................... // Vyber patternu
.................... if (Gear==0) // stav 0 znamena stop
*
008E: MOVF 44,F
008F: BTFSS 03.2
0090: GOTO 09D
.................... {
.................... output_low(MOTOR); // klidovy stav
0091: BSF 03.5
0092: BCF 06.2
0093: BCF 03.5
0094: BCF 06.2
.................... SSPSTAT = 0;
0095: BSF 03.5
0096: CLRF 14
.................... SSPCON1 = 0; // SPI stop
0097: BCF 03.5
0098: CLRF 14
.................... disable_interrupts(INT_SSP); // neni preruseni od SSP
0099: BSF 03.5
009A: BCF 0C.3
.................... }
.................... else // rizeny vykon
009B: GOTO 0B5
009C: BCF 03.5
.................... {
.................... if (Gear>7) // stav 8 a vice znamena plny vykon
009D: MOVF 44,W
009E: SUBLW 07
009F: BTFSC 03.0
00A0: GOTO 0A3
.................... {
.................... Gear=8; // plny plyn
00A1: MOVLW 08
00A2: MOVWF 44
.................... }
....................
.................... MotorPattern=ExpTab[--Gear]; // prevod z hodnoty plynu na data pro SSP
00A3: DECF 44,F
00A4: MOVF 44,W
00A5: CALL 03D
00A6: MOVWF 78
00A7: MOVWF 2A
.................... output_low(MOTOR); // klidovy stav
00A8: BSF 03.5
00A9: BCF 06.2
00AA: BCF 03.5
00AB: BCF 06.2
.................... SSPSTAT = 0;
00AC: BSF 03.5
00AD: CLRF 14
.................... SSPCON1 = 0x22; // SPI OSC/64
00AE: MOVLW 22
00AF: BCF 03.5
00B0: MOVWF 14
....................
.................... SSPBUF=MotorPattern; // prvni data pro vyslani
00B1: MOVF 2A,W
00B2: MOVWF 13
.................... enable_interrupts(INT_SSP); // az budou vyslana prijde interrupt od SSP
00B3: BSF 03.5
00B4: BSF 0C.3
.................... }
.................... }
00B5: BCF 03.5
00B6: RETLW 00
....................
....................
.................... // Obsluha preruseni od SSP jednotky, posila data z promenne MotorRun do SSP.
.................... #INT_SSP
.................... void IntSSP()
.................... {
.................... SSPBUF=MotorPattern; // znova hdnota PWM patternu na SSP
*
0089: MOVF 2A,W
008A: MOVWF 13
.................... }
....................
....................
008B: BCF 0C.3
008C: BCF 0A.3
008D: GOTO 026
.................... void MotorSet(unsigned int Gear)
*
018D: CLRF 29
018E: BTFSC 0B.7
018F: BSF 29.7
0190: BCF 0B.7
.................... // Nastavi vykon motoru dle hodnoty Gear a zahaji posilani PWM dat pres SSP pod prerusenim
.................... // od SSP jednotky
.................... // 0 stop
.................... // 1-7 pocet 1/8 vykonu
.................... // >7 plny vykon
.................... {
.................... // Nastav PWM pattern
.................... MotorPatternSet(Gear); // nastav PWM pattern pro SSP
0191: MOVF 3D,W
0192: MOVWF 44
0193: CALL 08E
0194: BTFSC 29.7
0195: BSF 0B.7
....................
.................... // Povol preruseni
.................... enable_interrupts(GLOBAL); // povol preruseni
0196: MOVLW C0
0197: IORWF 0B,F
.................... }
0198: RETLW 00
....................
....................
.................... void InitT0()
.................... // Inicializace casovace T0 (cca 1000x za sekundu)
.................... {
.................... setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4); // T0 z internich hodin 1/4
*
00D5: BSF 03.5
00D6: MOVF 01,W
00D7: ANDLW C0
00D8: IORLW 01
00D9: MOVWF 01
.................... enable_interrupts(INT_RTCC); // generuj preruseni od T0
00DA: BCF 03.5
00DB: BSF 0B.5
.................... enable_interrupts(GLOBAL); // povol preruseni
00DC: MOVLW C0
00DD: IORWF 0B,F
.................... }
00DE: BCF 0A.3
00DF: GOTO 1EF (RETURN)
....................
....................
.................... // Globalni promenna pro mereni casu
.................... // Nastavuje se procedurou TimeSet()
.................... // Testuje se funkci TimeIf()
.................... // Modifikuje se pri preruseni od casovace IntTo()
.................... unsigned int16 TimeTime;
....................
....................
.................... void TimerSet(unsigned int16 Time)
.................... // Nastavi casovac na zadany pocet ms
.................... // Test uplynuti casu se dela pomoci TimerIf()
.................... {
.................... // Nastav hodnotu
.................... disable_interrupts(INT_RTCC); // nesmi prijit preruseni
*
0199: BCF 0B.5
.................... TimeTime=Time; // pri nastavovani hodnoty
019A: MOVF 3E,W
019B: MOVWF 2C
019C: MOVF 3D,W
019D: MOVWF 2B
.................... enable_interrupts(INT_RTCC); // promenne (o delce vice nez 8 bitu)
019E: BSF 0B.5
.................... }
019F: RETLW 00
....................
....................
.................... int1 TimerIf()
.................... // Vraci TRUE pokud casovac jiz dobehl
.................... {
.................... int1 Flag; // pomocna promenna
....................
.................... // Otestuj casovac
.................... disable_interrupts(INT_RTCC); // nesmi prijit preruseni
01A0: BCF 0B.5
.................... Flag=(TimeTime==0); // behem testu promenne
01A1: MOVF 2B,F
01A2: BTFSS 03.2
01A3: GOTO 1A7
01A4: MOVF 2C,F
01A5: BTFSC 03.2
01A6: GOTO 1A9
01A7: MOVLW 00
01A8: GOTO 1AA
01A9: MOVLW 01
01AA: MOVWF 78
01AB: BTFSC 78.0
01AC: GOTO 1AF
01AD: BCF 3D.0
01AE: GOTO 1B0
01AF: BSF 3D.0
.................... enable_interrupts(INT_RTCC); // ted uz muze
01B0: BSF 0B.5
....................
.................... // Navratova hodnota
.................... return Flag; // TRUE znamena dobehl casovac
01B1: MOVLW 00
01B2: BTFSC 3D.0
01B3: MOVLW 01
01B4: MOVWF 78
.................... }
01B5: RETLW 00
....................
....................
.................... // Globalni promenne pro akceleraci
.................... // Nastavuje se metodou MotorStart()
.................... // Pouziva se v obsluze preruseni IntT0()
.................... unsigned int8 MotorTime; // aktualni casovac pro rozjezd
.................... unsigned int8 MotorDelay; // spozdeni mezi razenim
.................... unsigned int8 MotorGear; // rychlostni stupen
....................
....................
.................... void MotorStart(unsigned int8 Delay)
.................... // Provede rizeny rozjezd motoru
.................... {
.................... disable_interrupts(INT_RTCC);
01B6: BCF 0B.5
.................... MotorGear=1;
01B7: MOVLW 01
01B8: MOVWF 2F
.................... MotorDelay=Delay;
01B9: MOVF 3D,W
01BA: MOVWF 2E
.................... MotorTime=MotorDelay;
01BB: MOVF 2E,W
01BC: MOVWF 2D
.................... enable_interrupts(INT_RTCC);
01BD: BSF 0B.5
01BE: CLRF 29
01BF: BTFSC 0B.7
01C0: BSF 29.7
01C1: BCF 0B.7
....................
.................... MotorPatternSet(1);
01C2: MOVLW 01
01C3: MOVWF 44
01C4: CALL 08E
01C5: BTFSC 29.7
01C6: BSF 0B.7
.................... }
01C7: RETLW 00
....................
....................
.................... #INT_TIMER0
.................... void IntT0()
.................... // Preruseni od casovace cca 1000x za sekundu
.................... {
.................... // Odpocitavani casovace
.................... if (TimeTime) TimeTime--;
*
00B7: MOVF 2B,W
00B8: IORWF 2C,W
00B9: BTFSC 03.2
00BA: GOTO 0BF
00BB: MOVF 2B,W
00BC: BTFSC 03.2
00BD: DECF 2C,F
00BE: DECF 2B,F
....................
.................... // Obsluha akcelerace
.................... if (MotorTime) MotorTime--; // dekrementuj casovac rozjezdu
00BF: MOVF 2D,F
00C0: BTFSS 03.2
00C1: DECF 2D,F
.................... if ((MotorGear>0) && (MotorGear<8) && (!MotorTime)) // dalsi rychlostni stupen
00C2: MOVF 2F,F
00C3: BTFSC 03.2
00C4: GOTO 0D2
00C5: MOVF 2F,W
00C6: SUBLW 07
00C7: BTFSS 03.0
00C8: GOTO 0D2
00C9: MOVF 2D,F
00CA: BTFSS 03.2
00CB: GOTO 0D2
.................... {
.................... MotorTime=MotorDelay; // znovu nastav casovac
00CC: MOVF 2E,W
00CD: MOVWF 2D
.................... MotorGear++; // dalsi rychlost
00CE: INCF 2F,F
.................... MotorPatternSet(MotorGear); // nastav rychlost
00CF: MOVF 2F,W
00D0: MOVWF 44
00D1: CALL 08E
.................... }
.................... }
....................
....................
.................... // Cteni dat z AD prevodniku, zadava se cislo kanalu
00D2: BCF 0B.2
00D3: BCF 0A.3
00D4: GOTO 026
.................... int8 ReadAD(int8 Ch)
.................... {
.................... // Pokud merim Vref zapnu si jeho napajeni
.................... if (Ch==4) output_high(REFPOWER);
*
00E0: MOVF 3D,W
00E1: SUBLW 04
00E2: BTFSS 03.2
00E3: GOTO 0E8
00E4: BSF 03.5
00E5: BCF 06.1
00E6: BCF 03.5
00E7: BSF 06.1
....................
.................... // Inicializace a cislo kanalu
.................... ADCON1=0x30; // Vref+-, bez deleni hodin, Left Justify
00E8: MOVLW 30
00E9: BSF 03.5
00EA: MOVWF 1F
.................... ADCON0=0x41+(Ch<<3); // on, Tosc/8, cislo kanalu
00EB: BCF 03.5
00EC: RLF 3D,W
00ED: MOVWF 77
00EE: RLF 77,F
00EF: RLF 77,F
00F0: MOVLW F8
00F1: ANDWF 77,F
00F2: MOVF 77,W
00F3: ADDLW 41
00F4: MOVWF 1F
....................
.................... // Mereni
.................... delay_us(50); // doba na prepnuti kanalu
00F5: CLRWDT
00F6: MOVLW 10
00F7: MOVWF 77
00F8: DECFSZ 77,F
00F9: GOTO 0F8
00FA: NOP
00FB: NOP
.................... ADCON0 |= 4; // start prevodu
00FC: BSF 1F.2
.................... delay_us(50); // doba na prevod
00FD: CLRWDT
00FE: MOVLW 10
00FF: MOVWF 77
0100: DECFSZ 77,F
0101: GOTO 100
0102: NOP
0103: NOP
....................
.................... // Vypnu napajeni Vref (vzdycky)
.................... output_low(REFPOWER);
0104: BSF 03.5
0105: BCF 06.1
0106: BCF 03.5
0107: BCF 06.1
....................
.................... // Navrat hodnoty
.................... return ADRESH;
0108: MOVF 1E,W
0109: MOVWF 78
.................... }
010A: RETLW 00
....................
....................
.................... void main()
.................... {
*
01C8: CLRF 04
01C9: MOVLW 1F
01CA: ANDWF 03,F
01CB: BSF 03.5
01CC: BCF 1F.4
01CD: BCF 1F.5
01CE: MOVF 1B,W
01CF: ANDLW 80
01D0: MOVWF 1B
01D1: MOVLW 07
01D2: MOVWF 1C
01D3: MOVF 05,W
01D4: CLRWDT
01D5: MOVF 1C,W
01D6: BCF 03.5
01D7: BCF 0D.6
.................... unsigned int8 Debug;
.................... unsigned int8 i;
....................
.................... // Hodiny
.................... OSCCON = 0x62; // 4 MHz interni RC oscilator
01D8: MOVLW 62
01D9: BSF 03.5
01DA: MOVWF 0F
.................... /*
.................... // Digitalni vystupy
.................... output_low(PWM); // PWM vystup
.................... output_low(MOTOR); // Proud do motoru
.................... output_low(REFPOWER); // Napajeni Vref
.................... port_b_pullups(TRUE); // Zbyvajici vyvody portu B
....................
.................... // Watch Dog
.................... PSA=0; // preddelic prirazen casovaci
.................... WDTCON=0x0E; // Watch Dog cca 130ms
.................... // Analogove vstupy
.................... ANSEL = 0x1F; // AN0 az AN4
....................
.................... // nastaveni RS232
.................... InitRS232(); // inicializace HW RS232 (nutno pockat cca 10ms)
....................
.................... // Pipnuti (a cekani)
.................... for (i=1;i<30;i++) // pocet 1/2 period
.................... {
.................... int1 beep; // stavova promenna pro pipak
....................
.................... output_bit(BEEP0,beep);
.................... beep=~beep;
.................... output_bit(BEEP1,beep);
.................... delay_us(1000);
.................... }
....................
.................... // Rozhodnuti o rezimu cinnosti
.................... Debug=0;
.................... if (~input(SW0)) Debug|=1; // precti bit 0
.................... if (~input(SW1)) Debug|=2; // precti bit 1
.................... output_low(SW0); // nastav L aby se snizila spotreba
.................... output_low(SW1); // na obou vstupech
....................
.................... // Zobrazeni rezimu
.................... printf(Putc,"\fMode:%d",Debug);
.................... */
.................... // Inicializace PWM
.................... PR2 = 0x1F; // perioda PWM casovace
01DB: MOVLW 1F
01DC: MOVWF 12
.................... T2CON = 0x04; // povoleni casovace T2 bez preddelicu a postdelicu
01DD: MOVLW 04
01DE: BCF 03.5
01DF: MOVWF 12
.................... CCP1CON = 0x0C; // PWM mode, lsb bity nulove
01E0: MOVLW 0C
01E1: MOVWF 17
.................... CCPR1L = 0; // na zacatku nulova data
01E2: CLRF 15
.................... output_low(PWM); // PWM vystup
01E3: BSF 03.5
01E4: BCF 06.3
01E5: BCF 03.5
01E6: BCF 06.3
....................
.................... //!!!KAKL
.................... CCPR1L = 20; // pouziti vystupu
01E7: MOVLW 14
01E8: MOVWF 15
.................... disable_interrupts(GLOBAL);
01E9: BCF 0B.6
01EA: BCF 0B.7
01EB: BTFSC 0B.7
01EC: GOTO 1EA
.................... while(true);
01ED: GOTO 1ED
....................
.................... // Inicializace casovace
.................... InitT0(); // nastav casovac na cca 1ms
01EE: GOTO 0D5
....................
.................... //!!!KAKL
.................... Debug=3;
01EF: MOVLW 03
01F0: MOVWF 30
....................
.................... // Test menice PWM a rozjezdoveho PWM
.................... if (Debug==1)
01F1: DECFSZ 30,W
01F2: GOTO 22C
.................... {
.................... unsigned int8 Data1; // poteniometr P1 = PWM
.................... unsigned int8 Data2; // poteniometr P2 = Rozjezd
....................
.................... while (1)
.................... {
.................... // watch dog
.................... restart_wdt();
01F3: CLRWDT
....................
.................... // mereni vstupu
.................... Data1=ReadAD(0); // nacti parametr pro PWM
01F4: CLRF 3D
01F5: CALL 0E0
01F6: MOVF 78,W
01F7: MOVWF 32
.................... Data1>>=2; // redukuj rozsah na 0 az 63
01F8: RRF 32,F
01F9: RRF 32,F
01FA: MOVLW 3F
01FB: ANDWF 32,F
.................... Data2=ReadAD(1); // nacti parametr pro rozjezd
01FC: MOVLW 01
01FD: MOVWF 3D
01FE: CALL 0E0
01FF: MOVF 78,W
0200: MOVWF 33
.................... Data2>>=4; // redukuj rozsah na 0 az 15
0201: SWAPF 33,F
0202: MOVLW 0F
0203: ANDWF 33,F
....................
.................... // zobrazeni
.................... printf(Putc,"\nPWM:%03u RUN:%03u",Data1,Data2);
0204: CLRF 3D
0205: MOVF 3D,W
0206: CALL 049
0207: INCF 3D,F
0208: MOVWF 77
0209: MOVWF 41
020A: CALL 10B
020B: MOVLW 05
020C: SUBWF 3D,W
020D: BTFSS 03.2
020E: GOTO 205
020F: MOVF 32,W
0210: MOVWF 3F
0211: CLRF 40
0212: CALL 129
0213: MOVLW 09
0214: MOVWF 3E
0215: MOVF 3E,W
0216: CALL 049
0217: INCF 3E,F
0218: MOVWF 77
0219: MOVWF 41
021A: CALL 10B
021B: MOVLW 0E
021C: SUBWF 3E,W
021D: BTFSS 03.2
021E: GOTO 215
021F: MOVF 33,W
0220: MOVWF 3F
0221: CLRF 40
0222: CALL 129
.................... delay_ms(20);
0223: MOVLW 14
0224: MOVWF 3D
0225: CALL 176
....................
.................... // nastaveni parametru PWM
.................... CCPR1L = Data1;
0226: MOVF 32,W
0227: MOVWF 15
....................
.................... // nastaveni parametru RUN
.................... MotorSet(Data2);
0228: MOVF 33,W
0229: MOVWF 3D
022A: CALL 18D
.................... }
022B: GOTO 1F3
.................... }
....................
.................... // Testovani rozjezdu
.................... // Zadava se cas mezi stupni razeni pro rozjezd v ms
.................... if (Debug==2)
022C: MOVF 30,W
022D: SUBLW 02
022E: BTFSS 03.2
022F: GOTO 27D
.................... {
.................... int8 Data;
.................... int8 Start;
....................
.................... Start=0; // uvodni stav
0230: CLRF 35
.................... while(1)
.................... {
.................... // Nacti a zobraz parametr
.................... Data=ReadAD(1); // potenciometr P2 = rozjezd
0231: MOVLW 01
0232: MOVWF 3D
0233: CALL 0E0
0234: MOVF 78,W
0235: MOVWF 34
.................... printf(Putc,"\nRUN: %3ums ",Data); // zobraz
0236: CLRF 3D
0237: MOVF 3D,W
0238: CALL 060
0239: INCF 3D,F
023A: MOVWF 77
023B: MOVWF 41
023C: CALL 10B
023D: MOVLW 06
023E: SUBWF 3D,W
023F: BTFSS 03.2
0240: GOTO 237
0241: MOVF 34,W
0242: MOVWF 3F
0243: MOVLW 10
0244: MOVWF 40
0245: CALL 129
0246: MOVLW 6D
0247: MOVWF 41
0248: CALL 10B
0249: MOVLW 73
024A: MOVWF 41
024B: CALL 10B
024C: MOVLW 20
024D: MOVWF 41
024E: CALL 10B
.................... delay_ms(10); // prodleva pro terminal
024F: MOVLW 0A
0250: MOVWF 3D
0251: CALL 176
....................
.................... // Uvodni pauza
.................... if (Start==0) // spousti se 1x na zacatku
0252: MOVF 35,F
0253: BTFSS 03.2
0254: GOTO 25B
.................... {
.................... Start++; // dalsi stav je cekani
0255: INCF 35,F
.................... TimerSet(2000); // na dokonceni uvodni prodlevy
0256: MOVLW 07
0257: MOVWF 3E
0258: MOVLW D0
0259: MOVWF 3D
025A: CALL 199
.................... }
....................
.................... // Rozjezd
.................... if ((Start==1) && TimerIf())
025B: DECFSZ 35,W
025C: GOTO 26D
025D: CALL 1A0
025E: MOVF 78,F
025F: BTFSC 03.2
0260: GOTO 26D
.................... {
.................... Start++;
0261: INCF 35,F
.................... printf(Putc,"R");
0262: MOVLW 52
0263: MOVWF 41
0264: CALL 10B
.................... MotorStart(Data); // rozjezd s nastavenim prodlevy
0265: MOVF 34,W
0266: MOVWF 3D
0267: CALL 1B6
....................
.................... TimerSet(2000); // nastav celkovy cas jizdy
0268: MOVLW 07
0269: MOVWF 3E
026A: MOVLW D0
026B: MOVWF 3D
026C: CALL 199
.................... }
....................
.................... // Zastaveni
.................... if ((Start==2) && TimerIf())
026D: MOVF 35,W
026E: SUBLW 02
026F: BTFSS 03.2
0270: GOTO 27B
0271: CALL 1A0
0272: MOVF 78,F
0273: BTFSC 03.2
0274: GOTO 27B
.................... {
.................... Start++;
0275: INCF 35,F
.................... printf(Putc,"S");
0276: MOVLW 53
0277: MOVWF 41
0278: CALL 10B
.................... MotorSet(0); // pokud dobehl casovac zastav motor
0279: CLRF 3D
027A: CALL 18D
.................... }
....................
.................... // watch dog
.................... restart_wdt();
027B: CLRWDT
.................... }
027C: GOTO 231
.................... }
....................
.................... // Test nabijeciho algoritmu
.................... if (Debug==3)
027D: MOVF 30,W
027E: SUBLW 03
027F: BTFSS 03.2
0280: GOTO 2DB
.................... {
.................... unsigned int8 PwmOut; // akcni hodnota pro PWM
.................... unsigned int8 Req; // pozadovana hodnota z P1
.................... unsigned int8 Vref; // merena hodnota vref
....................
.................... // Inicializace stavove promenne
.................... PwmOut=0;
0281: CLRF 36
....................
.................... // Hlavni smycka
.................... while (1)
.................... {
.................... // watch dog
.................... restart_wdt();
0282: CLRWDT
....................
.................... // pozadovana hodnota (potenciometr P1)
.................... Req=ReadAD(0);
0283: CLRF 3D
0284: CALL 0E0
0285: MOVF 78,W
0286: MOVWF 37
.................... Req=50+(ReadAD(0)>>1); // 50 az 177
0287: CLRF 3D
0288: CALL 0E0
0289: BCF 03.0
028A: RRF 78,W
028B: ADDLW 32
028C: MOVWF 37
....................
.................... // napeti na napajeni (vref)
.................... Vref=ReadAD(4);
028D: MOVLW 04
028E: MOVWF 3D
028F: CALL 0E0
0290: MOVF 78,W
0291: MOVWF 38
....................
.................... // ricici algoritmus
.................... if ((Vref<Req) &&(PwmOut<30)) PwmOut++;
0292: MOVF 37,W
0293: SUBWF 38,W
0294: BTFSC 03.0
0295: GOTO 29A
0296: MOVF 36,W
0297: SUBLW 1D
0298: BTFSC 03.0
0299: INCF 36,F
.................... if ((Vref>=Req)&&(PwmOut> 0)) PwmOut--;
029A: MOVF 37,W
029B: SUBWF 38,W
029C: BTFSS 03.0
029D: GOTO 2A1
029E: MOVF 36,F
029F: BTFSS 03.2
02A0: DECF 36,F
.................... Vref+=10;
02A1: MOVLW 0A
02A2: ADDWF 38,F
.................... if ((Vref<(Req))&&(PwmOut<30)) PwmOut++; // urychleni nabehu
02A3: MOVF 37,W
02A4: SUBWF 38,W
02A5: BTFSC 03.0
02A6: GOTO 2AB
02A7: MOVF 36,W
02A8: SUBLW 1D
02A9: BTFSC 03.0
02AA: INCF 36,F
....................
.................... // nastaveni parametru PWM
.................... if (PwmOut>24) PwmOut=24; // saturace
02AB: MOVF 36,W
02AC: SUBLW 18
02AD: BTFSC 03.0
02AE: GOTO 2B1
02AF: MOVLW 18
02B0: MOVWF 36
.................... //!!!KAKL
.................... PwmOut=20;
02B1: MOVLW 14
02B2: MOVWF 36
.................... CCPR1L = PwmOut; // pouziti vystupu
02B3: MOVF 36,W
02B4: MOVWF 15
.................... disable_interrupts(GLOBAL);
02B5: BCF 0B.6
02B6: BCF 0B.7
02B7: BTFSC 0B.7
02B8: GOTO 2B6
.................... while(true);
02B9: GOTO 2B9
.................... // zobrazeni
.................... printf(Putc,"\nALG:%03u %03u %03u",Req,Vref,PwmOut);
02BA: CLRF 3D
02BB: MOVF 3D,W
02BC: CALL 071
02BD: INCF 3D,F
02BE: MOVWF 77
02BF: MOVWF 41
02C0: CALL 10B
02C1: MOVLW 05
02C2: SUBWF 3D,W
02C3: BTFSS 03.2
02C4: GOTO 2BB
02C5: MOVF 37,W
02C6: MOVWF 3F
02C7: CLRF 40
02C8: CALL 129
02C9: MOVLW 20
02CA: MOVWF 41
02CB: CALL 10B
02CC: MOVF 38,W
02CD: MOVWF 3F
02CE: CLRF 40
02CF: CALL 129
02D0: MOVLW 20
02D1: MOVWF 41
02D2: CALL 10B
02D3: MOVF 36,W
02D4: MOVWF 3F
02D5: CLRF 40
02D6: CALL 129
.................... delay_ms(10);
02D7: MOVLW 0A
02D8: MOVWF 3D
02D9: CALL 176
.................... }
02DA: GOTO 282
.................... }
....................
.................... // Standardni beh
.................... if (Debug==0)
02DB: MOVF 30,F
02DC: BTFSS 03.2
02DD: GOTO 341
.................... {
.................... unsigned int8 PwmOut; // akcni hodnota pro PWM
.................... unsigned int8 Req; // pozadovana hodnota z P1
.................... unsigned int8 Vref; // merena hodnota vref
.................... int1 Run;
....................
.................... // Inicializace stavove promenne
.................... PwmOut=0;
02DE: CLRF 39
.................... TimerSet(14000); // casovani startu
02DF: MOVLW 36
02E0: MOVWF 3E
02E1: MOVLW B0
02E2: MOVWF 3D
02E3: CALL 199
.................... Run=1;
02E4: BSF 3C.0
....................
.................... // Hlavni smycka
.................... while (1)
.................... {
.................... // watch dog
.................... restart_wdt();
02E5: CLRWDT
....................
.................... // pozadovana hodnota (potenciometr P1)
.................... Req=ReadAD(0);
02E6: CLRF 3D
02E7: CALL 0E0
02E8: MOVF 78,W
02E9: MOVWF 3A
.................... Req=50+(ReadAD(0)>>1); // 50 az 177
02EA: CLRF 3D
02EB: CALL 0E0
02EC: BCF 03.0
02ED: RRF 78,W
02EE: ADDLW 32
02EF: MOVWF 3A
....................
.................... // napeti na napajeni (vref)
.................... Vref=ReadAD(4);
02F0: MOVLW 04
02F1: MOVWF 3D
02F2: CALL 0E0
02F3: MOVF 78,W
02F4: MOVWF 3B
....................
.................... // ricici algoritmus
.................... if ((Vref<Req) &&(PwmOut<30)) PwmOut++;
02F5: MOVF 3A,W
02F6: SUBWF 3B,W
02F7: BTFSC 03.0
02F8: GOTO 2FD
02F9: MOVF 39,W
02FA: SUBLW 1D
02FB: BTFSC 03.0
02FC: INCF 39,F
.................... if ((Vref>=Req)&&(PwmOut> 0)) PwmOut--;
02FD: MOVF 3A,W
02FE: SUBWF 3B,W
02FF: BTFSS 03.0
0300: GOTO 304
0301: MOVF 39,F
0302: BTFSS 03.2
0303: DECF 39,F
.................... Vref+=10;
0304: MOVLW 0A
0305: ADDWF 3B,F
.................... if ((Vref<(Req))&&(PwmOut<30)) PwmOut++; // urychleni nabehu
0306: MOVF 3A,W
0307: SUBWF 3B,W
0308: BTFSC 03.0
0309: GOTO 30E
030A: MOVF 39,W
030B: SUBLW 1D
030C: BTFSC 03.0
030D: INCF 39,F
....................
.................... // nastaveni parametru PWM
.................... if (PwmOut>24) PwmOut=24; // saturace
030E: MOVF 39,W
030F: SUBLW 18
0310: BTFSC 03.0
0311: GOTO 314
0312: MOVLW 18
0313: MOVWF 39
.................... CCPR1L = PwmOut; // pouziti vystupu
0314: MOVF 39,W
0315: MOVWF 15
....................
.................... // zobrazeni
.................... printf(Putc,"\nALG:%03u %03u %03u",Req,Vref,PwmOut);
0316: CLRF 3D
0317: MOVF 3D,W
0318: CALL 071
0319: INCF 3D,F
031A: MOVWF 77
031B: MOVWF 41
031C: CALL 10B
031D: MOVLW 05
031E: SUBWF 3D,W
031F: BTFSS 03.2
0320: GOTO 317
0321: MOVF 3A,W
0322: MOVWF 3F
0323: CLRF 40
0324: CALL 129
0325: MOVLW 20
0326: MOVWF 41
0327: CALL 10B
0328: MOVF 3B,W
0329: MOVWF 3F
032A: CLRF 40
032B: CALL 129
032C: MOVLW 20
032D: MOVWF 41
032E: CALL 10B
032F: MOVF 39,W
0330: MOVWF 3F
0331: CLRF 40
0332: CALL 129
.................... delay_ms(10);
0333: MOVLW 0A
0334: MOVWF 3D
0335: CALL 176
....................
.................... // rozjezd
.................... if (TimerIf()&&Run)
0336: CALL 1A0
0337: MOVF 78,F
0338: BTFSC 03.2
0339: GOTO 340
033A: BTFSS 3C.0
033B: GOTO 340
.................... {
.................... Run=0;
033C: BCF 3C.0
.................... MotorStart(65);
033D: MOVLW 41
033E: MOVWF 3D
033F: CALL 1B6
.................... }
.................... }
0340: GOTO 2E5
.................... }
.................... }
....................
0341: SLEEP
Configuration Fuses:
Word 1: 2F38 NOWDT NOPUT MCLR NOBROWNOUT NOLVP NOCPD NOWRT NODEBUG CCPB3 NOPROTECT INTRC_IO
Word 2: 3FFF FCMEN IESO