LGT8F690A SDK 版本的 Signal Reverser

eddiewwm

嘗試在 LGT 的 SDKBuilder 下編寫 LGT8F690A版本的 Signal Reverser
以下是當中的main.c 程序：

1. //===================================================
   
2. // Auto generated file : 8/4/2019 17:51:37
   
3. //===================================================
   
4. 
   
5. #include "allinone.h"
   
6. 
   
7. //define from http://www.koch-engineering.com/fileadmin/code/delay.h.pdf
   
8. #define DelayUs(x) { unsigned int _dcnt; \
   
9. _dcnt = (x)/8|1; \
   
10. while(--_dcnt != 0) \
    
11. continue; }  //this define is not accuracy, need multiply factor 2.86
    
12. 
    
13. // Import external definitions
    
14. extern void init_modules(void);
    
15. 
    
16. char caTmp[8];
    
17. u16 periodTime =1500;
    
18. int temp=0;
    
19. unsigned int  u16tmp0 =0; //total count per cycle
    
20. unsigned int  u16tmp1 =0; //total count for High period
    
21. unsigned int  u16tmp =0; //total count to used as calibration factor
    
22. 
    
23. #define standardFactor1500 480
    
24. #define standardFactor750 330
    
25. unsigned int factor1500 = standardFactor1500;
    
26. unsigned int factor750 = standardFactor750;
    
27. 
    
28. 
    
29. int main(void)
    
30. {
    
31.         // Device initialization
    
32.         init_modules();
    
33.        
    
34.         TRISA4 =0x1;
    
35.         TRISB3 =0x0;
    
36.         ECP1_IF1=0x0;
    
37.         CCP1IE=0x1;
    
38.         T1CON = 0x01;                // TMR1ON
    
39. 
    
40.         eepWrite(0, 0x92); //used to set main clock compensation value
    
41.         //OSCTUNE = eepRead(0); //used to change the clock compensation value
    
42. 
    
43.         //for calibration Start
    
44.         //============================================
    
45.         gppPullupEnable(GPPB,P6); //need to enable global Pullup as well
    
46.         delayms(300);
    
47.         char calStatus = gppReadSingle(GPPB,P6);
    
48.         if (calStatus==0)
    
49.         {
    
50.                 char inCal = 1;
    
51.                 char calCount = 0;
    
52.                 while (inCal==1)
    
53.                 {
    
54.                         if (ECP1_IF1)
    
55.                         {
    
56.                                 CCP1IE=0;
    
57.                                 ECP1_IF1=0x0;
    
58.                                 if (temp==0)
    
59.                                 {
    
60.                                         u16tmp0 =  t1c1GetCapture();
    
61.                                         gppHigh(GPPA, P0);
    
62.                                
    
63.                                         // 8MSB of 16bit Top Value
    
64.                                         TMR1H = 0xff;
    
65.                                         // 8LSB of 16bit Top Value
    
66.                                         TMR1L = 0xff;
    
67. 
    
68.                                         ECP1CR2 = 0x02;
    
69.                                         CCP1IE=1;                               
    
70.                                         temp=1;       
    
71.                                 }
    
72.                                 else
    
73.                                 {
    
74.                                         u16tmp1 =  t1c1GetCapture();
    
75.                                         gppLow(GPPA, P0);
    
76.                                         if (calCount>1)
    
77.                                         {
    
78.                                                 u16tmp = (u16tmp + u16tmp1)/2;
    
79.                                         }
    
80.                                         else if (calCount == 1)
    
81.                                         {
    
82.                                                 u16tmp = u16tmp1;
    
83.                                         }
    
84.                                
    
85.                                         if (calCount ==20)
    
86.                                         {
    
87.                                                 inCal = 0;
    
88.                                         }
    
89.                                         calCount++;
    
90.                                
    
91.                                         ECP1CR2 = 0x00;
    
92.                                         CCP1IE=1;                                                               
    
93.                                         temp=0;               
    
94. /*                               
    
95.                                         //send u16tmp for debug purpose                       
    
96.                                         axu_utoa(caTmp, u16tmp, 16);
    
97.                                         //axu_utoa(caTmp, OSCTUNE, 16);
    
98.                                         usartPutStr(caTmp);
    
99.                                         usartPutStr("\r\n");
    
100. */                       
     
101.                                 }
     
102.                         }       
     
103.                 }
     
104.                 eepWrite(1,u16tmp); //low byte of calFactor
     
105.                 eepWrite(2,u16tmp>>8); //high byte of calFactor
     
106.         }
     
107. 
     
108.         u16tmp = eepRead(2)<<8;
     
109.         u16tmp = u16tmp | eepRead(1);
     
110. /*
     
111.         //send u16tmp for debug purpose                       
     
112.         axu_utoa(caTmp, u16tmp, 16);
     
113.         //axu_utoa(caTmp, OSCTUNE, 16);
     
114.         usartPutStr(caTmp);
     
115.         usartPutStr("\r\n");
     
116. */
     
117.         //        float  factor = (12000.000/u16tmp);
     
118.         //float  factor = 1.5;
     
119. 
     
120.         if (u16tmp > 12000 && u16tmp < 12500)
     
121.         {
     
122.                 factor1500 = (standardFactor1500-(u16tmp -12000));
     
123.                 factor750 = (standardFactor750+(u16tmp -12000)/2);
     
124.         }
     
125.         else if (u16tmp <12000 && u16tmp >11500)
     
126.         {
     
127.                 factor1500 = (standardFactor1500+(12000-u16tmp));
     
128.                 factor750 = (standardFactor750-(12000 - u16tmp)/2);
     
129.         }
     
130.        
     
131.         // Main loop
     
132.         while(1)
     
133.         {
     
134.                 if (ECP1_IF1)
     
135.                 {
     
136.                         CCP1IE=0;
     
137.                         ECP1_IF1=0x0;
     
138.                         if (temp==0)
     
139.                         {
     
140.                                 u16tmp0 =  t1c1GetCapture();
     
141.                                 // 8MSB of 16bit Top Value
     
142.                                 TMR1H = 0xff;
     
143.                                 // 8LSB of 16bit Top Value
     
144.                                 TMR1L = 0xff;
     
145. 
     
146.                                 ECP1CR2 = 0x02;
     
147.                                 CCP1IE=1;                               
     
148.                                 temp=1;       
     
149.                                        
     
150.                                 //no timer1 Interrupt (less than 6ms) is 750us mode
     
151.                                 if(!TMR1IF)
     
152.                                 {
     
153.                                         periodTime = (6000 - (u16tmp1 * 0.533)+ factor750); //calculate the 750us mode compensated reversed period time
     
154.                                 }               
     
155.                        
     
156.                         }
     
157.                         else
     
158.                         {
     
159.                                 u16tmp1 =  t1c1GetCapture();
     
160.                                 gppLow(GPPA, P0);
     
161.                                
     
162.                                 //has timer1 Interrupt (longer than 6ms) is 1500us mode
     
163.                                 if(TMR1IF)                               
     
164.                                 {
     
165.                                         periodTime = (12000 - (u16tmp1 * 0.525)-factor1500); //calculate the 1500us mode compensated reversed period time
     
166.                                 TMR1IF =0;
     
167.                                 }
     
168.                                
     
169.                                 DelayUs(periodTime); //reversed output period time
     
170.                                 gppHigh(GPPA, P0);
     
171.                        
     
172.                                 ECP1CR2 = 0x00;
     
173.                                 CCP1IE=1;                                                               
     
174.                                 temp=0;                                               
     
175.                         }
     
176. /*                       
     
177.                         //send u16tmp1 for debug purpose                       
     
178.                         axu_utoa(caTmp, u16tmp1, 16);
     
179.                         //axu_utoa(caTmp, OSCTUNE, 16);
     
180.                         usartPutStr(caTmp);
     
181.                         usartPutStr("\r\n");
     
182. */                       
     
183.                 }
     
184.         }
     
185. 
     
186.         return 0;
     
187. }
     

复制代码

SDK 中的設定：
1) System and Power：
        0x0 16MHz HFINTOSC
        0x6 HFINTOSC/2
        0x0 1T
        Gobal Pullup Enable

2) I/O Subsystem:
        RA0

3) USART Mode:
        0x0 Async. Mode
        19200 19200bps
        0x0 8 bit data
        Enable TX

4) Timer/Counter 1:
        0x1 System clock (Fsys)
        0x0 no scaler
        65000 (value of period register (PR1))
        Common Setting for all ECP1 PWM/Capture channels
                0x0 Instant Mode
                0x0 disable encoder
                0x0 invert, decrease counter
        Check to enable PWM/Capture for channel T1C1
                0x1 Capture Mode
                0x1 T1C1 on RA4
                0x0 from T1C1

5) EEPROM Module

6) Miscellany

7) Configration Words
        FOSC_INTOSC - internal 16MHz HFINTOSC
        WDT_OFF  - disable WDT
        FSEN_OFF - disable crystal fail-safe
        LVR_2V4 - 2.4V LVR threshold
        SUT_2MS  2ms startup timer
        RSTE_ON - enable external reset
        TCYC_1T - 1T instrction cycle
        LVRPM_ON - disable LVR in sleep mode

eddiewwm

為配合上面的690A signal reverser的測試，使用 LGT8F328P 在 Arduino下編寫的一個簡單測試程序：

1. /*
   
2.   Servo Signal Generator For Test Purpose
   
3. 
   
4. */
   
5. 
   
6. # define ServoOut 13
   
7. 
   
8. // the setup function runs once when you press reset or power the board
   
9. void setup() {
   
10.   // initialize digital pin as Servo output.
    
11.   pinMode(ServoOut, OUTPUT);
    
12. }
    
13. 
    
14. // the loop function runs over and over again forever
    
15. void loop() {
    
16. ///*
    
17.       digitalWrite(ServoOut, HIGH);   // turn the ServoOut on (HIGH is the voltage level)
    
18.       delayMicroseconds(1500 * 1.33);                     // wait for a second
    
19.       digitalWrite(ServoOut, LOW);    // turn the ServoOut off by making the voltage LOW
    
20.       delay(15);                       // wait for a second
    
21. //*/
    
22. /*
    
23.   for (int i = 8; i < 20; i++) {
    
24.     for (int j = 750; j < 2250; j=j+10) {
    
25.       digitalWrite(ServoOut, HIGH);   // turn the ServoOut on (HIGH is the voltage level)
    
26.       delayMicroseconds(j * 1.33);                     // wait for a second
    
27.       digitalWrite(ServoOut, LOW);    // turn the ServoOut off by making the voltage LOW
    
28.       delay(i);                       // wait for a second
    
29.     }
    
30.   }
    
31. /*
    
32.       digitalWrite(ServoOut, HIGH);   // turn the ServoOut on (HIGH is the voltage level)
    
33.       delayMicroseconds(750 * 1.33);                     // wait for a second
    
34.       digitalWrite(ServoOut, LOW);    // turn the ServoOut off by making the voltage LOW
    
35.       delayMicroseconds(1500*1.33);                       // wait for a second
    
36. */
    
37. 
    
38. /*
    
39.     for (int j = 400; j < 1120; j++) {
    
40.       digitalWrite(ServoOut, HIGH);   // turn the ServoOut on (HIGH is the voltage level)
    
41.       delayMicroseconds(j * 1.33);                     // wait for a second
    
42.       digitalWrite(ServoOut, LOW);    // turn the ServoOut off by making the voltage LOW
    
43.       delayMicroseconds(2000*1.33);                       // wait for a second
    
44.     }
    
45. */
    
46. }
    

复制代码