API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Aug 22nd, 2017
186
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 8.49 KB | None | 0 0
raw download clone embed print report
  1.  
  2. /* фаил main.c */
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include "diag/Trace.h"
  6. #include "math.h"
  7. #include "stm32f401_discovery.h"
  8. #include "main.h"
  9. #include "Timer.h"
  10. #include "BlinkLed.h"
  11. #define BLINK_ON_TICKS  (TIMER_FREQUENCY_HZ * 3 / 4)
  12. #define BLINK_OFF_TICKS (TIMER_FREQUENCY_HZ - BLINK_ON_TICKS)
  13. void ACCELERO_ReadAcc(void);
  14. void GYRO_ReadAng(void);
  15. void ACCELERO_MEMS_Test(void);
  16. void GYRO_MEMS_Test(void);
  17. void EXTILine0_Config(void);
  18.  
  19. extern __IO uint8_t UserPressButton;
  20.  
  21. int16_t ThresholdHigh = 1000;
  22. int16_t ThresholdLow = -1000;
  23. __IO uint8_t UserPressButton = 0;
  24.  
  25. int
  26. main(int argc, char* argv[]){
  27.     trace_puts("Hello ARM World!");
  28.     BSP_PB_Init(BUTTON_KEY, BUTTON_MODE_EXTI);
  29.     trace_puts("Hello ARM World!");
  30.     trace_printf("System clock: %u Hz\n", SystemCoreClock);
  31.     timer_start();
  32.     float pdata[3];
  33.     blink_led_init(12);
  34.     blink_led_init(13);
  35.     blink_led_init(14);
  36.     blink_led_init(15);
  37.     uint32_t seconds = 0;
  38.     while(1){
  39.         GYRO_MEMS_Test();
  40.         ACCELERO_MEMS_Test();
  41.  
  42.     }
  43. }
  44.  
  45. void ACCELERO_MEMS_Test(void){
  46.   trace_printf("\n\n\nACCELERO_MEMS_Test\n");
  47.   if(BSP_ACCELERO_Init() != HAL_OK){
  48.   }
  49.   UserPressButton = 0;
  50.   while(!UserPressButton){
  51.     ACCELERO_ReadAcc();
  52.   }
  53. }
  54. void ACCELERO_ReadAcc(void){
  55.   int16_t buffer[3] = {0};
  56.   int16_t xval, yval = 0x00;
  57.   BSP_ACCELERO_GetXYZ(buffer);
  58.   xval = buffer[0];
  59.   yval = buffer[1];
  60.   if((abs(xval))>(abs(yval))){
  61.     if(xval > ThresholdHigh){
  62.         BSP_LED_On(LED5);
  63.         timer_sleep(BLINK_ON_TICKS);
  64.     }
  65.     else if(xval < ThresholdLow){
  66.         BSP_LED_On(LED4);
  67.         timer_sleep(BLINK_ON_TICKS);
  68.     }else{
  69.         timer_sleep(BLINK_ON_TICKS);
  70.     }
  71.   }else{
  72.     if(yval < ThresholdLow){
  73.         BSP_LED_On(LED6);
  74.         timer_sleep(BLINK_ON_TICKS);
  75.     }else if(yval > ThresholdHigh){
  76.         BSP_LED_On(LED3);
  77.       timer_sleep(BLINK_ON_TICKS);
  78.     }else{
  79.         timer_sleep(BLINK_ON_TICKS);
  80.     }
  81.   }
  82.   trace_printf("xval = %d\t", xval);
  83.   trace_printf("yval = %d   \n", yval);
  84.   blink_led_off(12);
  85.   blink_led_off(13);
  86.   blink_led_off(14);
  87.   blink_led_off(15);
  88. }
  89.  
  90. void GYRO_MEMS_Test(void)
  91. {
  92.     trace_printf("\n\n\nGYRO_MEMS_Test\n");
  93.     UserPressButton = 0;
  94.     while(!UserPressButton){
  95.         GYRO_ReadAng();
  96.     }
  97. }
  98. void GYRO_ReadAng(void){
  99.   float Buffer[3];
  100.   float Xval, Yval = 0x00;
  101.   BSP_GYRO_GetXYZ(Buffer);
  102.   Xval = abs((Buffer[0]));
  103.   Yval = abs((Buffer[1]));
  104.   if(Xval>Yval){
  105.     if(Buffer[0] > 5000.0f){
  106.         BSP_LED_On(LED5);
  107.         timer_sleep(BLINK_ON_TICKS);
  108.     }
  109.     if(Buffer[0] < -5000.0f){
  110.         BSP_LED_On(LED4);
  111.         timer_sleep(BLINK_ON_TICKS);
  112.     }else{
  113.         timer_sleep(BLINK_ON_TICKS);
  114.     }
  115.   }{
  116.    if(Buffer[1] < -5000.0f){
  117.       BSP_LED_On(LED6);
  118.         timer_sleep(BLINK_ON_TICKS);
  119.     }if(Buffer[1] > 5000.0f){
  120.         BSP_LED_On(LED3);
  121.         timer_sleep(BLINK_ON_TICKS);
  122.     }else{
  123.         timer_sleep(BLINK_ON_TICKS);
  124.     }
  125.   }
  126.   trace_printf("Xval = %g\t", Buffer[0]);
  127.   trace_printf("Yval = %g\n", Buffer[1]);
  128.   blink_led_off(12);
  129.   blink_led_off(13);
  130.   blink_led_off(14);
  131.   blink_led_off(15);
  132. }
  133.  
  134. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin){
  135. if (KEY_BUTTON_PIN == GPIO_Pin){
  136.     while (BSP_PB_GetState(BUTTON_KEY) != RESET);
  137.     UserPressButton = 1;
  138. }
  139. }
  140.  
  141. #pragma GCC diagnostic pop
  142.  
  143. // ----------------------------------------------------------------------------
  144. /* файл stm32f401_discovery_accelerometer.с */
  145. uint8_t BSP_ACCELERO_Init(void){
  146.   uint8_t ret = ACCELERO_ERROR;
  147.   uint16_t ctrl = 0x0000;
  148.   ACCELERO_InitTypeDef         LSM303DLHC_InitStructure;
  149.   ACCELERO_FilterConfigTypeDef LSM303DLHC_FilterStructure = {0,0,0,0};
  150.   if(Lsm303dlhcDrv.ReadID() == I_AM_LMS303DLHC){
  151.     AccelerometerDrv = &Lsm303dlhcDrv;
  152.     LSM303DLHC_InitStructure.Power_Mode = LSM303DLHC_NORMAL_MODE;
  153.     LSM303DLHC_InitStructure.AccOutput_DataRate = LSM303DLHC_ODR_50_HZ;
  154.     LSM303DLHC_InitStructure.Axes_Enable = LSM303DLHC_AXES_ENABLE;
  155.     LSM303DLHC_InitStructure.AccFull_Scale = LSM303DLHC_FULLSCALE_2G;
  156.     LSM303DLHC_InitStructure.BlockData_Update = LSM303DLHC_BlockUpdate_Continous;
  157.     LSM303DLHC_InitStructure.Endianness = LSM303DLHC_BLE_LSB;
  158.     LSM303DLHC_InitStructure.High_Resolution = LSM303DLHC_HR_ENABLE;
  159.     ctrl |= (LSM303DLHC_InitStructure.Power_Mode | LSM303DLHC_InitStructure.AccOutput_DataRate | \
  160.                        LSM303DLHC_InitStructure.Axes_Enable);
  161.     ctrl |= ((LSM303DLHC_InitStructure.BlockData_Update | LSM303DLHC_InitStructure.Endianness | \
  162.                       LSM303DLHC_InitStructure.AccFull_Scale | LSM303DLHC_InitStructure.High_Resolution) << 8);
  163.     AccelerometerDrv->Init(ctrl);
  164.     LSM303DLHC_FilterStructure.HighPassFilter_Mode_Selection =LSM303DLHC_HPM_NORMAL_MODE;
  165.     LSM303DLHC_FilterStructure.HighPassFilter_CutOff_Frequency = LSM303DLHC_HPFCF_16;
  166.     LSM303DLHC_FilterStructure.HighPassFilter_AOI1 = LSM303DLHC_HPF_AOI1_DISABLE;
  167.     LSM303DLHC_FilterStructure.HighPassFilter_AOI2 = LSM303DLHC_HPF_AOI2_DISABLE;
  168.     ctrl = (uint8_t) (LSM303DLHC_FilterStructure.HighPassFilter_Mode_Selection |\
  169.                       LSM303DLHC_FilterStructure.HighPassFilter_CutOff_Frequency|\
  170.                       LSM303DLHC_FilterStructure.HighPassFilter_AOI1|\
  171.                       LSM303DLHC_FilterStructure.HighPassFilter_AOI2);
  172.     AccelerometerDrv->FilterConfig(ctrl);
  173.     ret = ACCELERO_OK;
  174.   }
  175.   else{
  176.     ret = ACCELERO_ERROR;
  177.   }
  178.   return ret;
  179. }
  180. void BSP_ACCELERO_Reset(void){
  181.   if(AccelerometerDrv->Reset != NULL){
  182.     AccelerometerDrv->Reset();
  183.   }  
  184. }
  185. void BSP_ACCELERO_Click_ITConfig(void){
  186.   if(AccelerometerDrv->ConfigIT!= NULL){
  187.     AccelerometerDrv->ConfigIT();
  188.   }
  189. }
  190. void BSP_ACCELERO_GetXYZ(int16_t *pDataXYZ){
  191.   int16_t SwitchXY = 0;
  192.   if(AccelerometerDrv->GetXYZ!= NULL){
  193.     AccelerometerDrv->GetXYZ(pDataXYZ);
  194.     if(AccelerometerDrv == &Lsm303dlhcDrv){
  195.       SwitchXY  = pDataXYZ[0];
  196.       pDataXYZ[0] = pDataXYZ[1];
  197.       pDataXYZ[1] = -SwitchXY;
  198.     }
  199.   }
  200. }
  201.  
  202. /* файл stm32f401_discovery_gyroscope.c */
  203. uint8_t BSP_GYRO_Init(void){  
  204.   uint8_t ret = GYRO_ERROR;
  205.   uint16_t ctrl = 0x0000;
  206.   GYRO_InitTypeDef         L3GD20_InitStructure;
  207.   GYRO_FilterConfigTypeDef L3GD20_FilterStructure = {0,0};
  208.   if((L3gd20Drv.ReadID() == I_AM_L3GD20) || (L3gd20Drv.ReadID() == I_AM_L3GD20_TR)){
  209.     GyroscopeDrv = &L3gd20Drv;
  210.     L3GD20_InitStructure.Power_Mode = L3GD20_MODE_ACTIVE;
  211.     L3GD20_InitStructure.Output_DataRate = L3GD20_OUTPUT_DATARATE_1;
  212.     L3GD20_InitStructure.Axes_Enable = L3GD20_AXES_ENABLE;
  213.     L3GD20_InitStructure.Band_Width = L3GD20_BANDWIDTH_4;
  214.     L3GD20_InitStructure.BlockData_Update = L3GD20_BlockDataUpdate_Continous;
  215.     L3GD20_InitStructure.Endianness = L3GD20_BLE_LSB;
  216.     L3GD20_InitStructure.Full_Scale = L3GD20_FULLSCALE_500;
  217.     ctrl = (uint16_t) (L3GD20_InitStructure.Power_Mode | L3GD20_InitStructure.Output_DataRate | \
  218.                       L3GD20_InitStructure.Axes_Enable | L3GD20_InitStructure.Band_Width);
  219.     ctrl |= (uint16_t) ((L3GD20_InitStructure.BlockData_Update | L3GD20_InitStructure.Endianness | \
  220.                         L3GD20_InitStructure.Full_Scale) << 8);
  221.     GyroscopeDrv->Init(ctrl);
  222.     L3GD20_FilterStructure.HighPassFilter_Mode_Selection =L3GD20_HPM_NORMAL_MODE_RES;
  223.     L3GD20_FilterStructure.HighPassFilter_CutOff_Frequency = L3GD20_HPFCF_0;
  224.     ctrl = (uint8_t) ((L3GD20_FilterStructure.HighPassFilter_Mode_Selection |\
  225.                        L3GD20_FilterStructure.HighPassFilter_CutOff_Frequency));    
  226.     GyroscopeDrv->FilterConfig(ctrl) ;
  227.     GyroscopeDrv->FilterCmd(L3GD20_HIGHPASSFILTER_ENABLE);
  228.     ret = GYRO_OK;
  229.   }
  230.   return ret;
  231. }
  232. uint8_t BSP_GYRO_ReadID(void){
  233.   uint8_t id = 0x00;
  234.   if(GyroscopeDrv->ReadID != NULL){
  235.     id = GyroscopeDrv->ReadID();
  236.   }  
  237.   return id;
  238. }
  239. void BSP_GYRO_Reset(void){  
  240.   if(GyroscopeDrv->Reset != NULL){
  241.     GyroscopeDrv->Reset();
  242.   }  
  243. }
  244. void BSP_GYRO_ITConfig(GYRO_InterruptConfigTypeDef *pIntConfig){
  245.   uint16_t interruptconfig = 0x0000;
  246.   if(GyroscopeDrv->ConfigIT != NULL){
  247.     interruptconfig |= ((uint8_t)(pIntConfig->Latch_Request| \
  248.                                   pIntConfig->Interrupt_Axes) << 8);
  249.     interruptconfig |= (uint8_t)(pIntConfig->Interrupt_ActiveEdge);
  250.     GyroscopeDrv->ConfigIT(interruptconfig);
  251.   }  
  252. }
  253. void BSP_GYRO_EnableIT(uint8_t IntPin){
  254.   if(GyroscopeDrv->EnableIT != NULL){
  255.     GyroscopeDrv->EnableIT(IntPin);
  256.   }
  257. }
  258. void BSP_GYRO_DisableIT(uint8_t IntPin){
  259.   if(GyroscopeDrv->DisableIT != NULL){
  260.     GyroscopeDrv->DisableIT(IntPin);
  261.   }
  262. }
  263. void BSP_GYRO_GetXYZ(float *pfData){
  264.   if(GyroscopeDrv->GetXYZ!= NULL ){  
  265.     GyroscopeDrv->GetXYZ(pfData);
  266.   }
  267. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!