Announcement

Collapse
No announcement yet.

Reverse Engineering ClonePI Software

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

  • Reverse Engineering ClonePI Software

    Hi,
    I started to disassembling ClonePI software. I'm trying to obtain C source code from hex file. Manually converting C code from assembly listing is a slow process. May be in the forum we can do it more easily together. Any help is appreciated.

    Original hex file is ClonePI-18.hex, downloaded from www.fandy.front.ru/CPI_PRG_181_18.zip
    I'm using Ida Pro V5.1, MPLAB IDE V8.0, HI-TECH PICC-18 V8.30

    Here is the first part of C conversion

    Code:
    #include    <hitech.h>
    #include    <pic18.h>
    #include    <stdio.h>
    
    //-----------------------------------
    #define    ADC_CS        RA3
    #define    LCD_RS        RC4
    #define LCD_EN        RC5
    #define LCD_DATA    PORTB
    
    //------ LCD Module commands --------
    #define    DISP_ON        0x0C
    #define    CLR_DISP    0x01
    #define    ENTRY_INC    0x06
    
    #define    LINE1    0x80
    #define    LINE2    0xC0
    //-----------------------------------
    
    void InitLCD(void);
    void EepromWait(void);
    void SendINS(BYTE c);
    
    BYTE Barrier;    //5F2
    BYTE Volume;    //5F3
    
    void main(void) {
        IPEN = 0;
        INTCON = 0;
        INTCON3 = 0;
        PIE1 = 0;
        PIE2 = 0;
        PIR1 = 0;
        PIR2 = 0;
        ADCON1 = 7;
    /*
    0A9C main:    
    0A9C         nop
    0A9E         bcf     rcon, 7, ACCESS
    0AA0         clrf     intcon, ACCESS
    0AA2         clrf     intcon3, ACCESS
    0AA4         clrf     pie1, ACCESS
    0AA6         clrf     pie2, ACCESS
    0AA8         clrf     pir1, ACCESS
    0AAA         clrf     pir2, ACCESS
    0AAC         movlw     7
    0AAE         movwf     adcon1, ACCESS
    */
        PORTA = 0b00101000;
        PORTB = 0b00000000;
        PORTC = 0b00000100;
        TRISA = 0b11010011;
        TRISB = 0b11110000;
        TRISC = 0b11000000;
        RBPU = 0;
    /*
    0AB0         movlw     28
    0AB2         movwf     porta,    ACCESS
    0AB4         clrf     portb,    ACCESS
    0AB6         movlw     4
    0AB8         movwf     portc,    ACCESS
    0ABA         movlw     0D3
    0ABC         movwf     trisa,    ACCESS
    0ABE         movlw     0F0
    0AC0         movwf     trisb,    ACCESS
    0AC2         movlw     0C0
    0AC4         movwf     trisc,    ACCESS
    0AC6         bcf     intcon2, 7, ACCESS
    */
        InitLCD();
        printf("    Clone PI    ");
        SendINS(LINE2);
        printf("  ver. 1.8.1a   ");
    /*
    0AC8         call     InitLCD, 0
    0ACC         movlb     1
    06EA aClonePi     data "    Clone PI    "<0>
    0ACE         movlw     0EA
    0AD0         movwf     byte_DATA_131,    BANKED
    0AD2         movlw     6
    0AD4         movwf     byte_DATA_132,    BANKED
    0AD6         call     printf, 0
    0ADA         movlw     0C0
    0ADC         call     SendINS, 0
    0AE0         movlb     1
    06C8 aVer_1_8_1a     data "  ver. 1.8.1a   "<0>
    0AE2         movlw     0C8
    0AE4         movwf     byte_DATA_131,    BANKED
    0AE6         movlw     6
    0AE8         movwf     byte_DATA_132,    BANKED
    0AEA         call     printf, 0
    */
        EepromWait();
        Volume = EEPROM_READ(0);
    /*
    0AEE         call     EepromWait, 0
    0AF2         clrf     eeadr,    ACCESS
    0AF4         btfss     intcon, 7, ACCESS
    0AF6         bra     loc_MEM_AFC
    0AF8         bsf     STATUS, 0, ACCESS
    0AFA         bra     loc_MEM_AFE
    0AFC loc_MEM_AFC:
    0AFC         bcf     STATUS, 0, ACCESS
    0AFE loc_MEM_AFE:
    0AFE         bcf     intcon, 7, ACCESS
    0B00         movlw     3F
    0B02         andwf     EECON1, f, ACCESS
    0B04         bsf     EECON1, 0, ACCESS
    0B06         movf     eedata, w, ACCESS
    0B08         movwf     eeadr,    ACCESS
    0B0A         bcf     intcon, 7, ACCESS
    0B0C         btfsc     STATUS, 0, ACCESS
    0B0E         bsf     intcon, 7, ACCESS
    0B10         movff     eeadr,    Volume
    */
        if(Volume >= 8)
            Volume = 5;
    /*
    0B14         movlw     7
    0B16         movlb     5
    0B18         cpfsgt     Volume, BANKED
    0B1A         bra     loc_MEM_B22
    0B1C         movlw     5
    0B1E         movff     wreg, Volume
    0B22 loc_MEM_B22:
    */
        EepromWait();
        Barrier = EEPROM_READ(1);
        if( (Barrier > 16) || (Barrier < 1) )
            Barrier = 4;
    /*
    0B22         call     EepromWait, 0
    0B26         movlw     1
    0B28         movwf     eeadr,    ACCESS
    0B2A         btfss     intcon, 7, ACCESS
    0B2C         bra     loc_MEM_B32
    0B2E         bsf     STATUS, 0, ACCESS
    0B30         bra     loc_MEM_B34
    0B32 loc_MEM_B32:
    0B32         bcf     STATUS, 0, ACCESS
    0B34 loc_MEM_B34:
    0B34         bcf     intcon, 7, ACCESS
    0B36         movlw     3F
    0B38         andwf     EECON1, f, ACCESS
    0B3A         bsf     EECON1, 0, ACCESS
    0B3C         movf     eedata, w, ACCESS
    0B3E         movwf     eeadr,    ACCESS
    0B40         bcf     intcon, 7, ACCESS
    0B42         btfsc     STATUS, 0, ACCESS
    0B44         bsf     intcon, 7, ACCESS
    0B46         movff     eeadr,    Barrier
    0B4A         movlw     10
    0B4C         movlb     5
    0B4E         cpfsgt     Barrier, BANKED
    0B50         bra     loc_MEM_B54
    0B52         bra     loc_MEM_B5C
    0B54 loc_MEM_B54:
    0B54         movlw     1
    0B56         movlb     5
    0B58         cpfslt     Barrier, BANKED
    0B5A         bra     loc_MEM_B62
    0B5C loc_MEM_B5C:
    0B5C         movlw     4
    0B5E         movff     wreg, Barrier
    0B62 loc_MEM_B62:
    */
    }

  • #2
    First, I'm converting the easy parts.

    Code:
    void InitADC(void) {
       ADCON1 = 0x0E;
       ADCON0 = 0x81;
    /*
    2276         nop
    2278 loc_MEM_2278:
    2278         movlw     8E
    227A         movwf     adcon1, ACCESS
    227C         movlw     81
    227E         movwf     adcon0, ACCESS
    2280         return     0
    2282         nop
    2284         bra     loc_MEM_2278
    */
    }
    
    void InitUSART(void) {
        BRGH = 0;    //low baud rate
        SPBRG = 1;    //DevFreq/(4*ADCFreq)    ; Baud Rate
        SYNC = 1;    // synchronous
        CSRC = 1;    //1 = Master mode (clock generated internally from BRG)
        SPEN = 1;    //1 = Serial port enabled (configures RC7/RX/DT and RC6/TX/CK pins as serial port pins)
        SREN = 0;    //0 = Disables single receive
        CREN = 0;    //0 = Disables continuous receive
        RX9 = 0;    //9th bit of Received Data
    /*
    221E         nop
    2220 loc_MEM_2220:
    2220         bcf     txsta,    2, ACCESS
    2222         movlw     1
    2224         movwf     spbrg,    ACCESS
    2226         bsf     txsta,    4, ACCESS
    2228         bsf     txsta,    7, ACCESS
    222A         bsf     rcsta,    7, ACCESS
    222C         bcf     rcsta,    5, ACCESS
    222E         bcf     rcsta,    4, ACCESS
    2230         bcf     rcsta,    6, ACCESS
    2232         return     0
    2234         nop
    2236         bra     loc_MEM_2220
    */
    }
    
    void InitCCP1(void) {
        TMR1H = 0;
        TMR1L = 0;
        T1CON = 0b00110000;
        CCPR1H = 0x06;
        CCPR1L = 0x1A;
        CCP1CON = 0b00001011;
        PIE1 = 0;
        PIE2 = 0;
        CCP1IE = 1;
        PEIE = 1;
        GIE = 1;
        TMR1ON = 1;
    /*
    2238         nop
    223A loc_MEM_223A:
    223A         clrf     tmr1h,    ACCESS
    223C         clrf     tmr1l,    ACCESS
    223E         movlw     30
    2240         movwf     t1con,    ACCESS
    2242         movlw     6
    2244         movwf     ccpr1h, ACCESS
    2246         movlw     1A
    2248         movwf     ccpr1l, ACCESS
    224A         movlw     0B
    224C         movwf     ccp1con, ACCESS
    224E         clrf     pie1, ACCESS
    2250         clrf     pie2, ACCESS
    2252         bsf     pie1, 2, ACCESS
    2254         bsf     intcon, 6, ACCESS
    2256         bsf     intcon, 7, ACCESS
    2258         bsf     t1con,    0, ACCESS
    225A         return     0
    225C         nop
    225E         bra     loc_MEM_223A
    */
    }
    
    void InitCCP2(void) {
        TMR2 = 0;
        T2CKPS1 = 1;
        PR2 = 0xFF;
        CCPR2L = 0x1F;
        CCP2CON = 0x0C;
    /*
    2260         nop
    2262 loc_MEM_2262:
    2262         clrf     tmr2, ACCESS
    2264         bsf     t2con,    1, ACCESS
    2266         setf     pr2, ACCESS
    2268         movlw     1F
    226A         movwf     ccpr2l, ACCESS
    226C         movlw     0C
    226E         movwf     ccp2con, ACCESS
    2270         return     0
    2272         nop
    2274         bra     loc_MEM_2262
    */
    }
    
    void InitLCD(void) {
        DelayMs(20);
        LCD_RS=0;
        NybbleOut(3);    //Reset Command
        DelayMs(3);
        NybbleOut(3);
        DelayMs(3);
        NybbleOut(3);
        DelayMs(3);
        NybbleOut(2);    //Set 4 Bit Mode
        DelayUs(150);
    /*
    019E         nop
    01A0 loc_MEM_1A0:
    01A0         movlw     14
    01A2         call     DelayMs, 0
    01A6         bcf     LCD_RS, ACCESS
    01A8         movlw     3
    01AA         rcall     NybbleOut
    01AC         movlw     3
    01AE         call     DelayMs, 0
    01B2         movlw     3
    01B4         rcall     NybbleOut
    01B6         movlw     3
    01B8         call     DelayMs, 0
    01BC         movlw     3
    01BE         rcall     NybbleOut
    01C0         movlw     3
    01C2         call     DelayMs, 0
    01C6         movlw     2
    01C8         rcall     NybbleOut
    01CA         movlw     96
    01CC         movwf     fsr2l,    ACCESS
    01CE         bra     loc_MEM_1D4
    01D0 loc_MEM_1D0:
    01D0         nop
    01D2         nop
    01D4 loc_MEM_1D4:
    01D4         decfsz     fsr2l,    f, ACCESS
    01D6         bra     loc_MEM_1D0
    */
        SendINS(0x28);        //4 bit, 2 Line, 5x7 font
        SendINS(0x10);        //display shift off
        SendINS(CLR_DISP);    //Clear the Display RAM
        DelayMs(3);            //Note, Can take up to 4.1 msecs
        SendINS(ENTRY_INC);    //increment cursor
        SendINS(DISP_ON);    //display on cursor off
        SendINS(0x48);
    /*
    01D8         movlw     28
    01DA         rcall     SendINS
    01DC         movlw     10
    01DE         rcall     SendINS
    01E0         movlw     1
    01E2         rcall     SendINS
    01E4         movlw     3
    01E6         call     DelayMs, 0
    01EA         movlw     6
    01EC         rcall     SendINS
    01EE         movlw     0C
    01F0         rcall     SendINS
    01F2         movlw     48
    01F4         rcall     SendINS
    */
        putchar(0x00); putchar(0x00); putchar(0x1F); putchar(0x1F);    putchar(0x1F); putchar(0x1F); putchar(0x00); putchar(0x00);
        putchar(0x00); putchar(0x01); putchar(0x01); putchar(0x01);    putchar(0x01); putchar(0x01); putchar(0x01); putchar(0x00);
        putchar(0x00); putchar(0x01); putchar(0x1F); putchar(0x1F);    putchar(0x1F); putchar(0x1F); putchar(0x01); putchar(0x00);
        putchar(0x10); putchar(0x18); putchar(0x1C); putchar(0x1E); putchar(0x1C); putchar(0x18); putchar(0x10); putchar(0x00);
        putchar(0x01); putchar(0x03); putchar(0x07); putchar(0x0F); putchar(0x07); putchar(0x03); putchar(0x01); putchar(0x00);
        SendINS(LINE1);
    /*
    01F6         movlw     0
    01F8         rcall     putchar
    01FA         movlw     0
    01FC         rcall     putchar
    01FE         movlw     1F
    0200         rcall     putchar
    0202         movlw     1F
    0204         rcall     putchar
    0206         movlw     1F
    0208         rcall     putchar
    020A         movlw     1F
    020C         rcall     putchar
    020E         movlw     0
    0210         rcall     putchar
    0212         movlw     0
    0214         rcall     putchar
    0216         movlw     0
    0218         rcall     putchar
    021A         movlw     1
    021C         rcall     putchar
    021E         movlw     1
    0220         rcall     putchar
    0222         movlw     1
    0224         rcall     putchar
    0226         movlw     1
    0228         rcall     putchar
    022A         movlw     1
    022C         rcall     putchar
    022E         movlw     1
    0230         rcall     putchar
    0232         movlw     0
    0234         rcall     putchar
    0236         movlw     0
    0238         rcall     putchar
    023A         movlw     1
    023C         rcall     putchar
    023E         movlw     1F
    0240         rcall     putchar
    0242         movlw     1F
    0244         rcall     putchar
    0246         movlw     1F
    0248         rcall     putchar
    024A         movlw     1F
    024C         rcall     putchar
    024E         movlw     1
    0250         rcall     putchar
    0252         movlw     0
    0254         rcall     putchar
    0256         movlw     10
    0258         rcall     putchar
    025A         movlw     18
    025C         rcall     putchar
    025E         movlw     1C
    0260         rcall     putchar
    0262         movlw     1E
    0264         rcall     putchar
    0266         movlw     1C
    0268         rcall     putchar
    026A         movlw     18
    026C         rcall     putchar
    026E         movlw     10
    0270         rcall     putchar
    0272         movlw     0
    0274         rcall     putchar
    0276         movlw     1
    0278         rcall     putchar
    027A         movlw     3
    027C         rcall     putchar
    027E         movlw     7
    0280         rcall     putchar
    0282         movlw     0F
    0284         rcall     putchar
    0286         movlw     7
    0288         rcall     putchar
    028A         movlw     3
    028C         rcall     putchar
    028E         movlw     1
    0290         rcall     putchar
    0292         movlw     0
    0294         rcall     putchar
    0296         movlw     80
    0298         bra     SendINS
    029A         nop
    029C         bra     loc_MEM_1A0
    */
    }
    
    #define    DelayUs(x)    { unsigned char _dcnt; \
                  _dcnt=(x*(10/4)/2); \
                  while(--_dcnt > 0) \
                    {\
                    asm("nop");\
                    asm("nop");\
                    continue; }\
            } 
    
    void DelayMs(BYTE cnt) {
        BYTE i;
        #define uS_CNT  246
        
        while(cnt--) {
            i = 4;
            while(i--) {
                DelayUs(uS_CNT);    //Adjust for error
            }
        }
    /*
    0878         nop
    087A loc_MEM_87A:
    087A         movwf     fsr0l,    ACCESS
    087C loc_MEM_87C:
    087C         decf     fsr0l,    f, ACCESS
    087E         incf     fsr0l,    w, ACCESS
    0880         btfsc     STATUS, 2, ACCESS
    0882         bra     loc_MEM_8A0
    0884         movlw     4
    0886         movwf     fsr1l,    ACCESS
    0888 loc_MEM_888:
    0888         decf     fsr1l,    f, ACCESS
    088A         incf     fsr1l,    w, ACCESS
    088C         btfsc     STATUS, 2, ACCESS
    088E         bra     loc_MEM_87C
    0890         movlw     0F6
    0892         movwf     fsr2l,    ACCESS
    0894         bra     loc_MEM_89A
    0896 loc_MEM_896:
    0896         nop
    0898         nop
    089A loc_MEM_89A:
    089A         decfsz     fsr2l,    f, ACCESS
    089C         bra     loc_MEM_896
    089E         bra     loc_MEM_888
    08A0 loc_MEM_8A0:
    08A0         return     0
    08A2         nop
    08A4         bra     loc_MEM_87A
    */
    }

    Comment


    • #3
      C conversion at 10% completed.
      Here is converted code and all assembly listing together.
      Attached Files

      Comment


      • #4
        enjoy. there are files in asm. good luck, Mustafa!
        Attached Files

        Comment


        • #5
          Hi kt315,
          Thank you very much for the files but these are very old.
          CPI_PRG_131.zip is version 1.31 asm file.

          Here is a more recent one, version 1.6 asm file from www.fandy.front.ru/CPI_PRG_16.zip
          Version 1.7 and above is written in Hi-tech C.
          Unless you have one of the C source files, asm files have no use for me.
          Regards,
          Mustafa
          Attached Files

          Comment


          • #6
            interrupt function converted except variable names.
            Code:
            near BYTE ADCResH;
            near BYTE ADCResL;
            INT_16 d3C3D;
            INT_32 d494A4B4C;
            INT_32 d4D4E4F50;
            BYTE d5F0;
            BYTE d5F1;
            
            void interrupt HI_ISR(void) {
                INT_16 d3839;
                BYTE CntInt;
            
                RC0 = 0;
                RA5 = 0;
                for(CntInt = OnInterval | 1; --CntInt; )
                    continue;
                RA5 = 1;
                for(CntInt = GuardInterval | 1; --CntInt; )
                    continue;
                RC0 = 1;
                for(CntInt = 3; --CntInt; )
                    continue;
            
                RC3 = 1;
                RC2 = 0;
                for(CntInt = 21 | 1; --CntInt; )
                    continue;
                RC2 = 1;
                ADC_CS = 0;
                CREN = 1;
                while(OERR == 0)
                    continue;
                ADC_CS = 1;
                CREN = 0;
                RC3 = 0;
            
                ADCResH = RCREG;
                ADCResL = RCREG;
                reverse8bit(ADCResH);
                reverse8bit(ADCResL);
                asm("rrcf _ADCResH,f");
                asm("rrcf _ADCResL,f");
                ADCResH &= 0x0F;
                d3839 = (ADCResH << 8) | ADCResL;
                d4D4E4F50 += (((INT_32)d3839 << 16) - d4D4E4F50) >> d5F1;
                if(d5ED != 2)
                    d494A4B4C += (((INT_32)d3839 << 16) - d494A4B4C) << d5F0;
                d3C3D = HighWord(d494A4B4C) - HighWord(d4D4E4F50);
                PIR1 = 0;
                PIR2 = 0;
            }
            
            #define HighWord(Value)    ((INT_16)(Value & 0xFFFF))
            
            #define    reverse8bit(p)    { \
                asm("swapf _"#p",w"); \
                asm("xorwf _"#p",w"); \
                asm("andlw 66"); \
                asm("xorwf _"#p",f"); \
                asm("rrcf _"#p",w"); \
                asm("rrcf _"#p",f"); \
                asm("andlw 55"); \
                asm("addwf _"#p",f"); \
                asm("rrcf _"#p",f"); \
                asm("addwf _"#p",f"); \
                asm("rlncf _"#p",f"); \
            }

            Comment


            • #7
              half complete clone181.c
              Code:
              #include    <hitech.h>
              #include    <pic18.h>
              #include    <stdio.h>
              
              //00300000            byte 0FF, 0FA, 0FC, 0FE, 0FF, 0FF, 0FA,    0FF
              
              //-----------------------------------
              #define    ADC_CS        RA3
              #define    LCD_RS        RC4
              #define LCD_EN        RC5
              #define LCD_DATA    PORTB
              
              //------ LCD Module commands --------
              #define    DISP_ON        0x0C
              #define    CLR_DISP    0x01
              #define    ENTRY_INC    0x06
              
              #define    LINE1    0x80
              #define    LINE2    0xC0
              //-----------------------------------
              
              
              near BYTE ADCResH;    //0F
              near BYTE ADCResL;    //10
              bit d12_0;            //12
              
              BYTE d109;            //109
              
              INT_16 d3A3B;        //3A3B
              INT_16 d3C3D;        //3C3D
              INT_16 d3E3F;        //3E3F
              
              INT_16 d4243;        //4243
              
              double Upow;        //464748;
              INT_32 d494A4B4C;    //494A4B4C
              INT_32 d4D4E4F50;    //4D4E4F50
              
              
              BYTE OnInterval = 100;        //5EA
              BYTE GuardInterval = 17;    //5EB
              BYTE PowPersents = 105;        //5EC
              BYTE d5ED = 0;                //5ED
              BYTE d5EE = 0;                //5EE
              BYTE d5EF = 3;                //5EF
              
              BYTE d5F0;        //5F0
              BYTE d5F1;        //5F1
              BYTE Barrier;    //5F2
              BYTE Volume;    //5F3
              
              
              
              BYTE CalcOnInterval(void);
              void DelayMs(BYTE cnt);
              void EepromWait(void);
              BYTE f22C4(void);
              void InitADC(void);
              void InitCCP1(void);
              void InitCCP2(void);
              void InitLCD(void);
              void InitUSART(void);
              void NybbleOut(BYTE c);
              void SendCHAR(BYTE c);
              void SendINS(BYTE c);
              void shutdown(void);
              void SOUND_F(BYTE temp);
              UINT_16 VMesure(void);
              
              #define    LCD_STROBE()    ((LCD_EN = 1),(LCD_EN=0))
              
              #define HighWord(Value)    ((INT_16)(Value & 0xFFFF))
              
              #define    DelayUs(x)    { unsigned char _dcnt; \
                            _dcnt=(x*(10/4)/2); \
                            while(--_dcnt > 0) \
                              {\
                              asm("nop");\
                              asm("nop");\
                              continue; }\
                      } 
              
              #define    reverse8bit(p)    { \
                  asm("swapf _"#p",w"); \
                  asm("xorwf _"#p",w"); \
                  asm("andlw 66"); \
                  asm("xorwf _"#p",f"); \
                  asm("rrcf _"#p",w"); \
                  asm("rrcf _"#p",f"); \
                  asm("andlw 55"); \
                  asm("addwf _"#p",f"); \
                  asm("rrcf _"#p",f"); \
                  asm("addwf _"#p",f"); \
                  asm("rlncf _"#p",f"); \
              }
              
              void NybbleOut(BYTE c) {
                  LCD_DATA = (c & 0x0F) | (LCD_DATA & 0xF0);
                  LCD_STROBE();
                  DelayUs(150);
              }
              
              void SendINS(BYTE c) {
                  LCD_RS = 0;
                  NybbleOut(c >> 4); 
                  NybbleOut(c); 
              }
              
              void SendCHAR(BYTE c) {
                  LCD_RS = 1;
                  NybbleOut(c >> 4); 
                  NybbleOut(c); 
              }
              
              void InitLCD(void) {
                  DelayMs(20);
                  LCD_RS=0;
                  NybbleOut(3);    //Reset Command
                  DelayMs(3);
                  NybbleOut(3);
                  DelayMs(3);
                  NybbleOut(3);
                  DelayMs(3);
                  NybbleOut(2);    //Set 4 Bit Mode
                  DelayUs(150);
                  SendINS(0x28);        //4 bit, 2 Line, 5x7 font
                  SendINS(0x10);        //display shift off
                  SendINS(CLR_DISP);    //Clear the Display RAM
                  DelayMs(3);            //Note, Can take up to 4.1 msecs
                  SendINS(ENTRY_INC);    //increment cursor
                  SendINS(DISP_ON);    //display on cursor off
                  SendINS(0x48);
                  SendCHAR(0x00); SendCHAR(0x00); SendCHAR(0x1F); SendCHAR(0x1F);    SendCHAR(0x1F); SendCHAR(0x1F); SendCHAR(0x00); SendCHAR(0x00);
                  SendCHAR(0x00); SendCHAR(0x01); SendCHAR(0x01); SendCHAR(0x01);    SendCHAR(0x01); SendCHAR(0x01); SendCHAR(0x01); SendCHAR(0x00);
                  SendCHAR(0x00); SendCHAR(0x01); SendCHAR(0x1F); SendCHAR(0x1F);    SendCHAR(0x1F); SendCHAR(0x1F); SendCHAR(0x01); SendCHAR(0x00);
                  SendCHAR(0x10); SendCHAR(0x18); SendCHAR(0x1C); SendCHAR(0x1E); SendCHAR(0x1C); SendCHAR(0x18); SendCHAR(0x10); SendCHAR(0x00);
                  SendCHAR(0x01); SendCHAR(0x03); SendCHAR(0x07); SendCHAR(0x0F); SendCHAR(0x07); SendCHAR(0x03); SendCHAR(0x01); SendCHAR(0x00);
                  SendINS(LINE1);
              }
              
              void putch(BYTE c) {
                  SendCHAR(c);
              }
              
              void DelayMs(BYTE cnt) {
                  BYTE i;
                  #define uS_CNT  246
                  
                  while(cnt--) {
                      i = 4;
                      while(i--) {
                          DelayUs(uS_CNT);    //Adjust for error
                      }
                  }
              }
              
              void interrupt HI_ISR(void) {
                  INT_16 d3839;    //3839
                  BYTE CntInt;
              
                  RC0 = 0;
                  RA5 = 0;
                  for(CntInt = OnInterval | 1; --CntInt; )
                      continue;
                  RA5 = 1;
                  for(CntInt = GuardInterval | 1; --CntInt; )
                      continue;
                  RC0 = 1;
                  for(CntInt = 3; --CntInt; )
                      continue;
              
                  RC3 = 1;
                  RC2 = 0;
                  for(CntInt = 21 | 1; --CntInt; )
                      continue;
                  RC2 = 1;
                  ADC_CS = 0;
                  CREN = 1;
                  while(OERR == 0)
                      continue;
                  ADC_CS = 1;
                  CREN = 0;
                  RC3 = 0;
              
                  ADCResH = RCREG;
                  ADCResL = RCREG;
                  reverse8bit(ADCResH);
                  reverse8bit(ADCResL);
                  asm("rrcf _ADCResH,f");
                  asm("rrcf _ADCResL,f");
                  ADCResH &= 0x0F;
                  d3839 = (ADCResH << 8) | ADCResL;
                  d4D4E4F50 += (((INT_32)d3839 << 16) - d4D4E4F50) >> d5F1;
                  if(d5ED != 2)
                      d494A4B4C += (((INT_32)d3839 << 16) - d494A4B4C) >> d5F0;
                  d3C3D = HighWord(d494A4B4C) - HighWord(d4D4E4F50);
                  PIR1 = 0;
                  PIR2 = 0;
              }
              
              void main(void) {
                  IPEN = 0;
                  INTCON = 0;
                  INTCON3 = 0;
                  PIE1 = 0;
                  PIE2 = 0;
                  PIR1 = 0;
                  PIR2 = 0;
                  ADCON1 = 7;
                  PORTA = 0b00101000;
                  PORTB = 0b00000000;
                  PORTC = 0b00000100;
                  TRISA = 0b11010011;
                  TRISB = 0b11110000;
                  TRISC = 0b11000000;
                  RBPU = 0;
                  InitLCD();
                  printf("    Clone PI    ");
                  SendINS(LINE2);
                  printf("  ver. 1.8.1a   ");
                  EepromWait();
                  Volume = EEPROM_READ(0);
                  if(Volume >= 8)
                      Volume = 5;
                  EepromWait();
                  Barrier = EEPROM_READ(1);
                  if( (Barrier > 16) || (Barrier < 1) )
                      Barrier = 4;
                  EepromWait();
                  PowPersents = EEPROM_READ(2);
                  if( (PowPersents > 120) || (PowPersents < 60) )
                      PowPersents = 105;
                  EepromWait();
                  d5EE = EEPROM_READ(4);
                  if(d5EE > 25)
                      d5EE = 0;
                  EepromWait();
                  GuardInterval = EEPROM_READ(5);
                  EepromWait();
                  d5ED = EEPROM_READ(6);
                  if(d5ED > 2)
                      d5ED = 0;
                  EepromWait();
                  d5EF = EEPROM_READ(7);
                  if(d5EF > 5)
                      d5EF = 3;
                  d5F1 = 4;
                  d5F0 = 9;
                  d3A3B = 20000;
                  InitADC();
                  InitUSART();
                  InitCCP2();
                  InitCCP1();
                  DelayMs(250); DelayMs(250);
                  Upow = VMesure() / 40.0;
                  OnInterval = CalcOnInterval();
                  SendINS(CLR_DISP);    DelayMs(4);
                  if(d5EE || (GuardInterval > 40) || (GuardInterval < 2) ) {
                      printf("     Tune...    ");
                      GuardInterval = f22C4();
                      if(GuardInterval < 2) {
                          SendINS(CLR_DISP); DelayMs(4);
                          SendINS(LINE1);
                          printf("Coil not connect");
                          SendINS(LINE2);
                          printf("or metal present");
                          DelayMs(0xFF);
                          PEIE = 0;
                          GIE = 0;
                          SLEEP();
                      } else {
                          EepromWait();
                      }
                      EEPROM_WRITE(5, GuardInterval);
                  }
                  SendINS(LINE1);
                  printf(" Guard Interval");
                  SendINS(LINE2);
                  printf("%2d", GuardInterval);
                  DelayMs(200);
                  d494A4B4C = d4D4E4F50;
                  DelayMs(100);
                  d109 = 50;    SOUND_F(155);    DelayMs(45);
                  d109 = 50;    SOUND_F(100);    DelayMs(45);
                  d109 = 50;    SOUND_F(70);    DelayMs(150);
                  SendINS(CLR_DISP); DelayMs(5);
              
                  while(1) {
                      di(); d3E3F = d3C3D; ei();
                      if(d5ED) {
                          if(d12_0)
                              d5F0 = (d3E3F < Barrier) ? 14 : 9;
                           else
                              d5F0 = (d3E3F < Barrier) ? 13 : 8;
                      } else {
                          if(d12_0)
                              d5F0 = 10;
                          else
                              d5F0 = 9;
                      }
                      d4243 += (d3E3F - d4243) >> 5;
                      if(d3E3F < 0)
                          d3E3F = 0;
                      if(d4243 < d3E3F)
                          d4243 = d3E3F;
              .
              .
              .
              .
              .
              .
              .
              
                  }
                  shutdown();
              }
              
              void InitUSART(void) {
                  BRGH = 0;    //low baud rate
                  SPBRG = 1;    //DevFreq/(4*ADCFreq)    ; Baud Rate
                  SYNC = 1;    // synchronous
                  CSRC = 1;    //1 = Master mode (clock generated internally from BRG)
                  SPEN = 1;    //1 = Serial port enabled (configures RC7/RX/DT and RC6/TX/CK pins as serial port pins)
                  SREN = 0;    //0 = Disables single receive
                  CREN = 0;    //0 = Disables continuous receive
                  RX9 = 0;    //9th bit of Received Data
              }
              
              void InitCCP1(void) {
                  TMR1H = 0;
                  TMR1L = 0;
                  T1CON = 0b00110000;
                  CCPR1H = 0x06;
                  CCPR1L = 0x1A;
                  CCP1CON = 0b00001011;
                  PIE1 = 0;
                  PIE2 = 0;
                  CCP1IE = 1;
                  PEIE = 1;
                  GIE = 1;
                  TMR1ON = 1;
              }
              
              void InitCCP2(void) {
                  TMR2 = 0;
                  T2CKPS1 = 1;
                  PR2 = 0xFF;
                  CCPR2L = 0x1F;
                  CCP2CON = 0x0C;
              }
              
              void InitADC(void) {
                 ADCON1 = 0x0E;
                 ADCON0 = 0x81;
              }
              
              UINT_16 VMesure(void) {
                  GODONE = 1;
                  while(GODONE)
                      continue;
                  return ADRES;
              }
              
              BYTE CalcOnInterval(void) {
                 return(1200 / Upow);
              }
              
              void SOUND_F(BYTE temp) {
                  PR2 = temp;
                  temp <<= Volume;
                  CCP1CON = (CCP1CON & 0xCF) | ( (temp & 0xC0) >> 2 );
                  CCPR2L = temp >> 8;
                  TMR2ON = 1;
                  DelayMs(d109);
                  TMR2ON = 0;
                  CCP2CON = 0;
                  CCP2CON = 0x0C;
              }
              
              void shutdown(void) {
                  FAST i;
              
                  PEIE = 0;
                  GIE = 0;
                  SendINS(CLR_DISP);
                  DelayMs(5);
                  SendINS(LINE1+2);
                  printf("Battery low,");
                  SendINS(LINE2+4);
                  printf("shutdown");
                  i = 3;
                  while(i != 0) {
                      d109 = 70;    SOUND_F(70);    DelayMs(50);
                      d109 = 70;    SOUND_F(186);    DelayMs(50);
                      d109 = 70;    SOUND_F(255);    DelayMs(255);
                      i--;
                  }
                  SLEEP();
              }
              
              void EepromWait(void) {
                  while(WR) continue;
              }

              Comment


              • #8
                80% complete clone181.c
                Code:
                #include    <hitech.h>
                #include    <pic18.h>
                #include    <stdio.h>
                
                __CONFIG(1,HS);
                __CONFIG(2, BORDIS & PWRTEN & WDTDIS);
                __CONFIG(4, DEBUGDIS & LVPDIS & STVRDIS);
                
                //-----------------------------------
                #define    ADC_CS        RA3
                #define    LCD_RS        RC4
                #define LCD_EN        RC5
                #define LCD_DATA    PORTB
                
                //------ LCD Module commands --------
                #define    DISP_ON        0x0C
                #define    CLR_DISP    0x01
                #define    ENTRY_INC    0x06
                
                #define    LINE1    0x80
                #define    LINE2    0xC0
                //-----------------------------------
                
                
                near BYTE ADCResH;
                near BYTE ADCResL;
                bit d12_0;
                bit d12_1;
                bit d12_2;
                bit d12_3;
                bit d12_4;
                
                INT_16 d102103;
                
                BYTE d109;
                
                near BYTE d10B;
                
                INT_16 d3A3B;
                INT_16 d3C3D;
                INT_16 d3E3F;
                
                struct menu* d4041;
                INT_16 d4243;
                UINT_16 d4445;
                double Upow;
                INT_32 d494A4B4C;
                INT_32 d4D4E4F50;
                
                
                BYTE OnInterval = 100;
                BYTE GuardInterval = 17;
                BYTE PowPersents = 105;
                BYTE d5ED = 0;
                BYTE d5EE = 0;
                BYTE d5EF = 3;
                
                BYTE d5F0;
                BYTE d5F1;
                BYTE Barrier;
                BYTE Volume;
                
                struct menu {
                    BYTE text[16+1];
                    struct menu* b1112;
                    struct menu* b1314;
                    struct menu* b1516;
                    struct menu* b1718;
                };
                
                struct menu tm[] = {
                    {"Volume         ",   0,   0,    0, tm+1},
                    {"Power          ",   0,   0, tm+0, tm+2},
                    {"Light          ",   0,   0, tm+1, tm+3},
                    {"U min of batt  ",   0,   0, tm+2, tm+4},
                    {"Guard interval ",   0,   0, tm+3, tm+5},
                    {"Ground adjust  ",   0,   0, tm+4, tm+6},
                    {"Volume raise   ",   0,   0, tm+5,    0}};
                
                BYTE CalcOnInterval(void);
                void DelayMs(BYTE cnt);
                void EepromWait(void);
                void f16A2(struct menu* d10910A);
                BYTE f22C4(void);
                void InitADC(void);
                void InitCCP1(void);
                void InitCCP2(void);
                void InitLCD(void);
                void InitUSART(void);
                void NybbleOut(BYTE c);
                void SendCHAR(BYTE c);
                void SendINS(BYTE c);
                void shutdown(void);
                void SOUND_F(BYTE temp);
                UINT_16 VMesure(void);
                
                #define    LCD_STROBE()    ((LCD_EN = 1),(LCD_EN=0))
                #define Low(Value)    ((BYTE)(Value >> 8))
                #define High(Value)    ((BYTE)(Value & 0xFF))
                #define HighWord(Value)    ((INT_16)(Value & 0xFFFF))
                #define    DelayUs(x)    { unsigned char _dcnt; \
                              _dcnt=(x*(10/4)/2); \
                              while(--_dcnt > 0) \
                                {\
                                asm("nop");\
                                asm("nop");\
                                continue; }\
                        } 
                
                #define    reverse8bit(p)    { \
                    asm("swapf _"#p",w"); \
                    asm("xorwf _"#p",w"); \
                    asm("andlw 66"); \
                    asm("xorwf _"#p",f"); \
                    asm("rrcf _"#p",w"); \
                    asm("rrcf _"#p",f"); \
                    asm("andlw 55"); \
                    asm("addwf _"#p",f"); \
                    asm("rrcf _"#p",f"); \
                    asm("addwf _"#p",f"); \
                    asm("rlncf _"#p",f"); \
                }
                
                void NybbleOut(BYTE c) {
                    LCD_DATA = (c & 0x0F) | (LCD_DATA & 0xF0);
                    LCD_STROBE();
                    DelayUs(150);
                }
                
                void SendINS(BYTE c) {
                    LCD_RS = 0;
                    NybbleOut(c >> 4); 
                    NybbleOut(c); 
                }
                
                void SendCHAR(BYTE c) {
                    LCD_RS = 1;
                    NybbleOut(c >> 4); 
                    NybbleOut(c); 
                }
                
                void InitLCD(void) {
                    DelayMs(20);
                    LCD_RS=0;
                    NybbleOut(3);    //Reset Command
                    DelayMs(3);
                    NybbleOut(3);
                    DelayMs(3);
                    NybbleOut(3);
                    DelayMs(3);
                    NybbleOut(2);    //Set 4 Bit Mode
                    DelayUs(150);
                    SendINS(0x28);        //4 bit, 2 Line, 5x7 font
                    SendINS(0x10);        //display shift off
                    SendINS(CLR_DISP);    //Clear the Display RAM
                    DelayMs(3);            //Note, Can take up to 4.1 msecs
                    SendINS(ENTRY_INC);    //increment cursor
                    SendINS(DISP_ON);    //display on cursor off
                    SendINS(0x48);
                    SendCHAR(0x00); SendCHAR(0x00); SendCHAR(0x1F); SendCHAR(0x1F);    SendCHAR(0x1F); SendCHAR(0x1F); SendCHAR(0x00); SendCHAR(0x00);
                    SendCHAR(0x00); SendCHAR(0x01); SendCHAR(0x01); SendCHAR(0x01);    SendCHAR(0x01); SendCHAR(0x01); SendCHAR(0x01); SendCHAR(0x00);
                    SendCHAR(0x00); SendCHAR(0x01); SendCHAR(0x1F); SendCHAR(0x1F);    SendCHAR(0x1F); SendCHAR(0x1F); SendCHAR(0x01); SendCHAR(0x00);
                    SendCHAR(0x10); SendCHAR(0x18); SendCHAR(0x1C); SendCHAR(0x1E); SendCHAR(0x1C); SendCHAR(0x18); SendCHAR(0x10); SendCHAR(0x00);
                    SendCHAR(0x01); SendCHAR(0x03); SendCHAR(0x07); SendCHAR(0x0F); SendCHAR(0x07); SendCHAR(0x03); SendCHAR(0x01); SendCHAR(0x00);
                    SendINS(LINE1);
                }
                
                void putch(BYTE c) {
                    SendCHAR(c);
                }
                
                void DelayMs(BYTE cnt) {
                    BYTE i;
                    #define uS_CNT  246
                    
                    while(cnt--) {
                        i = 4;
                        while(i--) {
                            DelayUs(uS_CNT);    //Adjust for error
                        }
                    }
                }
                
                void interrupt HI_ISR(void) {
                    INT_16 d3839;
                    BYTE CntInt;
                
                    RC0 = 0;
                    RA5 = 0;
                    for(CntInt = OnInterval | 1; --CntInt; )
                        continue;
                    RA5 = 1;
                    for(CntInt = GuardInterval | 1; --CntInt; )
                        continue;
                    RC0 = 1;
                    for(CntInt = 3; --CntInt; )
                        continue;
                
                    RC3 = 1;
                    RC2 = 0;
                    for(CntInt = 21 | 1; --CntInt; )
                        continue;
                    RC2 = 1;
                    ADC_CS = 0;
                    CREN = 1;
                    while(OERR == 0)
                        continue;
                    ADC_CS = 1;
                    CREN = 0;
                    RC3 = 0;
                
                    ADCResH = RCREG;
                    ADCResL = RCREG;
                    reverse8bit(ADCResH);
                    reverse8bit(ADCResL);
                    asm("rrcf _ADCResH,f");
                    asm("rrcf _ADCResL,f");
                    ADCResH &= 0x0F;
                    d3839 = (ADCResH << 8) | ADCResL;
                    d4D4E4F50 += (((INT_32)d3839 << 16) - d4D4E4F50) >> d5F1;
                    if(d5ED != 2)
                        d494A4B4C += (((INT_32)d3839 << 16) - d494A4B4C) >> d5F0;
                    d3C3D = HighWord(d494A4B4C) - HighWord(d4D4E4F50);
                    PIR1 = 0;
                    PIR2 = 0;
                }
                
                void main(void) {
                    IPEN = 0;
                    INTCON = 0;
                    INTCON3 = 0;
                    PIE1 = 0;
                    PIE2 = 0;
                    PIR1 = 0;
                    PIR2 = 0;
                    ADCON1 = 7;
                    PORTA = 0b00101000;
                    PORTB = 0b00000000;
                    PORTC = 0b00000100;
                    TRISA = 0b11010011;
                    TRISB = 0b11110000;
                    TRISC = 0b11000000;
                    RBPU = 0;
                    InitLCD();
                    printf("    Clone PI    ");
                    SendINS(LINE2);
                    printf("  ver. 1.8.1a   ");
                    EepromWait();
                    Volume = EEPROM_READ(0);
                    if(Volume >= 8)
                        Volume = 5;
                    EepromWait();
                    Barrier = EEPROM_READ(1);
                    if( (Barrier > 16) || (Barrier < 1) )
                        Barrier = 4;
                    EepromWait();
                    PowPersents = EEPROM_READ(2);
                    if( (PowPersents > 120) || (PowPersents < 60) )
                        PowPersents = 105;
                    EepromWait();
                    d5EE = EEPROM_READ(4);
                    if(d5EE > 25)
                        d5EE = 0;
                    EepromWait();
                    GuardInterval = EEPROM_READ(5);
                    EepromWait();
                    d5ED = EEPROM_READ(6);
                    if(d5ED > 2)
                        d5ED = 0;
                    EepromWait();
                    d5EF = EEPROM_READ(7);
                    if(d5EF > 5)
                        d5EF = 3;
                    d5F1 = 4;
                    d5F0 = 9;
                    d3A3B = 20000;
                    InitADC();
                    InitUSART();
                    InitCCP2();
                    InitCCP1();
                    DelayMs(250); DelayMs(250);
                    Upow = VMesure() / 40.0;
                    OnInterval = CalcOnInterval();
                    SendINS(CLR_DISP);    DelayMs(4);
                    if(d5EE || (GuardInterval > 40) || (GuardInterval < 2) ) {
                        printf("     Tune...    ");
                        GuardInterval = f22C4();
                        if(GuardInterval < 2) {
                            SendINS(CLR_DISP); DelayMs(4);
                            SendINS(LINE1);
                            printf("Coil not connect");
                            SendINS(LINE2);
                            printf("or metal present");
                            DelayMs(255);
                            PEIE = 0;
                            GIE = 0;
                            SLEEP();
                        } else {
                            EepromWait();
                        }
                        EEPROM_WRITE(5, GuardInterval);
                    }
                    SendINS(LINE1);
                    printf(" Guard Interval");
                    SendINS(LINE2);
                    printf("%2d", GuardInterval);
                    DelayMs(200);
                    d494A4B4C = d4D4E4F50;
                    DelayMs(100);
                    d109 = 50;    SOUND_F(155);    DelayMs(45);
                    d109 = 50;    SOUND_F(100);    DelayMs(45);
                    d109 = 50;    SOUND_F(70);    DelayMs(150);
                    SendINS(CLR_DISP); DelayMs(5);
                    while(1) {
                        di(); d3E3F = d3C3D; ei();
                        if(d5ED) {
                            if(d12_0)
                                d5F0 = (d3E3F < Barrier) ? 14 : 9;
                             else
                                d5F0 = (d3E3F < Barrier) ? 13 : 8;
                        } else {
                            if(d12_0)
                                d5F0 = 10;
                            else
                                d5F0 = 9;
                        }
                        d4243 += (d3E3F - d4243) >> 5;
                        if(d3E3F < 0)
                            d3E3F = 0;
                        if(d4243 < d3E3F)
                            d4243 = d3E3F;
                        if( (d3E3F < Barrier) || (d4041 != 0) ) {
                            TMR2ON = 0;
                            CCP2CON = 0;
                            CCP2CON = 0x0C;
                        } else {
                            if(Volume < 3)
                                PR2 = 0xFF;
                            else if(d3E3F > 0x00FF)
                                PR2 = 0x2F - (d3E3F >> 8);
                            else if(d3E3F < 0x0040)
                                PR2 = 0xFF - 2 * (d3E3F & 0xFF);
                            else if(d3E3F < 0x0080)
                                PR2 = 0xBF - (d3E3F & 0xFF);
                            else
                                PR2 = 0x40 - (d3E3F >> 3);
                            {
                                UINT_16 temp;
                                temp = PR2;
                                temp <<= Volume;
                                if(d5EF && (d3E3F < 64)) {
                                    d102103 = (PR2 * (64 - d3E3F)) >> (d5EF + 6 - Volume);
                                    if(d5EF > 1)
                                        d102103 *= (2 << (d5EF - 1) ) - 1;
                                    temp -= d102103;
                                    if(temp < 0x40)
                                        temp = 0x40;
                                    CCP1CON = (CCP1CON & 0xCF) | ( (temp & 0xC0) >> 2 );
                                    CCPR2L = temp >> 8;
                                    TMR2ON = 1;
                                }
                            }
                        }
                
                        f16A2(d4041);
                        if(~PORTB & 0xF0) {
                            d109 = 30;    SOUND_F(100);
                            if(RB7 == 0) {
                                if(d4041 == 0) {
                                    d12_1 = 0;
                                    d4041 = tm;
                                } else if(d12_3) {
                                    d12_3 = 0;
                                } else {
                                    d4041 = d4041->b1112;
                                }
                            } else if(RB6 == 0) {
                                if(d4041 == 0) {
                                    if(Barrier > 1) {
                                        Barrier--;
                                        EepromWait();
                                        EEPROM_WRITE(1, Barrier);
                                    }
                                } else {
                                    if(d12_3) {
                                        switch(d4041 - tm) {
                                            case 0:
                                            case 4:
                                            case 5:
                                            case 6:
                                                if(d4445)
                                                    d4445--;
                                                break;
                                            case 1:
                                            case 2:
                                                d12_4 = !d12_4;
                                                break;
                                            case 3:    
                                                if(d4445 >= 0x3D)
                                                    d4445--;
                                                break;
                                        }
                                    } else {
                                        if(d4041->b1516) {
                                            d4041 = d4041->b1516;
                                            d12_1 = 0;
                                        }
                                    }
                                }
                            } else if(RB5 == 0) {
                                if(d4041 == 0) {
                                    if(Barrier < 16) {
                                        Barrier++;
                                        EepromWait();
                                        EEPROM_WRITE(1, Barrier);
                                    }
                                } else {
                                    if(d12_3) {
                                        switch(d4041 - tm) {
                                            case 0:
                                                if(d4445 < 7)
                                                    d4445++;
                                                break;
                                            case 1:
                                            case 2:
                                                d12_4 = !d12_4;
                                                break;
                                            case 3:
                                                if(d4445 < 120)
                                                    d4445++;
                                                break;
                                            case 4:
                                                if(d4445 < 25)
                                                    d4445++;
                                                break;
                                            case 5:
                                                if(d4445 < 2)
                                                    d4445++;
                                                break;
                                            case 6:
                                                if(d4445 < 5)
                                                    d4445++;
                                                break;
                                        }
                                    } else {
                                        if(d4041->b1718) {
                                            d4041 = d4041->b1718;
                                            d12_1 = 1;
                                        }
                                    }
                                }
                            } else if(RB4 == 0) {
                                if(d4041 == 0) {
                                    d494A4B4C = d4D4E4F50;
                                } else {
                                    if(d12_3) {
                                        switch(d4041 - tm) {
                                            case 0:
                                                Volume = Low(d4445);
                                                EepromWait();
                                                EEPROM_WRITE(0, Low(d4445));
                                                break;
                                            case 1:
                                                d12_0 = d12_4;
                                                EepromWait();
                                                EEPROM_WRITE(3, d12_4 ? 1 : 0);
                                                if(d12_0) {
                                                    d5F1 = 0x05;
                                                    d5F0 = 0x0A;
                                                    CCPR1H = 0x03;
                                                    CCPR1L = 0x0D;
                                                } else {
                                                    d5F1 = 0x04;
                                                    d5F0 = 0x09;
                                                    CCPR1H = 0x06;
                                                    CCPR1L = 0x1A;
                                                }
                                                break;
                                            case 2:
                                                d12_2 = d12_4;
                                                if(d12_2)
                                                    RA2 = 1;
                                                else
                                                    RA2 = 0;
                                                break;
                                            case 3:
                                                PowPersents = Low(d4445);
                                                EepromWait();
                                                EEPROM_WRITE(2, Low(d4445));
                                                break;
                                            case 4:
                                                d5EE = Low(d4445);
                                                EepromWait();
                                                EEPROM_WRITE(4, Low(d4445));
                                                if(d5EE > 1) {
                                                    GuardInterval = d5EE;
                                                    DelayMs(50);
                                                    EepromWait();
                                                    EEPROM_WRITE(5, GuardInterval);
                                                }
                                                break;
                                            case 5:
                                                d5ED = Low(d4445);
                                                EepromWait();
                                                EEPROM_WRITE(6, Low(d4445));
                                                break;
                                            case 6:
                                                d5EF = Low(d4445);
                                                EepromWait();
                                                EEPROM_WRITE(7, Low(d4445));
                                                break;
                                        }
                                    } else {
                                        if(d4041->b1314) {
                                            d4041 = d4041->b1314;
                                            d12_1 = 0;
                                        } else {
                                            d12_3 = 1;
                                            switch(d4041 - tm) {
                                                case 0:
                                                    d4445 = Volume;
                                                    break;
                                                case 1:
                                                    d12_4 = d12_0;
                                                    break;
                                                case 2:
                                                    d12_4 = d12_2;
                                                    break;
                                                case 3:
                                                    d4445 = PowPersents;
                                                    break;
                                                case 4:
                                                    d4445 = d5EE;
                                                    break;
                                                case 5:
                                                    d4445 = d5ED;
                                                    break;
                                                case 6:
                                                    d4445 = d5EF;
                                                    break;
                                            }
                                        }
                                    }
                                }
                            }
                
                            if( (d4041 != 0) && (RB4 == 0) ) {
                                SendINS(LINE1);
                                printf("      ZERO      ");
                                SendINS(LINE2);
                                printf("                ");
                            } else {
                                if( (d4041 != 0) && ( (RB6 == 0) || (RB5 == 0) ) ) {
                                    SendINS(LINE1);
                                    printf("    Barrier     ");
                                    SendINS(LINE2);
                                    printf("       %d        ", Barrier);
                                }
                                f16A2(d4041);
                            }
                            while(~PORTB & 0xF0)
                                DelayMs(70);
                        }
                        Upow = VMesure() / 40.0;
                        if(Upow < (PowPersents / 10.0) )
                            break;
                        if(--d3A3B == 0) {
                            OnInterval = CalcOnInterval();
                            d3A3B = 20000;
                            DelayMs(250);
                            d494A4B4C = d4D4E4F50;
                        }
                    }
                    shutdown();
                }
                
                void f16A2(struct menu* d10910A) {
                    BYTE d10C[16+1];            //10C..11C
                
                
                    if(d10910A == 0) {
                        if(Barrier >= d3E3F) {
                            d10C[0] = (d4243 < (Barrier + 4) ) ? 0x02 : 0x20;
                        } else {
                            d10C[0] = (d4243 < (Barrier + 4) ) ? 0x03 : 0x01;
                        }
                        if( (d4243 >= (Barrier + 4) ) && (d4243 < (Barrier + 10) ) ) {
                            d10C[1] = (d3E3F < (Barrier + 4) ) ? 0x02 : 0x03;
                        } else {
                            d10C[1] = (d4243 < (Barrier + 4) ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= (Barrier + 10) ) && (d4243 < (Barrier + 20) ) ) {
                            d10C[2] = (d3E3F < (Barrier + 10) ) ? 0x02 : 0x03;
                        } else {
                            d10C[2] = (d4243 < (Barrier + 10) ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= (Barrier + 20) ) && (d4243 < 0x0024 ) ) {
                            d10C[3] = (d3E3F < (Barrier + 20) ) ? 0x02 : 0x03;
                        } else {
                            d10C[3] = (d4243 < (Barrier + 20) ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0024) && (d4243 < 0x0030 ) ) {
                            d10C[4] = (d3E3F < 0x0024 ) ? 0x02 : 0x03;
                        } else {
                            d10C[4] = (d4243 < 0x0024 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0030) && (d4243 < 0x0040 ) ) {
                            d10C[5] = (d3E3F < 0x0030 ) ? 0x02 : 0x03;
                        } else {
                            d10C[5] = (d4243 < 0x0030 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0040) && (d4243 < 0x0060 ) ) {
                            d10C[6] = (d3E3F < 0x0040 ) ? 0x02 : 0x03;
                        } else {
                            d10C[6] = (d4243 < 0x0040 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0060) && (d4243 < 0x0080 ) ) {
                            d10C[7] = (d3E3F < 0x0060 ) ? 0x02 : 0x03;
                        } else {
                            d10C[7] = (d4243 < 0x0060 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0080) && (d4243 < 0x00C0 ) ) {
                            d10C[8] = (d3E3F < 0x0080 ) ? 0x02 : 0x03;
                        } else {
                            d10C[8] = (d4243 < 0x0080 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x00C0) && (d4243 < 0x0100 ) ) {
                            d10C[9] = (d3E3F < 0x00C0 ) ? 0x02 : 0x03;
                        } else {
                            d10C[9] = (d4243 < 0x00C0 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0100) && (d4243 < 0x0155 ) ) {
                            d10C[10] = (d3E3F < 0x0100 ) ? 0x02 : 0x03;
                        } else {
                            d10C[10] = (d4243 < 0x0100 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0155) && (d4243 < 0x0220 ) ) {
                            d10C[11] = (d3E3F < 0x0155 ) ? 0x02 : 0x03;
                        } else {
                            d10C[11] = (d4243 < 0x0155 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0220) && (d4243 < 0x0300 ) ) {
                            d10C[12] = (d3E3F < 0x0220 ) ? 0x02 : 0x03;
                        } else {
                            d10C[12] = (d4243 < 0x0220 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0300) && (d4243 < 0x0400 ) ) {
                            d10C[13] = (d3E3F < 0x0300 ) ? 0x02 : 0x03;
                        } else {
                            d10C[13] = (d4243 < 0x0300 ) ? 0x20 : 0x01;
                        }
                        if( (d4243 >= 0x0400) && (d4243 < 0x0600 ) ) {
                            d10C[14] = (d3E3F < 0x0400 ) ? 0x02 : 0x03;
                        } else {
                            d10C[14] = (d4243 < 0x0400 ) ? 0x20 : 0x01;
                        }
                        if( (d3E3F >= 0x0600) && (d4243 < 0x0600 ) ) {
                            d10C[15] = (d4243 < 0x0600 ) ? 0x02 : 0x20;
                            d10C[15] = 3;
                        }
                        SendINS(LINE1);
                        printf("%s", d10C);
                        SendINS(LINE2);
                        printf("B%2d V%1d \004%c\005 %4.1fV", Barrier, Volume, (d12_0 ? '2' : '1'), Upow);
                        return;
                    }
                    if(d12_3) {
                        d10B = d10910A - tm;
                        SendINS(LINE1);
                        switch(d10B) {
                            case 0:
                                printf("     Volume     ");
                                break;
                            case 1:
                                printf("     Power      ");
                                break;
                            case 2:
                                printf("      Light     ");
                                break;
                            case 3:
                                printf(" U min of batt  ");
                                break;
                            case 4:
                                printf(" Guard interval ");
                                break;
                            case 5:
                                printf(" Ground adjust  ");
                                break;
                            case 6:
                                printf("  Volume raise  ");
                                break;
                        }
                        SendINS(LINE2);
                        switch(d10B) {
                            case 0:
                                printf("        %1d       ", d4445);
                                break;
                            case 1:
                                printf("       x%c       ", d12_4 ? '2' : '1');
                                break;
                            case 2:
                                printf("       %3s      ", d12_4 ? "on " : "off");
                                break;
                            case 3:
                                printf("     %4.1f V     ", d4445 / 10.0);
                                break;
                            case 4:
                                if(d4445 == 0)
                                    printf("      auto      ");
                                else if(d4445 == 1)
                                    printf("      last      ");
                                else
                                    printf("       %2d       ", d4445);
                                break;
                            case 5:
                                switch(d4445) {
                                    case 0:
                                        printf("    adaptive    ");
                                        break;
                                    case 1:
                                        printf("     fixing     ");
                                        break;
                                    case 2:
                                        printf("  off (static)  ");
                                        break;
                                }
                                break;
                            case 6:
                                switch(d4445) {
                                    case 0:
                                        printf("       1        ");
                                        break;
                                    case 1:
                                        printf("      1/2       ");
                                        break;
                                    case 2:
                                        printf("      1/4       ");
                                        break;
                                    case 3:
                                        printf("      1/8       ");
                                        break;
                                    case 4:
                                        printf("      1/16      ");
                                        break;
                                    case 5:
                                        printf("      1/32      ");
                                        break;
                                }
                                break;
                        }
                        return;
                    }
                
                    if(d12_1) {
                        SendINS(LINE1);
                        printf("%s%c", d10910A->b1516->text, ' '); //...
                    } else {
                        SendINS(LINE1);
                        //...
                    }
                }
                
                void InitUSART(void) {
                    BRGH = 0;    //low baud rate
                    SPBRG = 1;    //DevFreq/(4*ADCFreq)    ; Baud Rate
                    SYNC = 1;    // synchronous
                    CSRC = 1;    //1 = Master mode (clock generated internally from BRG)
                    SPEN = 1;    //1 = Serial port enabled (configures RC7/RX/DT and RC6/TX/CK pins as serial port pins)
                    SREN = 0;    //0 = Disables single receive
                    CREN = 0;    //0 = Disables continuous receive
                    RX9 = 0;    //9th bit of Received Data
                }
                
                void InitCCP1(void) {
                    TMR1H = 0;
                    TMR1L = 0;
                    T1CON = 0b00110000;
                    CCPR1H = 0x06;
                    CCPR1L = 0x1A;
                    CCP1CON = 0b00001011;
                    PIE1 = 0;
                    PIE2 = 0;
                    CCP1IE = 1;
                    PEIE = 1;
                    GIE = 1;
                    TMR1ON = 1;
                }
                
                void InitCCP2(void) {
                    TMR2 = 0;
                    T2CKPS1 = 1;
                    PR2 = 0xFF;
                    CCPR2L = 0x1F;
                    CCP2CON = 0x0C;
                }
                
                void InitADC(void) {
                   ADCON1 = 0x0E;
                   ADCON0 = 0x81;
                }
                
                UINT_16 VMesure(void) {
                    GODONE = 1;
                    while(GODONE)
                        continue;
                    return ADRES;
                }
                
                BYTE CalcOnInterval(void) {
                   return (BYTE)(1200 / Upow);
                }
                
                BYTE f22C4(void) {
                //...
                }
                
                void SOUND_F(BYTE temp) {
                    PR2 = temp;
                    temp <<= Volume;
                    CCP1CON = (CCP1CON & 0xCF) | ( (temp & 0xC0) >> 2 );
                    CCPR2L = temp >> 8;
                    TMR2ON = 1;
                    DelayMs(d109);
                    TMR2ON = 0;
                    CCP2CON = 0;
                    CCP2CON = 0x0C;
                }
                
                void shutdown(void) {
                    FAST i;
                
                    PEIE = 0;
                    GIE = 0;
                    SendINS(CLR_DISP);
                    DelayMs(5);
                    SendINS(LINE1+2);
                    printf("Battery low,");
                    SendINS(LINE2+4);
                    printf("shutdown");
                    i = 3;
                    while(i != 0) {
                        d109 = 70;    SOUND_F(70);    DelayMs(50);
                        d109 = 70;    SOUND_F(186);    DelayMs(50);
                        d109 = 70;    SOUND_F(255);    DelayMs(255);
                        i--;
                    }
                    SLEEP();
                }
                
                void EepromWait(void) {
                    while(WR) continue;
                }

                Comment


                • #9
                  Translation complete.
                  Attached Files

                  Comment


                  • #10
                    Congratulations!
                    Fred

                    Comment


                    • #11
                      C for amel

                      Good job Mustafa!
                      But I still have 2 questions:
                      1. Does this last version work compiled really exactly like the original and
                      (if it works so)
                      2. could you adapt it for the ATMega8 ? Please!

                      I would be extremely thankful!

                      Comment


                      • #12
                        Hi tresoro,
                        1. I have Hitech 8.30 and Hitech 9.50PL3 but original hex was compiled with different version of Hitech picc. Without having the same version of compiler I can not guarantee 100% equivalence.
                        2. Sorry, I don't have any experience on Atmel chips.

                        Comment


                        • #13
                          sit down

                          This is doing my head in. I mustafa sit down to think.

                          Comment


                          • #14
                            Originally posted by Mustafa View Post
                            Translation complete.
                            With interest has looked result. It is similar to the original. Thanks.

                            Comment


                            • #15
                              Hi Andy,
                              Welcome to the Geotech Forums. It is nice to see you here.
                              Thanks for your great work on Clone PI projects and sharing publicly.

                              Comment

                              Working...
                              X