www.pudn.com > Micrium-ST-uCOS-II-LCD-STM32-SK.rar > bsp.c
/* ********************************************************************************************************* * MICIRUM BOARD SUPPORT PACKAGE * * (c) Copyright 2007; Micrium, Inc.; Weston, FL * * All rights reserved. Protected by international copyright laws. * Knowledge of the source code may NOT be used to develop a similar product. * Please help us continue to provide the Embedded community with the finest * software available. Your honesty is greatly appreciated. ********************************************************************************************************* */ /* ********************************************************************************************************* * * BOARD SUPPORT PACKAGE * * ST Microelectronics STM32 * with the * IAR STM32-SK Evaluation Board * * Filename : bsp.c * Version : V1.00 * Programmer(s) : Brian Nagel ********************************************************************************************************* */ /* ********************************************************************************************************* * INCLUDE FILES ********************************************************************************************************* */ #define BSP_GLOBALS #include/* ********************************************************************************************************* * LOCAL DEFINES ********************************************************************************************************* */ /* ---------------------- GPIOA Pins ---------------------- */ #define GPIOA_PB_WAKEUP DEF_BIT_00 #define GPIOA_MIC_IN DEF_BIT_01 #define GPIOA_UART2_TX DEF_BIT_02 #define GPIOA_UART2_RX DEF_BIT_03 #define GPIOA_LED1 DEF_BIT_04 #define GPIOA_LED2 DEF_BIT_05 #define GPIOA_LED3 DEF_BIT_06 #define GPIOA_LED4 DEF_BIT_07 #define GPIOA_PWM_OUT DEF_BIT_08 #define GPIOA_LED5 DEF_BIT_09 #define GPIOA_LED6 DEF_BIT_10 #define GPIOA_LEDS (GPIOA_LED1 | GPIOA_LED2 | GPIOA_LED3 | GPIOA_LED4 | GPIOA_LED5 | GPIOA_LED6) /* ---------------------- GPIOB Pins ---------------------- */ #define GPIOB_LCD_LIGHT DEF_BIT_00 #define GPIOB_PB2 DEF_BIT_05 #define GPIOB_LED7 DEF_BIT_06 #define GPIOB_LED8 DEF_BIT_07 #define GPIOB_CAN_RX DEF_BIT_08 #define GPIOB_CAN_TX DEF_BIT_09 #define GPIOB_LED9 DEF_BIT_10 #define GPIOB_LED10 DEF_BIT_11 #define GPIOB_LED11 DEF_BIT_12 #define GPIOB_LED12 DEF_BIT_13 #define GPIOB_LED13 DEF_BIT_14 #define GPIOB_LED14 DEF_BIT_15 #define GPIOB_LEDS (GPIOB_LED7 | GPIOB_LED8 | GPIOB_LED9 | GPIOB_LED10 | GPIOB_LED11 | GPIOB_LED12 | GPIOB_LED13 | GPIOB_LED14) /* ---------------------- GPIOC Pins ---------------------- */ #define GPIOC_LCD_DB4 DEF_BIT_00 #define GPIOC_LCD_DB5 DEF_BIT_01 #define GPIOC_LCD_DB6 DEF_BIT_02 #define GPIOC_LCD_DB7 DEF_BIT_03 #define GPIOC_PB3 DEF_BIT_04 #define GPIOC_POT DEF_BIT_05 #define GPIOC_LED15 DEF_BIT_06 #define GPIOC_LED16 DEF_BIT_07 #define GPIOC_LCD_RS DEF_BIT_08 #define GPIOC_LCD_RW DEF_BIT_09 #define GPIOC_USART3_TX DEF_BIT_10 #define GPIOC_USART3_RX DEF_BIT_11 #define GPIOC_LCD_E DEF_BIT_12 #define GPIOC_PB1 DEF_BIT_13 #define GPIOC_LCD_DB (GPIOC_LCD_DB4 | GPIOC_LCD_DB5 | GPIOC_LCD_DB6 | GPIOC_LCD_DB7) #define GPIOC_LEDS (GPIOC_LED15 | GPIOC_LED16) /* ********************************************************************************************************* * LOCAL CONSTANTS ********************************************************************************************************* */ /* ********************************************************************************************************* * LOCAL DATA TYPES ********************************************************************************************************* */ /* ********************************************************************************************************* * LOCAL TABLES ********************************************************************************************************* */ /* ********************************************************************************************************* * LOCAL GLOBAL VARIABLES ********************************************************************************************************* */ /* ********************************************************************************************************* * LOCAL FUNCTION PROTOTYPES ********************************************************************************************************* */ static void Tmr_TickInit (void); static void LED_Init (void); static void PB_Init (void); static void LCD_LightInit (void); static void ADCS_Init (void); #ifdef DISP_MODULE_PRESENT static void DispE_High (void); static void DispE_Low (void); static void DispRW_Low (void); static void DispTmr_Init (void); static void DispTmr_Dly (CPU_INT32U dly); #endif /* ********************************************************************************************************* * LOCAL CONFIGURATION ERRORS ********************************************************************************************************* */ /* ****************************************************************************************************************************** ****************************************************************************************************************************** ** Global Functions ****************************************************************************************************************************** ****************************************************************************************************************************** */ /* ********************************************************************************************************* * BSP INITIALIZATION * * Description : This function should be called by your application code before you make use of any of the * functions found in this module. * * Arguments : none ********************************************************************************************************* */ void BSP_Init (void) { RCC_DeInit(); RCC_HSEConfig(RCC_HSE_ON); RCC_WaitForHSEStartUp(); RCC_HCLKConfig(RCC_SYSCLK_Div1); RCC_PCLK2Config(RCC_HCLK_Div1); RCC_PCLK1Config(RCC_HCLK_Div2); RCC_ADCCLKConfig(RCC_PCLK2_Div6); FLASH_SetLatency(FLASH_Latency_2); FLASH_PrefetchBufferCmd(FLASH_PrefetchBuffer_Enable); RCC_PLLConfig(RCC_PLLSource_HSE_Div1, RCC_PLLMul_9); RCC_PLLCmd(ENABLE); while (RCC_GetFlagStatus(RCC_FLAG_PLLRDY) == RESET) { ; } RCC_SYSCLKConfig(RCC_SYSCLKSource_PLLCLK); while (RCC_GetSYSCLKSource() != 0x08) { ; } LED_Init(); /* Initialize the I/Os for the LED controls */ PB_Init(); /* Initialize the I/Os for the PB controls */ LCD_LightInit(); /* Initialize the I/Os for the LCD backlight */ ADCS_Init(); /* Initialize the ADC for the potentiometer */ Tmr_TickInit(); /* Initialize the uC/OS-II tick interrupt */ } /* ********************************************************************************************************* * DISABLE ALL INTERRUPTS * * Description : This function disables all interrupts from the interrupt controller. * * Arguments : None. * * Returns : None. ********************************************************************************************************* */ void BSP_IntDisAll (void) { CPU_IntDis(); } /* ********************************************************************************************************* * GET THE CPU CLOCK FREQUENCY * * Description: This function reads CPU registers to determine the CPU clock frequency of the chip in KHz. * * Argument(s): None. * * Returns : The CPU clock frequency, in Hz. ********************************************************************************************************* */ CPU_INT32U BSP_CPU_ClkFreq (void) { static RCC_ClocksTypeDef rcc_clocks; RCC_GetClocksFreq(&rcc_clocks); return ((CPU_INT32U)rcc_clocks.HCLK_Frequency); } /* ****************************************************************************************************************************** ****************************************************************************************************************************** ** PB, LED, LCD Backlight, and ADC Functions ****************************************************************************************************************************** ****************************************************************************************************************************** */ /* ********************************************************************************************************* * PB INITIALIZATION * * Description : This function initializes the board's PB * * Arguments : none * * Returns ; none ********************************************************************************************************* */ static void PB_Init (void) { GPIO_InitTypeDef gpio_init; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); gpio_init.GPIO_Pin = GPIOA_PB_WAKEUP; gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &gpio_init); gpio_init.GPIO_Pin = GPIOB_PB2; gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOB, &gpio_init); gpio_init.GPIO_Pin = GPIOC_PB1 | GPIOC_PB3; gpio_init.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOC, &gpio_init); } /* ********************************************************************************************************* * GET 'PUSH BUTTON' STATUS * * Description : This function is used to get the status of any push button on the board. * * Arguments : push_button is the number of the push button to probe * 1 probe the PB1 push button * 2 probe the PB2 push button * 3 probe the PB3 push button * 4 probe the wakeup push button * * Returns : DEF_TRUE if the push button is pressed * DEF_FALSE if the push button is not pressed ********************************************************************************************************* */ CPU_BOOLEAN PB_GetStatus (CPU_INT08U pb) { CPU_BOOLEAN status; CPU_INT32U pin; status = DEF_FALSE; switch (pb) { case 1: pin = GPIO_ReadInputDataBit(GPIOC, GPIOC_PB1); if (pin > 0) { status = DEF_TRUE; } break; case 2: pin = GPIO_ReadInputDataBit(GPIOB, GPIOB_PB2); if (pin > 0) { status = DEF_TRUE; } break; case 3: pin = GPIO_ReadInputDataBit(GPIOC, GPIOC_PB3); if (pin > 0) { status = DEF_TRUE; } break; case 4: pin = GPIO_ReadInputDataBit(GPIOA, GPIOA_PB_WAKEUP); if (pin > 0) { status = DEF_TRUE; } break; default: break; } return (status); } /* ********************************************************************************************************* * LED INITIALIZATION * * Description : This function initializes the board's LEDs * * Arguments : none * * Returns : none ********************************************************************************************************* */ static void LED_Init (void) { GPIO_InitTypeDef gpio_init; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); gpio_init.GPIO_Pin = GPIOA_LEDS; gpio_init.GPIO_Speed = GPIO_Speed_50MHz; gpio_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOA, &gpio_init); gpio_init.GPIO_Pin = GPIOB_LEDS; gpio_init.GPIO_Speed = GPIO_Speed_50MHz; gpio_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOB, &gpio_init); gpio_init.GPIO_Pin = GPIOC_LEDS; gpio_init.GPIO_Speed = GPIO_Speed_50MHz; gpio_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOC, &gpio_init); } /* ********************************************************************************************************* * LED ON * * Description : This function is used to control any or all the LEDs on the board. * * Arguments : led is the number of the LED to control * 0 indicates that you want ALL the LEDs to be ON * 1 turns ON user LED1 on the board * 2 turns ON user LED2 on the board * . * . * . * 16 turns ON user LED16 on the board * * Returns : none ********************************************************************************************************* */ void LED_On (CPU_INT08U led) { switch (led) { case 0: GPIO_ResetBits(GPIOA, GPIOA_LEDS); GPIO_ResetBits(GPIOB, GPIOB_LEDS); GPIO_ResetBits(GPIOC, GPIOC_LEDS); break; case 1: GPIO_ResetBits(GPIOA, GPIOA_LED1); break; case 2: GPIO_ResetBits(GPIOA, GPIOA_LED2); break; case 3: GPIO_ResetBits(GPIOA, GPIOA_LED3); break; case 4: GPIO_ResetBits(GPIOA, GPIOA_LED4); break; case 5: GPIO_ResetBits(GPIOA, GPIOA_LED5); break; case 6: GPIO_ResetBits(GPIOA, GPIOA_LED6); break; case 7: GPIO_ResetBits(GPIOB, GPIOB_LED7); break; case 8: GPIO_ResetBits(GPIOB, GPIOB_LED8); break; case 9: GPIO_ResetBits(GPIOB, GPIOB_LED9); break; case 10: GPIO_ResetBits(GPIOB, GPIOB_LED10); break; case 11: GPIO_ResetBits(GPIOB, GPIOB_LED11); break; case 12: GPIO_ResetBits(GPIOB, GPIOB_LED12); break; case 13: GPIO_ResetBits(GPIOB, GPIOB_LED13); break; case 14: GPIO_ResetBits(GPIOB, GPIOB_LED14); break; case 15: GPIO_ResetBits(GPIOC, GPIOC_LED15); break; case 16: GPIO_ResetBits(GPIOC, GPIOC_LED16); break; default: break; } } /* ********************************************************************************************************* * LED OFF * * Description : This function is used to control any or all the LEDs on the board. * * Arguments : led is the number of the LED to turn OFF * 0 indicates that you want ALL the LEDs to be OFF * 1 turns OFF user LED1 on the board * 2 turns OFF user LED2 on the board * . * . * . * 16 turns OFF user LED16 on the board * * Returns ; none ********************************************************************************************************* */ void LED_Off (CPU_INT08U led) { switch (led) { case 0: GPIO_SetBits(GPIOA, GPIOA_LEDS); GPIO_SetBits(GPIOB, GPIOB_LEDS); GPIO_SetBits(GPIOC, GPIOC_LEDS); break; case 1: GPIO_SetBits(GPIOA, GPIOA_LED1); break; case 2: GPIO_SetBits(GPIOA, GPIOA_LED2); break; case 3: GPIO_SetBits(GPIOA, GPIOA_LED3); break; case 4: GPIO_SetBits(GPIOA, GPIOA_LED4); break; case 5: GPIO_SetBits(GPIOA, GPIOA_LED5); break; case 6: GPIO_SetBits(GPIOA, GPIOA_LED6); break; case 7: GPIO_SetBits(GPIOB, GPIOB_LED7); break; case 8: GPIO_SetBits(GPIOB, GPIOB_LED8); break; case 9: GPIO_SetBits(GPIOB, GPIOB_LED9); break; case 10: GPIO_SetBits(GPIOB, GPIOB_LED10); break; case 11: GPIO_SetBits(GPIOB, GPIOB_LED11); break; case 12: GPIO_SetBits(GPIOB, GPIOB_LED12); break; case 13: GPIO_SetBits(GPIOB, GPIOB_LED13); break; case 14: GPIO_SetBits(GPIOB, GPIOB_LED14); break; case 15: GPIO_SetBits(GPIOC, GPIOC_LED15); break; case 16: GPIO_SetBits(GPIOC, GPIOC_LED16); break; default: break; }} /* ********************************************************************************************************* * LED TOGGLE * * Description : This function is used to toggle any or all the LEDs on the board. * * Arguments : led is the number of the LED to control * 0 indicates that you want to toggle ALL the LEDs * 1 toggles user LED on the board * * Returns ; none ********************************************************************************************************* */ void LED_Toggle (CPU_INT08U led) { CPU_INT32U pins; switch (led) { case 0: pins = GPIO_ReadOutputData(GPIOA); pins ^= GPIOA_LEDS; GPIO_SetBits( GPIOA, pins & GPIOA_LEDS); GPIO_ResetBits(GPIOA, (~pins) & GPIOA_LEDS); pins = GPIO_ReadOutputData(GPIOB); pins ^= GPIOB_LEDS; GPIO_SetBits( GPIOB, pins & GPIOB_LEDS); GPIO_ResetBits(GPIOB, (~pins) & GPIOB_LEDS); pins = GPIO_ReadOutputData(GPIOA); pins ^= GPIOC_LEDS; GPIO_SetBits( GPIOC, pins & GPIOC_LEDS); GPIO_ResetBits(GPIOC, (~pins) & GPIOC_LEDS); break; case 1: case 2: case 3: case 4: pins = GPIO_ReadOutputData(GPIOA); if ((pins & (1 << (led + 3))) == 0) { GPIO_SetBits( GPIOA, (1 << (led + 3))); } else { GPIO_ResetBits(GPIOA, (1 << (led + 3))); } break; case 5: case 6: pins = GPIO_ReadOutputData(GPIOA); if ((pins & (1 << (led + 4))) == 0) { GPIO_SetBits( GPIOA, (1 << (led + 4))); } else { GPIO_ResetBits(GPIOA, (1 << (led + 4))); } break; case 7: case 8: pins = GPIO_ReadOutputData(GPIOB); if ((pins & (1 << (led - 1))) == 0) { GPIO_SetBits( GPIOB, (1 << (led - 1))); } else { GPIO_ResetBits(GPIOB, (1 << (led - 1))); } case 9: case 10: case 11: case 12: case 13: case 14: pins = GPIO_ReadOutputData(GPIOB); if ((pins & (1 << (led + 1))) == 0) { GPIO_SetBits( GPIOB, (1 << (led + 1))); } else { GPIO_ResetBits(GPIOB, (1 << (led + 1))); } break; case 15: case 16: pins = GPIO_ReadOutputData(GPIOC); if ((pins & (1 << (led - 9))) == 0) { GPIO_SetBits( GPIOC, (1 << (led - 9))); } else { GPIO_ResetBits(GPIOC, (1 << (led - 9))); } break; default: break; } } /* ********************************************************************************************************* * LCD LIGHT INITIALIZATION * * Description : This function initializes the LCD backlight. * * Arguments : None. * * Returns : None. ********************************************************************************************************* */ static void LCD_LightInit (void) { GPIO_InitTypeDef gpio_init; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); gpio_init.GPIO_Pin = GPIOB_LCD_LIGHT; gpio_init.GPIO_Speed = GPIO_Speed_50MHz; gpio_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOB, &gpio_init); } /* ********************************************************************************************************* * LCD LIGHT ON * * Description : This function is used to turn on the LCD backlight. * * Arguments : None. * * Returns : None. ********************************************************************************************************* */ void LCD_LightOn (void) { GPIO_ResetBits(GPIOB, GPIOB_LCD_LIGHT); } /* ********************************************************************************************************* * LCD LIGHT OFF * * Description : This function is used to turn off the LCD backlight. * * Arguments : None. * * Returns : None. ********************************************************************************************************* */ void LCD_LightOff (void) { GPIO_SetBits(GPIOB, GPIOB_LCD_LIGHT); } /* ********************************************************************************************************* * LCD LIGHT TOGGLE * * Description : This function is used to toggle the LCD backlight * * Arguments : led is the number of the LED to control * 0 indicates that you want to toggle ALL the LEDs * 1 toggles user LED on the board * * Returns ; none ********************************************************************************************************* */ void LCD_LightToggle (void) { CPU_INT32U pins; pins = GPIO_ReadOutputData(GPIOB); if ((pins & GPIOB_LCD_LIGHT) == 0) { GPIO_SetBits( GPIOB, GPIOB_LCD_LIGHT); } else { GPIO_ResetBits(GPIOB, GPIOB_LCD_LIGHT); } } /* ********************************************************************************************************* * ADC INITIALIZATION * * Description : This function initializes the board's ADC * * Arguments : none * * Returns : none ********************************************************************************************************* */ static void ADCS_Init (void) { ADC_InitTypeDef adc_init; GPIO_InitTypeDef gpio_init; RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE); RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE); gpio_init.GPIO_Pin = GPIO_Pin_5; gpio_init.GPIO_Mode = GPIO_Mode_AIN; GPIO_Init(GPIOC, &gpio_init); adc_init.ADC_Mode = ADC_Mode_Independent; adc_init.ADC_ScanConvMode = DISABLE; adc_init.ADC_ContinuousConvMode = ENABLE; adc_init.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None; adc_init.ADC_DataAlign = ADC_DataAlign_Right; adc_init.ADC_NbrOfChannel = 1; ADC_Init(ADC1, &adc_init); ADC_RegularChannelConfig(ADC1, ADC_Channel_15, 1, ADC_SampleTime_13Cycles5); ADC_Cmd(ADC1, ENABLE); ADC_SoftwareStartConvCmd(ADC1, ENABLE); } /* ********************************************************************************************************* * ADC STATUS * * Description : This function initializes the board's ADC * * Arguments : adc is the number of the ADC to probe. For this board, the only legitimate value is 1. * * Returns : The numerator of the binary fraction representing the result of the latest ADC conversion. * This value will be a 12-bit value between 0x0000 and 0x0FFF, inclusive. ********************************************************************************************************* */ CPU_INT16U ADC_GetStatus (CPU_INT08U adc) { CPU_INT16U result; result = 0; if (adc == 1) { result = ADC_GetConversionValue(ADC1); } return (result); } /* ****************************************************************************************************************************** ****************************************************************************************************************************** ** uC/LCD Display Functions ****************************************************************************************************************************** ****************************************************************************************************************************** */ /* ********************************************************************************************************* * WRITE DATA TO DISPLAY DEVICE * * Description : This function sends a single BYTE to the display device. * * Arguments : 'data' is the BYTE to send to the display device * * Returns : none * * Notes : (1) The LPC2148 evaluation board uses a 4 bit interface. * If an 8 bit interface is used. BSP_IO_Init() and DispDataWr() will need * to be modified to reflect the new databus. In 8 bit mode, DispDataWrOneNibble() * is not necessary. ********************************************************************************************************* */ #ifdef DISP_MODULE_PRESENT void DispDataWr (CPU_INT08U data) { CPU_INT32U value; DispRW_Low(); /* Set R/W write LOW to write to the LCD module */ DispE_High(); /* Write the UPPER nibble to the LCD module */ value = ((data >> 4) & 0x0000000F); GPIO_SetBits(GPIOC, value); value = (~(data >> 4) & 0x0000000F); GPIO_ResetBits(GPIOC, value); DispDly_uS(1000); DispE_Low(); DispDly_uS(1000); /* Write the LOWER nibble to the LCD module */ DispE_High(); value = (data & 0x0000000F); GPIO_SetBits(GPIOC, value); value = (~data & 0x0000000F); GPIO_ResetBits(GPIOC, value); DispDly_uS(1000); DispE_Low(); } #if DISP_BUS_WIDTH == 4 void DispDataWrOneNibble (CPU_INT08U data) { CPU_INT32U value; // wait_while_busy(); DispRW_Low(); /* Set R/W write LOW to write to the LCD module */ DispE_High(); /* Write the UPPER nibble to the LCD module */ value = ((data >> 4) & 0x0F); GPIO_SetBits(GPIOC, value); value = (~(data >> 4) & 0x0F); GPIO_ResetBits(GPIOC, value); DispDly_uS(1000); DispE_Low(); } #endif #endif /* ********************************************************************************************************* * DELAY * * Description : This function is called to delay for the specified number of microseconds. * * Arguments : us Number of microseconds * * Returns : none ********************************************************************************************************* */ #ifdef DISP_MODULE_PRESENT void DispDly_uS (CPU_INT32U us) { DispTmr_Dly(us); } #endif /* ********************************************************************************************************* * INITIALIZE DISPLAY DRIVER I/O PORTS * * Description : This initializes the I/O ports used by the display driver. * * Arguments : none * * Returns : none ********************************************************************************************************* */ #ifdef DISP_MODULE_PRESENT void DispInitPort (void) { GPIO_InitTypeDef gpio_init; gpio_init.GPIO_Pin = GPIOC_LCD_DB4 | GPIOC_LCD_DB5 | GPIOC_LCD_DB6 | GPIOC_LCD_DB7 | GPIOC_LCD_RS | GPIOC_LCD_RW | GPIOC_LCD_E; gpio_init.GPIO_Speed = GPIO_Speed_50MHz; gpio_init.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOC, &gpio_init); DispTmr_Init(); } #endif /* ********************************************************************************************************* * SELECT COMMAND OR DATA REGISTER * * Description : This changes the Register Select control line to the LCD controller. * * Arguments : none * * Returns : none ********************************************************************************************************* */ #ifdef DISP_MODULE_PRESENT void DispSel (CPU_INT08U sel) { if (sel == DISP_SEL_CMD_REG) { GPIO_ResetBits(GPIOC, GPIOC_LCD_RS); /* Select the command register (RS low) */ } else { GPIO_SetBits(GPIOC, GPIOC_LCD_RS); /* Select the data register (RS high) */ } } #endif /* ********************************************************************************************************* * DISPLAY CONTROL LINE FUNCTIONS ********************************************************************************************************* */ #ifdef DISP_MODULE_PRESENT static void DispE_High (void) { GPIO_SetBits(GPIOC, GPIOC_LCD_E); } static void DispE_Low (void) { GPIO_ResetBits(GPIOC, GPIOC_LCD_E); } static void DispRW_Low (void) { GPIO_ResetBits(GPIOC, GPIOC_LCD_RW); } #endif /* ********************************************************************************************************* * DispTmr_Dly() * * Description : Uses a timer to produce a short delay * * Arguments : dly The number of microseconds for which to delay * * Returns : None ********************************************************************************************************* */ #ifdef DISP_MODULE_PRESENT static void DispTmr_Init (void) { TIM_TimeBaseInitTypeDef tim_init; RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); tim_init.TIM_Period = 0xFFFF; tim_init.TIM_Prescaler = 0x00; tim_init.TIM_ClockDivision = 0x0; tim_init.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM3, &tim_init); TIM_SetCounter(TIM3, 0); TIM_PrescalerConfig(TIM3, 8, TIM_PSCReloadMode_Immediate); TIM_Cmd(TIM3, ENABLE); } static void DispTmr_Dly (CPU_INT32U us) { CPU_INT32U original_val; CPU_INT32U current_val; CPU_INT32U clk_per_us; CPU_INT32U clks; original_val = TIM_GetCounter(TIM3); clk_per_us = BSP_CPU_ClkFreq() / 1000000 + 1; clks = clk_per_us * us; if (clks > 32768 / 2) { clks = 32768 / 2; } current_val = TIM_GetCounter(TIM3); while ((current_val - original_val) < clks) { current_val = TIM_GetCounter(TIM3); } } #endif /* ****************************************************************************************************************************** ****************************************************************************************************************************** * uC/Probe Plug-In for uC/OS-II Functions ****************************************************************************************************************************** ****************************************************************************************************************************** */ /* ********************************************************************************************************* * INITIALIZE TIMER FOR uC/Probe Plug-In for uC/OS-II * * Description : This function is called to by uC/Probe Plug-In for uC/OS-II to initialize the * free running timer that is used to make time measurements. * * Arguments : none * * Returns : none * * Note(s) : This function is EMPTY because the timer is initialized elsewhere. ********************************************************************************************************* */ #if (uC_PROBE_OS_PLUGIN > 0) && (OS_PROBE_HOOKS_EN == 1) void OSProbe_TmrInit (void) { TIM_TimeBaseInitTypeDef tim_init; #if (OS_PROBE_TIMER_SEL == 2) RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE); tim_init.TIM_Period = 0xFFFF; tim_init.TIM_Prescaler = 0x00; tim_init.TIM_ClockDivision = 0x0; tim_init.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM2, &tim_init); TIM_SetCounter(TIM2, 0); TIM_PrescalerConfig(TIM2, 256, TIM_PSCReloadMode_Immediate); TIM_Cmd(TIM2, ENABLE); #elif (OS_PROBE_TIMER_SEL == 3) RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM3, ENABLE); tim_init.TIM_Period = 0xFFFF; tim_init.TIM_Prescaler = 0x00; tim_init.TIM_ClockDivision = 0x0; tim_init.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM3, &tim_init); TIM_SetCounter(TIM3, 0); TIM_PrescalerConfig(TIM3, 256, TIM_PSCReloadMode_Immediate); TIM_Cmd(TIM3, ENABLE); #elif (OS_PROBE_TIMER_SEL == 4) RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE); tim_init.TIM_Period = 0xFFFF; tim_init.TIM_Prescaler = 0x00; tim_init.TIM_ClockDivision = 0x0; tim_init.TIM_CounterMode = TIM_CounterMode_Up; TIM_TimeBaseInit(TIM4, &tim_init); TIM_SetCounter(TIM4, 0); TIM_PrescalerConfig(TIM4, 256, TIM_PSCReloadMode_Immediate); TIM_Cmd(TIM4, ENABLE); #endif } #endif /* ********************************************************************************************************* * READ TIMER FOR uC/Probe Plug-In for uC/OS-II * * Description : This function is called to read the current counts of a 16 bit free running timer. * * Arguments : none * * Returns : The 16 or 32 bit count of the timer assuming the timer is an UP counter. ********************************************************************************************************* */ #if (uC_PROBE_OS_PLUGIN > 0) && (OS_PROBE_HOOKS_EN == 1) CPU_INT32U OSProbe_TmrRd (void) { #if (OS_PROBE_TIMER_SEL == 2) return ((CPU_INT32U)TIM_GetCounter(TIM2)); #elif (OS_PROBE_TIMER_SEL == 3) return ((CPU_INT32U)TIM_GetCounter(TIM3)); #elif (OS_PROBE_TIMER_SEL == 4) return ((CPU_INT32U)TIM_GetCounter(TIM4)); #endif } #endif /* ****************************************************************************************************************************** ****************************************************************************************************************************** ** uC/OS-II Timer Functions ****************************************************************************************************************************** ****************************************************************************************************************************** */ /* ********************************************************************************************************* * TICKER INITIALIZATION * * Description : This function is called to initialize uC/OS-II's tick source (typically a timer generating * interrupts every 1 to 100 mS). * * Arguments : none * * Note(s) : 1) The timer is setup for output compare mode BUT 'MUST' also 'freerun' so that the timer * count goes from 0x00000000 to 0xFFFFFFFF to ALSO be able to read the free running count. * The reason this is needed is because we use the free-running count in uC/OS-View. ********************************************************************************************************* */ static void Tmr_TickInit (void) { RCC_ClocksTypeDef rcc_clocks; CPU_INT32U cnts; RCC_GetClocksFreq(&rcc_clocks); cnts = (CPU_INT32U)rcc_clocks.HCLK_Frequency / OS_TICKS_PER_SEC; SysTick_SetReload(cnts); SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK); SysTick_CounterCmd(SysTick_Counter_Enable); SysTick_ITConfig(ENABLE); } static void delay (int cnt) { while (cnt--); } unsigned char wait_while_busy (void) { unsigned char status; do { status = lcd_read_status(); } while (status & 0x80); return (status); } /******************************************************************************* * Read status of LCD controller * * Parameter: none * * Return: Status byte contains busy flag and address pointer * *******************************************************************************/ unsigned char lcd_read_status (void) { unsigned char status; LCD_DATA_DIR_IN LCD_RS(0) LCD_RW(1) delay(10); LCD_E(1) delay(10); status = LCD_DATA_IN << 4; LCD_E(0) delay(10); LCD_E(1) delay(10); status |= LCD_DATA_IN; LCD_E(0) LCD_DATA_DIR_OUT return (status); } /* ********************************************************************************************************* * TIMER IRQ HANDLER * * Description : This function handles the timer interrupt that is used to generate TICKs for uC/OS-II. * * Arguments : none * * Note(s) : 1) The timer is 'reloaded' with the count at compare + the time for the next interrupt. * Since we are using 'unsigned' integer math, overflows are irrelevant. ********************************************************************************************************* */ void Tmr_TickISR_Handler (void) { OS_CPU_SR cpu_sr; OS_ENTER_CRITICAL(); /* Tell uC/OS-II that we are starting an ISR */ OSIntNesting++; OS_EXIT_CRITICAL(); OSTimeTick(); /* Call uC/OS-II's OSTimeTick() */ OSIntExit(); /* Tell uC/OS-II that we are leaving the ISR */ } /******************************************************************************/