Subversion Repositories svnkaklik

Rev

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