KW41 自动搬运小车测试

strong161

KW41 自动搬运小车测试 [复制链接]

        点完灯后一直没有没更新，主要是技术不行，BLE一直整不懂，所以暂时先搞下基本车子的功能，先分享一下近期的进展吧。结构比较简单，就是个四驱小车，实际采用的是双驱，只用了一片L298N，结果，压跟带不起4个电机，……抽空再加一片L298N吧。半边跑一顿撞，红外寻迹Sensor只余下两路了，所以代码还是得改改，2路是个尴尬的问题变成妞妞车了。
      
       因为KW41兼容arduino接口，所以就直接把所有电路都直接怼在一个arduino扩展板上了，这样的好处就是，每次不用老是一根一根对线了。在这里对KW41还是要提点建议的，KW41的板子上面设计可不可以把带PWM IO也能arduino兼容一下，这样就更加直接观了，更加方便了，因为某宝上查了一些arduino直插的电机驱动板，那样会很方便，但是与KW41是没法怼的，因为使用是arduino带PWM输出的IO，而对应的IO在KW41上面并没有PWM功能，需要软件来做，这样就比较复杂了。
      另外还有一个比较尴尬的事，就是原来设计按SW3进入中断，然后使能启动主程序，结果一直进不了中断，后面检查发现，SW3的IO被占用了，也就是一个IO做了板载SW后，同时又做成了arduino接口，当然这个主要是自己没有仔细看，不过一个IO做了板载SW最好就不要再放到arduino接口上面了。
        
        
        

1. gpio_pin_config_t moto_config = {
   
2.                 kGPIO_DigitalOutput, 0,
   
3. };
   
4. /*moto IO init*/
   
5. #define MOTO_INIT                                                    \
   
6.          GPIO_PinInit(MOTO_LEFT1_GPIO, MOTO_LEFT1_GPIO_PIN, &moto_config);\
   
7.          GPIO_PinInit(MOTO_LEFT2_GPIO, MOTO_LEFT2_GPIO_PIN, &moto_config);\
   
8.          GPIO_PinInit(MOTO_RIGHT1_GPIO, MOTO_RIGHT1_GPIO_PIN, &moto_config);\
   
9.          GPIO_PinInit(MOTO_RIGHT2_GPIO, MOTO_RIGHT2_GPIO_PIN, &moto_config)
   
10. /*moto dirct*/
    
11. #define MOTO_LEFT_RUN                                           \
    
12.                 GPIO_WritePinOutput(MOTO_LEFT1_GPIO, MOTO_LEFT1_GPIO_PIN, 1);\
    
13.                 GPIO_WritePinOutput(MOTO_LEFT2_GPIO, MOTO_LEFT2_GPIO_PIN, 0)
    
14. #define MOTO_RIGHT_BACK                                          \
    
15.                 GPIO_WritePinOutput(MOTO_LEFT1_GPIO, MOTO_LEFT1_GPIO_PIN, 0);\
    
16.                 GPIO_WritePinOutput(MOTO_LEFT2_GPIO, MOTO_LEFT2_GPIO_PIN, 1)
    
17. 
    
18. #define MOTO_RIGHT_RUN                                             \
    
19.                 GPIO_WritePinOutput(MOTO_RIGHT1_GPIO, MOTO_RIGHT1_GPIO_PIN, 1);\
    
20.                 GPIO_WritePinOutput(MOTO_RIGHT2_GPIO, MOTO_RIGHT2_GPIO_PIN, 0)
    
21. #define MOTO_LEFT_BACK                                            \
    
22.                 GPIO_WritePinOutput(MOTO_RIGHT1_GPIO, MOTO_RIGHT1_GPIO_PIN, 0);\
    
23.                 GPIO_WritePinOutput(MOTO_RIGHT2_GPIO, MOTO_RIGHT2_GPIO_PIN, 1)

复制代码

1. /*setting for four tracking Sensors */
   
2. #define TRACK_SENSOR_GPIO GPIOB
   
3. #define TRACK_SENSOR_PORT PORTB
   
4. //#define TRACK_SENSOR1_GPIO_PIN  1U
   
5. #define TRACK_SENSOR2_GPIO_PIN  1U
   
6. #define TRACK_SENSOR3_GPIO_PIN  2U
   
7. //#define TRACK_SENSOR4_GPIO_PIN  18U
   
8. 
   
9. #define TRACK_SENSOR_IRQ PORTB_PORTC_IRQn
   
10. #define TRACK_SENSOR_IRQ_HANDLER PORTB_PORTC_IRQHandler

复制代码

       以前没有好好玩过小车，所以对L298N使用有点尴尬，仿佛是有坑的，本来是打算通过Enable输入PWM进行调速的，结果根本调不了……后来经饺神指导，说L298N的enable使能调PWM基本上要最低频，那样PWM就没有什么意思了，所以还是用直接输出到IN上面控制电机。
   

1. void TRACK_SENSOR_IRQ_HANDLER(void) {
   
2. /*read IRQ source and clean IRQ */
   
3. //        if (GPIO_GetPinsInterruptFlags(TRACK_SENSOR_GPIO)&(1U << TRACK_SENSOR1_GPIO_PIN)) {
   
4. //                GPIO_ClearPinsInterruptFlags( TRACK_SENSOR_GPIO,1U << TRACK_SENSOR1_GPIO_PIN);
   
5. //                AUTO_MODE = 1;
   
6. //                        }
   
7. //
   
8. //        else
   
9.         if (GPIO_GetPinsInterruptFlags(TRACK_SENSOR_GPIO)&(1U << TRACK_SENSOR2_GPIO_PIN)) {
   
10.                 GPIO_ClearPinsInterruptFlags( TRACK_SENSOR_GPIO,1U << TRACK_SENSOR2_GPIO_PIN );
    
11.                 AUTO_MODE = 2;
    
12.                         }
    
13. 
    
14.         else if (GPIO_GetPinsInterruptFlags(TRACK_SENSOR_GPIO)&(1U << TRACK_SENSOR3_GPIO_PIN)) {
    
15.                 GPIO_ClearPinsInterruptFlags( TRACK_SENSOR_GPIO,1U << TRACK_SENSOR3_GPIO_PIN);
    
16.                 AUTO_MODE = 3;
    
17.                         }
    
18. 
    
19.         else if(GPIO_GetPinsInterruptFlags(BOARD_SW_GPIO)&(1U<< BOARD_SW_GPIO_PIN)){
    
20.             /* Clear external interrupt flag. */
    
21.             GPIO_ClearPinsInterruptFlags(BOARD_SW_GPIO, 1U << BOARD_SW_GPIO_PIN);
    
22.             /* Change state of button. */
    
23.             SwForStart = 1;
    
24.         }
    
25.         else printf("error cannot find the IRQ");
    
26. }

复制代码

主程序

1. int main(void) {
   
2.     /* Define the init structure for the input switch pin */
   
3.     gpio_pin_config_t sw_config = {
   
4.         kGPIO_DigitalInput, 0,
   
5.     };
   
6.     /* Init input switch GPIO. */
   
7.         /*MOTO Enable TPM seting */
   
8. 
   
9.           /*
   
10.              * tpmInfo.prescale = kTPM_Prescale_Divide_1;
    
11.              * tpmInfo.useGlobalTimeBase = false;
    
12.              * tpmInfo.enableDoze = false;
    
13.              * tpmInfo.enableDebugMode = false;
    
14.              * tpmInfo.enableReloadOnTrigger = false;
    
15.              * tpmInfo.enableStopOnOverflow = false;
    
16.              * tpmInfo.enableStartOnTrigger = false;
    
17.              * tpmInfo.enablePauseOnTrigger = false;
    
18.              * tpmInfo.triggerSelect = kTPM_Trigger_Select_0;
    
19.              * tpmInfo.triggerSource = kTPM_TriggerSource_External;
    
20.              */
    
21.     tpm_config_t tpmInfo;
    
22. 
    
23.     tpm_chnl_pwm_signal_param_t tpmParam[2];
    
24.     /* Configure tpm params with frequency 24kHZ */
    
25.     tpmParam[0].chnlNumber = (tpm_chnl_t)MOTO_LEFT_TPM_CHANNEL;
    
26.     tpmParam[0].level = kTPM_LowTrue;
    
27.     tpmParam[0].dutyCyclePercent = updatedDutycycleLeft;
    
28. 
    
29.     tpmParam[1].chnlNumber = (tpm_chnl_t)MOTO_RIGHT_TPM_CHANNEL;
    
30.     tpmParam[1].level = kTPM_LowTrue;
    
31.     tpmParam[1].dutyCyclePercent = updatedDutycycleRight;
    
32. 
    
33.   /*config for Sensor IO*/
    
34.     gpio_pin_config_t Track_Sensor_config = {
    
35.         kGPIO_DigitalInput, 0,
    
36.     };
    
37. 
    
38. 
    
39.           /* Init board hardware. */
    
40.     BOARD_InitBootPins();
    
41.     BOARD_InitBootClocks();
    
42.           /* Init FSL debug console. */
    
43.     BOARD_InitDebugConsole();
    
44. 
    
45.     /*Init the Moto IO*/
    
46.     MOTO_INIT;
    
47. 
    
48.     /*for Start SW */
    
49.     PORT_SetPinInterruptConfig(BOARD_SW_PORT, BOARD_SW_GPIO_PIN, kPORT_InterruptFallingEdge);
    
50. 
    
51. 
    
52.     /*Init the Tracking Sensor IO */
    
53.     /*
    
54.      * Sensor1 out of line and in line all in interrupt,
    
55.      * then need to check the site of the pin,if in line Turn to high speed ,else in half speed
    
56.      * Sensor2,3 only the Sensor in rising Well be interrupt
    
57.      * */
    
58.     //PORT_SetPinInterruptConfig(TRACK_SENSOR_PORT, TRACK_SENSOR1_GPIO_PIN, kPORT_InterruptEitherEdge);
    
59.     PORT_SetPinInterruptConfig(TRACK_SENSOR_PORT, TRACK_SENSOR2_GPIO_PIN, kPORT_InterruptRisingEdge);
    
60.     PORT_SetPinInterruptConfig(TRACK_SENSOR_PORT, TRACK_SENSOR3_GPIO_PIN, kPORT_InterruptRisingEdge);
    
61.    /*Enable of IRQ of the Sensor and Init all Sensor pin*/
    
62.     EnableIRQ(TRACK_SENSOR_IRQ);
    
63.    // GPIO_PinInit(TRACK_SENSOR_GPIO, TRACK_SENSOR1_GPIO_PIN, &Track_Sensor_config);
    
64.     GPIO_PinInit(TRACK_SENSOR_GPIO, TRACK_SENSOR2_GPIO_PIN, &Track_Sensor_config);
    
65.     GPIO_PinInit(TRACK_SENSOR_GPIO, TRACK_SENSOR3_GPIO_PIN, &Track_Sensor_config);
    
66. 
    
67.     /*for Start SW*/
    
68.     GPIO_PinInit(BOARD_SW_GPIO, BOARD_SW_GPIO_PIN, &sw_config);
    
69. 
    
70.     /* Select the clock source for the TPM counter as MCGPLLCLK */
    
71.     CLOCK_SetTpmClock(1U);
    
72. 
    
73.     TPM_GetDefaultConfig(&tpmInfo);
    
74. 
    
75.     /* Initialize TPM module */
    
76.     TPM_Init(MOTO_TPM_BASEADDR, &tpmInfo);
    
77.     TPM_SetupPwm(MOTO_TPM_BASEADDR, tpmParam, 2U, kTPM_EdgeAlignedPwm, 20000U, TPM_SOURCE_CLOCK);
    
78. 
    
79. 
    
80. //    car_move_control_t car_mover_config;
    
81. //    car_mover_config.CarLeftMotoDirection = 1;
    
82. //    car_mover_config.CarRightMotoDirection = 1;
    
83. //    car_mover_config.CarLeftMotoEnable = 50;
    
84. //    car_mover_config.CarRightMotoEnable = 20;
    
85. 
    
86. /*wait for pass Sw4 for start  */
    
87. 
    
88.     while( 0==SwForStart ){
    
89.             printf("pass the key for start \n");
    
90.             delay();
    
91.             delay();
    
92.             delay();
    
93.     }
    
94.     printf("init over \n");
    
95.     /*moto direct */
    
96.     MOTO_LEFT_RUN;
    
97.     MOTO_RIGHT_RUN;
    
98.     /*Start PWM*/
    
99.     TPM_StartTimer(MOTO_TPM_BASEADDR, kTPM_SystemClock);
    
100. 
     
101.     /* Enter an infinite loop for Run Auto */
     
102.     /*just  for test pwm*/
     
103. //    for(;;){
     
104. //
     
105. //        TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
     
106. //                                                        (tpm_chnl_t)MOTO_LEFT_TPM_CHANNEL,
     
107. //                                                            kTPM_EdgeAlignedPwm,
     
108. //                                                            50);
     
109. //
     
110. //        TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
     
111. //                                                        (tpm_chnl_t)MOTO_RIGHT_TPM_CHANNEL,
     
112. //                                                            kTPM_EdgeAlignedPwm,
     
113. //                                                            80);
     
114. //
     
115. //    }
     
116. 
     
117. 
     
118.    for(;;){
     
119.            if(0 == AUTO_MODE){
     
120.                    CarRun(0);
     
121.            }else if (1 == AUTO_MODE){
     
122.                    CarRun(0);
     
123.            }else if (2 == AUTO_MODE){
     
124.                    CarTurnLeft(1);
     
125.            }else if (3 == AUTO_MODE){
     
126.                    CarTurnRight(1);
     
127.            }
     
128. 
     
129.     }
     
130.     return 0 ;
     
131. }

复制代码

自动运动与远程控制的函数

1. void CarTurnRight(char turnRightSpeed){
   
2. 
   
3.         uint8_t turnSpeed[2];
   
4. 
   
5.         if(1 == turnRightSpeed)                {
   
6.                 turnSpeed[0] = 80;
   
7.                 turnSpeed[1] = 99;
   
8.         }else if  (2 == turnRightSpeed)        {
   
9.                 turnSpeed[0] = 90;
   
10.                 turnSpeed[1] = 99;
    
11.         }else                            {
    
12.                 turnSpeed[0] = 95;
    
13.                 turnSpeed[1] = 99;
    
14.         }
    
15. 
    
16.     TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
    
17.                                                     (tpm_chnl_t)MOTO_LEFT_TPM_CHANNEL,
    
18.                                                         kTPM_EdgeAlignedPwm,
    
19.                                                         turnSpeed[0]);
    
20. 
    
21.     TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
    
22.                                                     (tpm_chnl_t)MOTO_RIGHT_TPM_CHANNEL,
    
23.                                                         kTPM_EdgeAlignedPwm,
    
24.                                                         turnSpeed[1]);
    
25. }
    
26. /**car TURN LEFT
    
27. * turnLeftSpeed  1 high turn left
    
28. * turnLeftSpeed  2 50% turn left
    
29. * turnLefttSpeed  3 25% turn left
    
30. *  */
    
31. void CarTurnLeft(char turnLeftSpeed){
    
32.          uint8_t turnSpeed[2];
    
33.         if (1 == turnLeftSpeed)             {
    
34.                 turnSpeed[0] = 80;
    
35.                 turnSpeed[1] = 99;
    
36.         }else if  (2 == turnLeftSpeed)        {
    
37.                 turnSpeed[0] = 90;
    
38.                 turnSpeed[1] = 99;
    
39.         }else                           {
    
40.                 turnSpeed[0] = 95;
    
41.                 turnSpeed[1] = 99;
    
42.         }
    
43. 
    
44.         MOTO_LEFT_RUN;
    
45.         MOTO_RIGHT_RUN;
    
46. 
    
47.         TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
    
48.                                                         (tpm_chnl_t)MOTO_LEFT_TPM_CHANNEL,
    
49.                                                         kTPM_EdgeAlignedPwm,
    
50.                                                         turnSpeed[1]);
    
51.         TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
    
52.                                                         (tpm_chnl_t)MOTO_RIGHT_TPM_CHANNEL,
    
53.                                                         kTPM_EdgeAlignedPwm,
    
54.                                                         turnSpeed[0]);
    
55. 
    
56. }
    
57. 
    
58. /**
    
59. * Run mode
    
60. * speed
    
61. * depend on the
    
62. * speed  = 1
    
63. * 1 = hight speed
    
64. * 0 = Low speed
    
65. * */
    
66. 
    
67. void CarRun(bool Speed){
    
68.          uint8_t RunSpeed;
    
69.          if(1 == Speed){
    
70.                  RunSpeed = 95;
    
71.          }else{
    
72.                  RunSpeed = 99;
    
73.          }
    
74.          MOTO_LEFT_RUN;
    
75.          MOTO_RIGHT_RUN;
    
76.          /*Run with the speed */
    
77.            TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
    
78.                                                                        (tpm_chnl_t)MOTO_LEFT_TPM_CHANNEL,
    
79.                                                            kTPM_EdgeAlignedPwm,
    
80.                                                            RunSpeed);
    
81.            TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
    
82.                                                                        (tpm_chnl_t)MOTO_RIGHT_TPM_CHANNEL,
    
83.                                                            kTPM_EdgeAlignedPwm,
    
84.                                                            RunSpeed);
    
85. }
    
86. typedef struct _car_move_control
    
87. {
    
88.   bool CarLeftMotoDirection;          /* left moto direction */
    
89.   bool CarRightMotoDirection;         /* Output direction */
    
90.   char CarLeftMotoEnable;             /* present of Left moto PWM */
    
91.   char CarRightMotoEnable;             /* present of Right moto PWM */
    
92. } car_move_control_t;
    
93. 
    
94. 
    
95. void CarMoveControl(car_move_control_t *Car_Move_control){
    
96.         assert(Car_Move_control);
    
97.         //uint16_t _temp = car_move_control_t *Car_Move_control
    
98. 
    
99.         if(Car_Move_control->CarLeftMotoDirection) {
    
100.                 MOTO_LEFT_RUN;
     
101.         }else {
     
102.                 MOTO_LEFT_BACK;
     
103.         }
     
104. 
     
105.         if(Car_Move_control->CarRightMotoDirection){
     
106.                 MOTO_RIGHT_RUN;
     
107.         }else {
     
108.                 MOTO_RIGHT_BACK;
     
109.         }
     
110.         TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
     
111.                                                         (tpm_chnl_t)MOTO_LEFT_TPM_CHANNEL,
     
112.                                                         kTPM_EdgeAlignedPwm,
     
113.                                                         Car_Move_control->CarLeftMotoEnable);
     
114.         TPM_UpdatePwmDutycycle(        MOTO_TPM_BASEADDR,
     
115.                                                         (tpm_chnl_t)MOTO_RIGHT_TPM_CHANNEL,
     
116.                                                         kTPM_EdgeAlignedPwm,
     
117.                                                         Car_Move_control->CarRightMotoEnable);
     
118. }

复制代码

      整机状态如下图。
      
      周未由于撞坏了2个Sensor所以也改成2Sensor测试了，通过Sensor进中断，后分别调整两侧电机PWM，测试结果还是良好的。
来个视频吧。EE的视频咋加的，还不会，过一会儿再来补






此内容由EEWORLD论坛网友strong161原创，如需转载或用于商业用途需征得作者同意并注明出处

ljj3166

我在长沙发现了楼主

qwerghf

很好，多谢分享

long521

代码狂人,贴了一堆

strong161

ljj3166 发表于 2017-6-6 10:21
我在长沙发现了楼主

  我都几个月没有去长沙了……

strong161

qwerghf 发表于 2017-6-6 10:26
很好，多谢分享

谢谢腾哥帮顶

strong161

long521 发表于 2017-6-6 10:31
代码狂人,贴了一堆

好像是写的太多了，看样子还是得删掉点！

shinykongcn

6b了铁

dql2016

只用了一块啊

strong161

dql2016 发表于 2017-6-6 12:21
只用了一块啊

车上空间不多！……

ljj3166

strong161 发表于 2017-6-6 10:35
我都几个月没有去长沙了……

年轻人，谦虚点......