void analogin_init(analogin_t *obj, PinName pin) { uint32_t function = (uint32_t)NC; // ADC Internal Channels "pins" (Temperature, Vref, Vbat, ...) // are described in PinNames.h and PeripheralPins.c // Pin value must be between 0xF0 and 0xFF if ((pin < 0xF0) || (pin >= 0x100)) { // Normal channels // Get the peripheral name from the pin and assign it to the object obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC); // Get the functions (adc channel) from the pin and assign it to the object function = pinmap_function(pin, PinMap_ADC); // Configure GPIO pinmap_pinout(pin, PinMap_ADC); } else { // Internal channels obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC_Internal); function = pinmap_function(pin, PinMap_ADC_Internal); // No GPIO configuration for internal channels } MBED_ASSERT(obj->handle.Instance != (ADC_TypeDef *)NC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); // Save pin number for the read function obj->pin = pin; // Configure ADC object structures obj->handle.State = HAL_ADC_STATE_RESET; obj->handle.Init.OversamplingMode = DISABLE; obj->handle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV1; obj->handle.Init.Resolution = ADC_RESOLUTION_12B; obj->handle.Init.SamplingTime = ADC_SAMPLETIME_160CYCLES_5; obj->handle.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD; obj->handle.Init.DataAlign = ADC_DATAALIGN_RIGHT; obj->handle.Init.ContinuousConvMode = DISABLE; obj->handle.Init.DiscontinuousConvMode = DISABLE; obj->handle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIG_EDGE_NONE; obj->handle.Init.ExternalTrigConv = ADC_EXTERNALTRIG0_T6_TRGO; // Not used here obj->handle.Init.DMAContinuousRequests = DISABLE; obj->handle.Init.EOCSelection = EOC_SINGLE_CONV; obj->handle.Init.Overrun = OVR_DATA_OVERWRITTEN; obj->handle.Init.LowPowerAutoWait = ENABLE; obj->handle.Init.LowPowerFrequencyMode = DISABLE; // To be enabled only if ADC clock < 2.8 MHz obj->handle.Init.LowPowerAutoPowerOff = DISABLE; __HAL_RCC_ADC1_CLK_ENABLE(); if (HAL_ADC_Init(&obj->handle) != HAL_OK) { error("Cannot initialize ADC"); } if (!HAL_ADCEx_Calibration_GetValue(&obj->handle, ADC_SINGLE_ENDED)) { HAL_ADCEx_Calibration_Start(&obj->handle, ADC_SINGLE_ENDED); } __HAL_ADC_ENABLE(&obj->handle); }
void spi_init(spi_t *obj_in, PinName mosi, PinName miso, PinName sclk, PinName ssel) { spi_obj_t *obj = OBJ_P(obj_in); uint32_t spi = (uint32_t)NC; en_clk_dst_t clock; if (mosi != NC) { spi = pinmap_merge(spi, pinmap_peripheral(mosi, PinMap_SPI_MOSI)); clock = CY_PIN_CLOCK(pinmap_function(mosi, PinMap_SPI_MOSI)); } if (miso != NC) { spi = pinmap_merge(spi, pinmap_peripheral(miso, PinMap_SPI_MISO)); clock = CY_PIN_CLOCK(pinmap_function(miso, PinMap_SPI_MISO)); } if (sclk != NC) { spi = pinmap_merge(spi, pinmap_peripheral(sclk, PinMap_SPI_SCLK)); clock = CY_PIN_CLOCK(pinmap_function(sclk, PinMap_SPI_SCLK)); } if (ssel != NC) { spi = pinmap_merge(spi, pinmap_peripheral(ssel, PinMap_SPI_SSEL)); clock = CY_PIN_CLOCK(pinmap_function(ssel, PinMap_SPI_SSEL)); } if (spi != (uint32_t)NC) { obj->base = (CySCB_Type*)spi; obj->spi_id = ((SPIName)spi - SPI_0) / (SPI_1 - SPI_0); obj->pin_mosi = mosi; obj->pin_miso = miso; obj->pin_sclk = sclk; obj->pin_ssel = ssel; obj->data_bits = 8; obj->clock = clock; obj->div_num = CY_INVALID_DIVIDER; obj->ms_mode = CY_SCB_SPI_MASTER; #if DEVICE_SPI_ASYNCH obj->pending = PENDING_NONE; obj->events = 0; obj->tx_buffer = NULL; obj->tx_buffer_size = 0; obj->rx_buffer = NULL; obj->rx_buffer_size = 0; #endif // DEVICE_SPI_ASYNCH spi_init_clock(obj, SPI_DEFAULT_SPEED); spi_init_pins(obj); spi_init_peripheral(obj); #if DEVICE_SLEEP && DEVICE_LOWPOWERTIMER obj->pm_callback_handler.callback = spi_pm_callback; obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP; obj->pm_callback_handler.skipMode = 0; obj->pm_callback_handler.callbackParams = &obj->pm_callback_params; obj->pm_callback_params.base = obj->base; obj->pm_callback_params.context = obj; if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) { error("PM callback registration failed!"); } #endif // DEVICE_SLEEP && DEVICE_LOWPOWERTIMER } else { error("SPI pinout mismatch. Requested Rx and Tx pins can't be used for the same SPI communication."); } }
/* * Initializes i/o pins for i2c sda/scl. */ static void i2c_init_pins(i2c_obj_t *obj) { /* MBED driver reserves pins for I2C as Ditigal IO while doing I2C error * recovery in constructor. */ pin_function(obj->pin_sda, pinmap_function(obj->pin_sda, PinMap_I2C_SDA)); pin_function(obj->pin_scl, pinmap_function(obj->pin_scl, PinMap_I2C_SCL)); }
/** Initialize the analogout peripheral * * Configures the pin used by analogout. * @param obj The analogout object to initialize * @param pin The analogout pin name */ void analogout_init(dac_t *obj, PinName pin) { /* get the peripheral name from the pin and assign it to the object */ obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC); MBED_ASSERT(obj->dac != (DACName)NC); /* get the pin function and assign the used channel to the object */ uint32_t function = pinmap_function(pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = GD_PIN_CHANNEL_GET(function); MBED_ASSERT(obj->channel <= DAC1); /* configure GPIO */ pinmap_pinout(pin, PinMap_DAC); /* save the pin for future use */ obj->pin = pin; /* enable DAC clock */ rcu_periph_clock_enable(RCU_DAC); /* configure DAC */ dac_wave_mode_config(obj->channel, DAC_WAVE_DISABLE); dac_trigger_disable(obj->channel); dac_output_buffer_enable(obj->channel); analogout_write_u16(obj, 0); }
void pwmout_init(pwmout_t* obj, PinName pin) { // Get the peripheral name from the pin and assign it to the object obj->pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM); MBED_ASSERT(obj->pwm != (PWMName)NC); // Get the functions (timer channel, (non)inverted) from the pin and assign it to the object uint32_t function = pinmap_function(pin, PinMap_PWM); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); obj->inverted = STM_PIN_INVERTED(function); // Enable TIM clock #if defined(TIM1_BASE) if (obj->pwm == PWM_1) __HAL_RCC_TIM1_CLK_ENABLE(); #endif #if defined(TIM2_BASE) if (obj->pwm == PWM_2) __HAL_RCC_TIM2_CLK_ENABLE(); #endif #if defined(TIM3_BASE) if (obj->pwm == PWM_3) __HAL_RCC_TIM3_CLK_ENABLE(); #endif #if defined(TIM4_BASE) if (obj->pwm == PWM_4) __HAL_RCC_TIM4_CLK_ENABLE(); #endif #if defined(TIM5_BASE) if (obj->pwm == PWM_5) __HAL_RCC_TIM5_CLK_ENABLE(); #endif #if defined(TIM8_BASE) if (obj->pwm == PWM_8) __HAL_RCC_TIM8_CLK_ENABLE(); #endif #if defined(TIM9_BASE) if (obj->pwm == PWM_9) __HAL_RCC_TIM9_CLK_ENABLE(); #endif #if defined(TIM10_BASE) if (obj->pwm == PWM_10) __HAL_RCC_TIM10_CLK_ENABLE(); #endif #if defined(TIM11_BASE) if (obj->pwm == PWM_11) __HAL_RCC_TIM11_CLK_ENABLE(); #endif #if defined(TIM12_BASE) if (obj->pwm == PWM_12) __HAL_RCC_TIM12_CLK_ENABLE(); #endif #if defined(TIM13_BASE) if (obj->pwm == PWM_13) __HAL_RCC_TIM13_CLK_ENABLE(); #endif #if defined(TIM14_BASE) if (obj->pwm == PWM_14) __HAL_RCC_TIM14_CLK_ENABLE(); #endif // Configure GPIO pinmap_pinout(pin, PinMap_PWM); obj->pin = pin; obj->period = 0; obj->pulse = 0; obj->prescaler = 1; pwmout_period_us(obj, 20000); // 20 ms per default }
void pwmout_init(pwmout_t* obj, PinName pin) { // Get the peripheral name from the pin and assign it to the object obj->pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM); MBED_ASSERT(obj->pwm != (PWMName)NC); // Get the functions (timer channel, (non)inverted) from the pin and assign it to the object uint32_t function = pinmap_function(pin, PinMap_PWM); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); obj->inverted = STM_PIN_INVERTED(function); // Enable TIM clock if (obj->pwm == PWM_1) __TIM1_CLK_ENABLE(); if (obj->pwm == PWM_2) __TIM2_CLK_ENABLE(); if (obj->pwm == PWM_3) __TIM3_CLK_ENABLE(); // Configure GPIO pinmap_pinout(pin, PinMap_PWM); obj->pin = pin; obj->period = 0; obj->pulse = 0; obj->prescaler = 1; pwmout_period_us(obj, 20000); // 20 ms per default }
void pwmout_init(pwmout_t* obj, PinName pin) { // Get the peripheral name from the pin and assign it to the object obj->pwm = (PWMName)pinmap_peripheral(pin, PinMap_PWM); MBED_ASSERT(obj->pwm != (PWMName)NC); // Get the pin function and assign the used channel to the object uint32_t function = pinmap_function(pin, PinMap_PWM); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); obj->inverted = STM_PIN_INVERTED(function); // Enable TIM clock if (obj->pwm == PWM_2) __TIM2_CLK_ENABLE(); #if defined(TIM3_BASE) if (obj->pwm == PWM_3) __TIM3_CLK_ENABLE(); #endif if (obj->pwm == PWM_21) __TIM21_CLK_ENABLE(); #if defined(TIM22_BASE) if (obj->pwm == PWM_22) __TIM22_CLK_ENABLE(); #endif // Configure GPIO pinmap_pinout(pin, PinMap_PWM); obj->pin = pin; obj->period = 0; obj->pulse = 0; pwmout_period_us(obj, 20000); // 20 ms per default }
/** * @brief TIM MSP Initialization * This function configures the hardware resources used in this example: * - Peripheral's clock enable * - Peripheral's GPIO Configuration * @param htim: TIM handle pointer * @retval None */ void HAL_TIM_PWM_MspInit(TIM_HandleTypeDef *htim) { GPIO_InitTypeDef GPIO_InitStruct; GPIO_TypeDef *port; uint32_t function = pinmap_function(g_current_pin, PinMap_PWM); /*##-1- Enable peripherals and GPIO Clocks #################################*/ /* TIMx Peripheral clock enable */ timer_enable_clock(htim); /* Enable GPIO Channels Clock */ /* Enable GPIO clock ****************************************/ port = set_GPIO_Port_Clock(STM_PORT(g_current_pin)); /* Common configuration for all channels */ GPIO_InitStruct.Mode = GPIO_MODE_AF_PP; GPIO_InitStruct.Pull = GPIO_NOPULL; GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(function)); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(function); #endif /* STM32F1xx */ GPIO_InitStruct.Pin = STM_GPIO_PIN(g_current_pin); HAL_GPIO_Init(port, &GPIO_InitStruct); }
/** * @brief This function will set the PWM to the required value * @param port : the gpio port to use * @param pin : the gpio pin to use * @param clock_freq : frequency of the tim clock * @param period : period of the tim counter * @param value : the value to push on the PWM output * @param do_init : if set to 1 the initialization of the PWM is done * @retval None */ void pwm_start(PinName pin, uint32_t clock_freq, uint32_t period, uint32_t value, uint8_t do_init) { TIM_HandleTypeDef timHandle = {}; TIM_OC_InitTypeDef timConfig = {}; uint32_t timChannel; /* Compute the prescaler value to have TIM counter clock equal to clock_freq Hz */ timHandle.Instance = pinmap_peripheral(pin, PinMap_PWM); if (timHandle.Instance == NP) return; timHandle.Init.Prescaler = (uint32_t)(getTimerClkFreq(timHandle.Instance) / clock_freq) - 1; timHandle.Init.Period = period -1; timHandle.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1; timHandle.Init.CounterMode = TIM_COUNTERMODE_UP; #if !defined(STM32L0xx) && !defined(STM32L1xx) timHandle.Init.RepetitionCounter = 0; #endif timHandle.State= HAL_TIM_STATE_RESET; // TBC: is timHandle.State field should be saved ? if (do_init == 1) { g_current_pin = pin; if (HAL_TIM_PWM_Init(&timHandle) != HAL_OK) { return; } } timChannel = get_pwm_channel(pin); if (!IS_TIM_CHANNELS(timChannel)) return; //HAL_TIM_PWM_Stop(&timHandle, timChannel); /*##-2- Configure the PWM channels #########################################*/ /* Common configuration for all channels */ timConfig.OCMode = TIM_OCMODE_PWM1; timConfig.OCPolarity = TIM_OCPOLARITY_HIGH; timConfig.OCFastMode = TIM_OCFAST_DISABLE; #if !defined(STM32L0xx) && !defined(STM32L1xx) timConfig.OCNPolarity = TIM_OCNPOLARITY_HIGH; timConfig.OCNIdleState = TIM_OCNIDLESTATE_RESET; timConfig.OCIdleState = TIM_OCIDLESTATE_RESET; #endif timConfig.Pulse = value; if (HAL_TIM_PWM_ConfigChannel(&timHandle, &timConfig, timChannel) != HAL_OK) { /*##-2- Configure the PWM channels #########################################*/ return; } #if !defined(STM32L0xx) && !defined(STM32L1xx) if(STM_PIN_INVERTED(pinmap_function(pin, PinMap_PWM))) { HAL_TIMEx_PWMN_Start(&timHandle, timChannel); } else #endif { HAL_TIM_PWM_Start(&timHandle, timChannel); } }
/** Find the MUX function of input pin specific to given SERCOM index * * @param[in] pin Pin whose function is to be found out * @param[in] sercom_index SERCOM index * @return MUX function if found, else, NC */ uint32_t pinmap_function_sercom(PinName pin, uint32_t sercom_index) { uint32_t func = NC; uint32_t index; sercom_index &= 0x0F; if ((pin == NC) || (sercom_index >= SERCOM_INST_NUM)) { return NC; } index = pinmap_peripheral(pin, PinMap_SERCOM_PAD); if ((index & 0x0F) == sercom_index) { func = pinmap_function(pin, PinMap_SERCOM_PAD); return func; } index = pinmap_peripheral(pin, PinMap_SERCOM_PADEx); if ((index & 0x0F) == sercom_index) { func = pinmap_function(pin, PinMap_SERCOM_PADEx); return func; } return NC; }
void analogout_init(dac_t *obj, PinName pin) { uint32_t channel ; HAL_StatusTypeDef status; // Get the peripheral name (DAC_1, ...) from the pin and assign it to the object obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC); // Get the functions (dac channel) from the pin and assign it to the object uint32_t function = pinmap_function(pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); // Save the channel for the write and read functions obj->channel = STM_PIN_CHANNEL(function); if (obj->dac == (DACName)NC) { error("DAC pin mapping failed"); } // Configure GPIO pinmap_pinout(pin, PinMap_DAC); __GPIOA_CLK_ENABLE(); __DAC_CLK_ENABLE(); DacHandle.Instance = DAC; status = HAL_DAC_Init(&DacHandle); if (status != HAL_OK) { error("HAL_DAC_Init failed"); } sConfig.DAC_Trigger = DAC_TRIGGER_NONE; sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE; if (obj->channel == 1) { channel = DAC_CHANNEL_1; } else { channel = DAC_CHANNEL_2; } if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, channel) != HAL_OK) { error("HAL_DAC_ConfigChannel failed"); } if (HAL_DAC_Start(&DacHandle, channel) != HAL_OK) { error("HAL_DAC_Start failed"); } if (HAL_DAC_SetValue(&DacHandle, channel, DAC_ALIGN_12B_R, 0x000) != HAL_OK) { error("HAL_DAC_SetValue failed"); } }
void analogout_init(dac_t *obj, PinName pin) { DAC_ChannelConfTypeDef sConfig; // Get the peripheral name from the pin and assign it to the object obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC); MBED_ASSERT(obj->dac != (DACName)NC); // Get the pin function and assign the used channel to the object uint32_t function = pinmap_function(pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); // Configure GPIO pinmap_pinout(pin, PinMap_DAC); // Save the pin for future use obj->pin = pin; // Enable DAC clock if (obj->dac == DAC_1) { __DAC1_CLK_ENABLE(); } #if defined(DAC2) if (obj->dac == DAC_2) { __DAC2_CLK_ENABLE(); } #endif // Configure DAC DacHandle.Instance = (DAC_TypeDef *)(obj->dac); sConfig.DAC_Trigger = DAC_TRIGGER_NONE; sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_DISABLE; if (pin == PA_4) { HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DAC_CHANNEL_1); pa4_used = 1; } #if defined(DAC_CHANNEL_2) if (pin == PA_5) { HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DAC_CHANNEL_2); pa5_used = 1; } #endif if (pin == PA_6) { HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DAC_CHANNEL_1); } analogout_write_u16(obj, 0); }
/* * Initializes i/o pins for spi. */ static void spi_init_pins(spi_obj_t *obj) { bool conflict = false; conflict = cy_reserve_io_pin(obj->pin_sclk); if (!conflict) { pin_function(obj->pin_sclk, pinmap_function(obj->pin_sclk, PinMap_SPI_SCLK)); } if (obj->pin_mosi != NC) { if (!cy_reserve_io_pin(obj->pin_mosi)) { pin_function(obj->pin_mosi, pinmap_function(obj->pin_mosi, PinMap_SPI_MOSI)); } else { conflict = true; } } if (obj->pin_miso != NC) { if (!cy_reserve_io_pin(obj->pin_miso)) { pin_function(obj->pin_miso, pinmap_function(obj->pin_miso, PinMap_SPI_MISO)); } else { conflict = true; } } if (obj->pin_ssel != NC) { if (!cy_reserve_io_pin(obj->pin_ssel)) { pin_function(obj->pin_ssel, pinmap_function(obj->pin_ssel, PinMap_SPI_SSEL)); } else { conflict = true; } } if (conflict) { error("SPI pin reservation conflict."); } // Pin configuration in PinMap defaults to Master mode; revert for Slave. if (obj->ms_mode == CY_SCB_SPI_SLAVE) { pin_mode(obj->pin_sclk, PullNone); pin_mode(obj->pin_mosi, PullNone); pin_mode(obj->pin_miso, PushPull); pin_mode(obj->pin_ssel, PullNone); } }
/** Release the analogout object * * Note: This is not currently used in the mbed-drivers * @param obj The analogout object */ void analogout_free(dac_t *obj) { /* reset DAC and disable clock */ dac_deinit(); rcu_periph_clock_disable(RCU_DAC); /* configure GPIO */ /* get the pin function and assign the used channel to the object */ uint32_t function = pinmap_function(obj->pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); pin_function(obj->pin, function); }
void analogout_init(dac_t *obj, PinName pin) { DAC_ChannelConfTypeDef sConfig = {0}; // Get the peripheral name (DAC_1, ...) from the pin and assign it to the object obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC); // Get the functions (dac channel) from the pin and assign it to the object uint32_t function = pinmap_function(pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); // Save the channel for the write and read functions switch (STM_PIN_CHANNEL(function)) { case 1: obj->channel = DAC_CHANNEL_1; break; #if defined(DAC_CHANNEL_2) case 2: obj->channel = DAC_CHANNEL_2; break; #endif default: error("Unknown DAC channel"); break; } if (obj->dac == (DACName)NC) { error("DAC pin mapping failed"); } // Configure GPIO pinmap_pinout(pin, PinMap_DAC); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_DAC_CLK_ENABLE(); obj->handle.Instance = DAC; obj->handle.State = HAL_DAC_STATE_RESET; if (HAL_DAC_Init(&obj->handle) != HAL_OK ) { error("HAL_DAC_Init failed"); } sConfig.DAC_Trigger = DAC_TRIGGER_NONE; sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE; if (HAL_DAC_ConfigChannel(&obj->handle, &sConfig, obj->channel) != HAL_OK) { error("HAL_DAC_ConfigChannel failed"); } analogout_write_u16(obj, 0); }
void analogout_init(dac_t *obj, PinName pin) { DAC_ChannelConfTypeDef sConfig = {0}; // Get the peripheral name from the pin and assign it to the object obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC); MBED_ASSERT(obj->dac != (DACName)NC); // Get the pin function and assign the used channel to the object uint32_t function = pinmap_function(pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); // Configure GPIO pinmap_pinout(pin, PinMap_DAC); // Save the pin for future use obj->pin = pin; // Enable DAC clock __HAL_RCC_DAC1_CLK_ENABLE(); // Configure DAC DacHandle.Instance = DAC; if (HAL_DAC_Init(&DacHandle) != HAL_OK) { error("Cannot initialize DAC\n"); } sConfig.DAC_SampleAndHold = DAC_SAMPLEANDHOLD_DISABLE; sConfig.DAC_Trigger = DAC_TRIGGER_NONE; sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE; sConfig.DAC_ConnectOnChipPeripheral = DAC_CHIPCONNECT_DISABLE; sConfig.DAC_UserTrimming = DAC_TRIMMING_FACTORY; if (obj->channel == 2) { if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DAC_CHANNEL_2) != HAL_OK) { error("Cannot configure DAC channel 2\n"); } channel2_used = 1; } else { // channel 1 per default if (HAL_DAC_ConfigChannel(&DacHandle, &sConfig, DAC_CHANNEL_1) != HAL_OK) { error("Cannot configure DAC channel 1\n"); } obj->channel = 1; channel1_used = 1; } analogout_write_u16(obj, 0); }
void analogin_init(analogin_t *obj, PinName pin) { obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC); MBED_ASSERT(obj->adc != (ADCName)NC); uint32_t pinFunc = pinmap_function(pin, PinMap_ADC); MBED_ASSERT(pinFunc != (uint32_t)NC); obj->adc_pin = pinFunc; NVIC_SetVector(ADC_IRQn, (uint32_t)ADC_IRQHandler); ret_code_t ret_code; // p_config, event_handler ret_code = nrf_drv_adc_init(NULL , NULL); // select blocking mode MBED_ASSERT((ret_code == NRF_SUCCESS) || (ret_code == NRF_ERROR_INVALID_STATE)); //NRF_ERROR_INVALID_STATE expected for multiple channels used. }
/** * @brief This function will disable the PWM * @param port : the gpio port to use * @param pin : the gpio pin to use * @retval None */ void pwm_stop(PinName pin) { TIM_HandleTypeDef timHandle; uint32_t timChannel; timHandle.Instance = pinmap_peripheral(pin, PinMap_PWM); if (timHandle.Instance == NP) return; timChannel = get_pwm_channel(pin); if (!IS_TIM_CHANNELS(timChannel)) return; #if !defined(STM32L0xx) && !defined(STM32L1xx) if (STM_PIN_INVERTED(pinmap_function(pin, PinMap_PWM))) { HAL_TIMEx_PWMN_Stop(&timHandle, timChannel); } else #endif { HAL_TIM_PWM_Stop(&timHandle, timChannel); } HAL_TIM_PWM_DeInit(&timHandle); }
static uint32_t get_pwm_channel(PinName pin) { uint32_t function = pinmap_function(pin, PinMap_PWM); uint32_t channel = 0; switch(STM_PIN_CHANNEL(function)) { case 1: channel = TIM_CHANNEL_1; break; case 2: channel = TIM_CHANNEL_2; break; case 3: channel = TIM_CHANNEL_3; break; case 4: channel = TIM_CHANNEL_4; break; default: channel = 0; break; } return channel; }
static uint32_t get_dac_channel(PinName pin) { uint32_t function = pinmap_function(pin, PinMap_DAC); uint32_t channel = 0; switch(STM_PIN_CHANNEL(function)) { #ifdef DAC_CHANNEL_0 case 0: channel = DAC_CHANNEL_0; break; #endif case 1: channel = DAC_CHANNEL_1; break; #ifdef DAC_CHANNEL_2 case 2: channel = DAC_CHANNEL_2; break; #endif default: channel = 0; break; } return channel; }
/** Initialize the analogin peripheral * * Configures the pin used by analogin. * @param obj The analogin object to initialize * @param pin The analogin pin name */ void analogin_init(analogin_t *obj, PinName pin) { MBED_ASSERT(obj); /* Only initialize SAADC on first pin. */ static bool first_init = true; if (first_init) { first_init = false; /* Use configuration from sdk_config.h. * Default is: * - 12 bit. * - No oversampling. * - Priority 7 (lowest). * - No low power mode. */ nrf_drv_saadc_config_t adc_config = { .resolution = (nrf_saadc_resolution_t)SAADC_CONFIG_RESOLUTION, .oversample = (nrf_saadc_oversample_t)SAADC_CONFIG_OVERSAMPLE, .interrupt_priority = SAADC_CONFIG_IRQ_PRIORITY, .low_power_mode = SAADC_CONFIG_LP_MODE }; ret_code_t result = nrf_drv_saadc_init(&adc_config, analog_in_event_handler); MBED_ASSERT(result == NRF_SUCCESS); /* Register interrupt handler in vector table. */ NVIC_SetVector(SAADC_IRQn, (uint32_t)SAADC_IRQHandler); } /* Use pinmap function to get associated channel. */ uint32_t channel = pinmap_function(pin, PinMap_ADC); MBED_ASSERT(channel != (uint32_t) NC); /* Account for an off-by-one in Channel definition and Input definition. */ nrf_saadc_input_t input = channel + 1; /* Configure channel and pin: * - the 1/4 gain and VDD/4 makes the reference voltage VDD. */ nrf_saadc_channel_config_t channel_config = { .resistor_p = NRF_SAADC_RESISTOR_DISABLED, .resistor_n = NRF_SAADC_RESISTOR_DISABLED, .gain = NRF_SAADC_GAIN1_4, .reference = NRF_SAADC_REFERENCE_VDD4, .acq_time = NRF_SAADC_ACQTIME_10US, .mode = NRF_SAADC_MODE_SINGLE_ENDED, .burst = NRF_SAADC_BURST_DISABLED, .pin_p = input, .pin_n = NRF_SAADC_INPUT_DISABLED }; ret_code_t result = nrf_drv_saadc_channel_init(channel, &channel_config); MBED_ASSERT(result == NRF_SUCCESS); /* Store channel in ADC object. */ obj->channel = channel; } /** Read the input voltage, represented as a float in the range [0.0, 1.0] * * @param obj The analogin object * @return A floating value representing the current input voltage */ uint16_t analogin_read_u16(analogin_t *obj) { MBED_ASSERT(obj); /* Default return value is 0. */ uint16_t retval = 0; /* Read single channel, blocking. */ nrf_saadc_value_t value = { 0 }; ret_code_t result = nrf_drv_saadc_sample_convert(obj->channel, &value); /* nrf_saadc_value_t is a signed integer. Only take the absolute value. */ if ((result == NRF_SUCCESS) && (value > 0)) { /* Normalize 12 bit ADC value to 16 bit Mbed ADC range. */ uint32_t normalized = value; retval = (normalized * ADC_16BIT_RANGE) / ADC_12BIT_RANGE; } return retval; }
void analogout_init(dac_t *obj, PinName pin) { DAC_ChannelConfTypeDef sConfig = {0}; // Get the peripheral name from the pin and assign it to the object obj->dac = (DACName)pinmap_peripheral(pin, PinMap_DAC); MBED_ASSERT(obj->dac != (DACName)NC); // Get the pin function and assign the used channel to the object uint32_t function = pinmap_function(pin, PinMap_DAC); MBED_ASSERT(function != (uint32_t)NC); // Save the channel for the write and read functions switch (STM_PIN_CHANNEL(function)) { case 1: obj->channel = DAC_CHANNEL_1; break; #if defined(DAC_CHANNEL_2) case 2: obj->channel = DAC_CHANNEL_2; break; #endif default: error("Unknown DAC channel"); break; } // Configure GPIO pinmap_pinout(pin, PinMap_DAC); // Save the pin for future use obj->pin = pin; // Enable DAC clock if (obj->dac == DAC_1) { __HAL_RCC_DAC1_CLK_ENABLE(); } #if defined(DAC2) if (obj->dac == DAC_2) { __HAL_RCC_DAC2_CLK_ENABLE(); } #endif // Configure DAC obj->handle.Instance = (DAC_TypeDef *)(obj->dac); obj->handle.State = HAL_DAC_STATE_RESET; if (HAL_DAC_Init(&obj->handle) != HAL_OK) { error("HAL_DAC_Init failed"); } /* Enable both Buffer and Switch in the configuration, * letting HAL layer in charge of selecting either one * or the other depending on the actual DAC instance and * channel being configured. */ sConfig.DAC_Trigger = DAC_TRIGGER_NONE; sConfig.DAC_OutputBuffer = DAC_OUTPUTBUFFER_ENABLE; #if defined(DAC_OUTPUTSWITCH_ENABLE) sConfig.DAC_OutputSwitch = DAC_OUTPUTSWITCH_ENABLE; #endif if (pin == PA_4) { pa4_used = 1; } if (pin == PA_5) { pa5_used = 1; } if (HAL_DAC_ConfigChannel(&obj->handle, &sConfig, obj->channel) != HAL_OK) { error("HAL_DAC_ConfigChannel failed"); } analogout_write_u16(obj, 0); }
void i2c_init(i2c_t *obj_in, PinName sda, PinName scl) { i2c_obj_t *obj = OBJ_P(obj_in); uint32_t i2c = pinmap_peripheral(sda, PinMap_I2C_SDA); i2c = pinmap_merge(i2c, pinmap_peripheral(scl, PinMap_I2C_SCL)); if (i2c != (uint32_t) NC) { /* Initialize configuration */ obj->base = (CySCB_Type *) i2c; obj->i2c_id = ((I2CName) i2c - I2C_0) / (I2C_1 - I2C_0); obj->clock = CY_PIN_CLOCK(pinmap_function(scl, PinMap_I2C_SCL)); obj->divider = I2C_INVALID_DIVIDER; obj->already_reserved = (0 != cy_reserve_scb(obj->i2c_id)); obj->pin_sda = sda; obj->pin_scl = scl; obj->mode = CY_SCB_I2C_MASTER; obj->timeout = I2C_DEFAULT_TIMEOUT; #if DEVICE_I2C_ASYNCH obj->irqn = unconnected_IRQn; obj->pending = PENDING_NONE; obj->events = 0; #endif /* DEVICE_I2C_ASYNCH */ /* Check if resource severed */ if (obj->already_reserved) { /* SCB pins and clocks are connected */ /* Disable block and get it into the default state */ Cy_SCB_I2C_Disable(obj->base, &obj->context); Cy_SCB_I2C_DeInit(obj->base); /* The proper clock will be connected by i2c_init_clock(obj, I2C_DEFAULT_SPEED) */ obj->divider = I2C_DIVIDER_LOW; } else { #if DEVICE_SLEEP && DEVICE_LPTICKER /* Register callback once */ obj->pm_callback_handler.callback = i2c_pm_callback; obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP; obj->pm_callback_handler.skipMode = 0; obj->pm_callback_handler.callbackParams = &obj->pm_callback_params; obj->pm_callback_params.base = obj->base; obj->pm_callback_params.context = obj; if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) { error("PM callback registration failed!"); } #endif /* DEVICE_SLEEP && DEVICE_LPTICKER */ } /* Configure hardware resources */ i2c_init_clock(obj, I2C_DEFAULT_SPEED); i2c_init_pins(obj); i2c_init_peripheral(obj); } else { error("I2C pinout mismatch. Requested pins SDA and SCL can't be used for the same I2C communication."); } }
/** Initialize the analogin peripheral * * Configures the pin used by analogin. * @param obj The analogin object to initialize * @param pin The analogin pin name */ void analogin_init(analogin_t *obj, PinName pin) { uint32_t periph; MBED_ASSERT(obj); obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC); MBED_ASSERT(obj->adc != (ADCName)NC); uint32_t function = pinmap_function(pin, PinMap_ADC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = GD_PIN_CHANNEL_GET(function); MBED_ASSERT(obj->channel <= ADC_CHANNEL_17); periph = obj->adc; /* save the pin for future use */ obj->pin = pin; /* ADC clock enable and pin number reset */ switch (periph) { case ADC0: rcu_periph_clock_enable(RCU_ADC0); break; case ADC1: rcu_periph_clock_enable(RCU_ADC1); /* reset pin number */ pin = (PinName)(pin & AND_NUMBER); break; } /* ADC clock cannot be greater than 40M */ rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV4); if ((ADC_CHANNEL_16 == obj->channel)) { /* ADC Vrefint enable */ adc_tempsensor_vrefint_enable(); /* set temperature sample flag */ temperature_sample_flag = SET; } if ((ADC_CHANNEL_17 == obj->channel)) { /* ADC Vrefint enable */ adc_tempsensor_vrefint_enable(); } /* when pin >= ADC_TEMP, it indicates that the channel has no external pins */ if (pin < ADC_TEMP) { pinmap_pinout(pin, PinMap_ADC); } /* ADC configuration */ adc_special_function_config(obj->adc, ADC_SCAN_MODE, DISABLE); adc_special_function_config(obj->adc, ADC_CONTINUOUS_MODE, DISABLE); /* ADC trigger config */ adc_external_trigger_source_config(obj->adc, ADC_REGULAR_CHANNEL, ADC0_1_EXTTRIG_REGULAR_NONE); /* ADC mode config */ adc_mode_config(ADC_MODE_FREE); /* ADC data alignment config */ adc_data_alignment_config(obj->adc, ADC_DATAALIGN_RIGHT); /* ADC channel length config */ adc_channel_length_config(obj->adc, ADC_REGULAR_CHANNEL, 1); if (temperature_sample_flag == SET) { /* sample temperature needs more time */ adc_regular_channel_config(obj->adc, 0, obj->channel, ADC_SAMPLETIME_239POINT5); /* clear temperature sample flag */ temperature_sample_flag = RESET; } else { adc_regular_channel_config(obj->adc, 0, obj->channel, ADC_SAMPLETIME_28POINT5); } adc_external_trigger_config(obj->adc, ADC_REGULAR_CHANNEL, ENABLE); /* ADC enable */ adc_enable(obj->adc); /* wait for ADC to stabilize */ _delay(500); adc_calibration_enable(obj->adc); }
void analogin_init(analogin_t *obj, PinName pin) { static bool adc_hsi_inited = false; RCC_OscInitTypeDef RCC_OscInitStruct; uint32_t function = (uint32_t)NC; // ADC Internal Channels "pins" (Temperature, Vref, Vbat, ...) // are described in PinNames.h and PeripheralPins.c // Pin value must be between 0xF0 and 0xFF if ((pin < 0xF0) || (pin >= 0x100)) { // Normal channels // Get the peripheral name from the pin and assign it to the object obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC); // Get the functions (adc channel) from the pin and assign it to the object function = pinmap_function(pin, PinMap_ADC); // Configure GPIO pinmap_pinout(pin, PinMap_ADC); } else { // Internal channels obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC_Internal); function = pinmap_function(pin, PinMap_ADC_Internal); // No GPIO configuration for internal channels } MBED_ASSERT(obj->handle.Instance != (ADC_TypeDef *)NC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); // Save pin number for the read function obj->pin = pin; // Configure ADC object structures obj->handle.State = HAL_ADC_STATE_RESET; obj->handle.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV4; obj->handle.Init.Resolution = ADC_RESOLUTION_12B; obj->handle.Init.DataAlign = ADC_DATAALIGN_RIGHT; obj->handle.Init.ScanConvMode = DISABLE; // Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) obj->handle.Init.EOCSelection = EOC_SINGLE_CONV; // On STM32L1xx ADC, overrun detection is enabled only if EOC selection is set to each conversion (or transfer by DMA enabled, this is not the case in this example). obj->handle.Init.LowPowerAutoWait = ADC_AUTOWAIT_UNTIL_DATA_READ; // Enable the dynamic low power Auto Delay: new conversion start only when the previous conversion (for regular group) or previous sequence (for injected group) has been treated by user software. obj->handle.Init.LowPowerAutoPowerOff = ADC_AUTOPOWEROFF_IDLE_PHASE; // Enable the auto-off mode: the ADC automatically powers-off after a conversion and automatically wakes-up when a new conversion is triggered (with startup time between trigger and start of sampling). obj->handle.Init.ChannelsBank = ADC_CHANNELS_BANK_A; obj->handle.Init.ContinuousConvMode = DISABLE; // Continuous mode disabled to have only 1 conversion at each conversion trig obj->handle.Init.NbrOfConversion = 1; // Parameter discarded because sequencer is disabled obj->handle.Init.DiscontinuousConvMode = DISABLE; // Parameter discarded because sequencer is disabled obj->handle.Init.NbrOfDiscConversion = 1; // Parameter discarded because sequencer is disabled obj->handle.Init.ExternalTrigConv = 0; // Not used obj->handle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; obj->handle.Init.DMAContinuousRequests = DISABLE; __HAL_RCC_ADC1_CLK_ENABLE(); if (HAL_ADC_Init(&obj->handle) != HAL_OK) { error("Cannot initialize ADC"); } // This section is done only once if (!adc_hsi_inited) { adc_hsi_inited = true; // Enable the HSI (to clock the ADC) RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI; RCC_OscInitStruct.HSIState = RCC_HSI_ON; RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE; RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT; HAL_RCC_OscConfig(&RCC_OscInitStruct); } }
/** Initialize the analogin peripheral * * Configures the pin used by analogin. * @param obj The analogin object to initialize * @param pin The analogin pin name */ void analogin_init(analogin_t *obj, PinName pin) { uint32_t periph; MBED_ASSERT(obj); obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC); MBED_ASSERT(obj->adc != (ADCName)NC); uint32_t function = pinmap_function(pin, PinMap_ADC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = GD_PIN_CHANNEL_GET(function); MBED_ASSERT(obj->channel <= ADC_CHANNEL_17); obj->pin = pin; if ((ADC_CHANNEL_17 == obj->channel) || (ADC_CHANNEL_16 == obj->channel)) { /* no need to config port */ } else { pinmap_pinout(pin, PinMap_ADC); } periph = obj->adc; /* when pin >= ADC_TEMP, it indicates that the channel has no external pins */ if (pin < ADC_TEMP) { pinmap_pinout(pin, PinMap_ADC); } /* ADC clock enable */ switch (periph) { case ADC0: rcu_periph_clock_enable(RCU_ADC0); break; case ADC1: rcu_periph_clock_enable(RCU_ADC1); break; #ifndef GD32F30X_CL case ADC2: rcu_periph_clock_enable(RCU_ADC2); break; #endif /* GD32F30X_CL */ } /* ADC clock cannot be greater than 42M */ rcu_adc_clock_config(RCU_CKADC_CKAPB2_DIV6); /* ADC configuration */ adc_data_alignment_config(obj->adc, ADC_DATAALIGN_RIGHT); adc_channel_length_config(obj->adc, ADC_REGULAR_CHANNEL, 1); adc_special_function_config(obj->adc, ADC_SCAN_MODE, DISABLE); adc_special_function_config(obj->adc, ADC_CONTINUOUS_MODE, DISABLE); adc_external_trigger_config(obj->adc, ADC_REGULAR_CHANNEL, ENABLE); adc_external_trigger_source_config(obj->adc, ADC_REGULAR_CHANNEL, ADC0_1_2_EXTTRIG_REGULAR_NONE); /* ADC enable */ adc_enable(obj->adc); adc_calibration_enable(obj->adc); }
void analogin_init(analogin_t *obj, PinName pin) { uint32_t function = (uint32_t)NC; // ADC Internal Channels "pins" (Temperature, Vref, Vbat, ...) // are described in PinNames.h and PeripheralPins.c // Pin value must be between 0xF0 and 0xFF if ((pin < 0xF0) || (pin >= 0x100)) { // Normal channels // Get the peripheral name from the pin and assign it to the object obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC); // Get the functions (adc channel) from the pin and assign it to the object function = pinmap_function(pin, PinMap_ADC); // Configure GPIO pinmap_pinout(pin, PinMap_ADC); } else { // Internal channels obj->handle.Instance = (ADC_TypeDef *)pinmap_peripheral(pin, PinMap_ADC_Internal); function = pinmap_function(pin, PinMap_ADC_Internal); // No GPIO configuration for internal channels } MBED_ASSERT(obj->handle.Instance != (ADC_TypeDef *)NC); MBED_ASSERT(function != (uint32_t)NC); obj->channel = STM_PIN_CHANNEL(function); // Save pin number for the read function obj->pin = pin; // Configure ADC object structures obj->handle.State = HAL_ADC_STATE_RESET; obj->handle.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2; obj->handle.Init.Resolution = ADC_RESOLUTION_12B; obj->handle.Init.DataAlign = ADC_DATAALIGN_RIGHT; obj->handle.Init.ScanConvMode = DISABLE; obj->handle.Init.EOCSelection = ADC_EOC_SINGLE_CONV; obj->handle.Init.LowPowerAutoWait = DISABLE; obj->handle.Init.ContinuousConvMode = DISABLE; obj->handle.Init.NbrOfConversion = 1; obj->handle.Init.DiscontinuousConvMode = DISABLE; obj->handle.Init.NbrOfDiscConversion = 0; obj->handle.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1; obj->handle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE; obj->handle.Init.DMAContinuousRequests = DISABLE; obj->handle.Init.Overrun = ADC_OVR_DATA_OVERWRITTEN; #if defined(ADC1) if ((ADCName)obj->handle.Instance == ADC_1) { __HAL_RCC_ADC1_CLK_ENABLE(); } #endif #if defined(ADC2) if ((ADCName)obj->handle.Instance == ADC_2) { __HAL_RCC_ADC2_CLK_ENABLE(); } #endif #if defined(ADC3) if ((ADCName)obj->handle.Instance == ADC_3) { __HAL_RCC_ADC34_CLK_ENABLE(); } #endif #if defined(ADC4) if ((ADCName)obj->handle.Instance == ADC_4) { __HAL_RCC_ADC34_CLK_ENABLE(); } #endif if (HAL_ADC_Init(&obj->handle) != HAL_OK) { error("Cannot initialize ADC\n"); } if (!HAL_ADCEx_Calibration_GetValue(&obj->handle, ADC_SINGLE_ENDED)) { HAL_ADCEx_Calibration_Start(&obj->handle, ADC_SINGLE_ENDED); } }
void pwmout_init(pwmout_t *obj, PinName pin) { uint32_t pwm_cnt = 0; uint32_t pwm_function = 0; uint32_t abs_cnt_num = 0; MBED_ASSERT(obj); MBED_ASSERT(pin != (PinName)NC); // Allocate and setup clock. if (pwm_clock_divider == CY_INVALID_DIVIDER) { pwm_clock_divider = cy_clk_allocate_divider(CY_SYSCLK_DIV_8_BIT); if (pwm_clock_divider == CY_INVALID_DIVIDER) { error("PWM clock divider allocation failed."); return; } Cy_SysClk_PeriphSetDivider(CY_SYSCLK_DIV_8_BIT, pwm_clock_divider, (CY_CLK_PERICLK_FREQ_HZ / PWMOUT_BASE_CLOCK_HZ) - 1); Cy_SysClk_PeriphEnableDivider(CY_SYSCLK_DIV_8_BIT, pwm_clock_divider); } pwm_cnt = pinmap_peripheral(pin, PinMap_PWM_OUT); if (pwm_cnt != (uint32_t)NC) { if (cy_reserve_io_pin(pin)) { error("PWMOUT pin reservation conflict."); } obj->base = (TCPWM_Type*)CY_PERIPHERAL_BASE(pwm_cnt); obj->pin = pin; if (obj->base == TCPWM0) { obj->counter_id = ((PWMName)pwm_cnt - PWM_32b_0) / (PWM_32b_1 - PWM_32b_0); abs_cnt_num = obj->counter_id; } else { // TCPWM1 is used. obj->counter_id = ((PWMName)pwm_cnt - PWM_16b_0) / (PWM_16b_1 - PWM_16b_0); abs_cnt_num = obj->counter_id + 8; } if (cy_reserve_tcpwm(abs_cnt_num)) { error("PWMOUT Timer/Counter reservation conflict."); } // Configure clock. pwm_function = pinmap_function(pin, PinMap_PWM_OUT); obj->clock = CY_PIN_CLOCK(pwm_function); Cy_SysClk_PeriphAssignDivider(obj->clock, CY_SYSCLK_DIV_8_BIT, pwm_clock_divider); Cy_TCPWM_PWM_Init(obj->base, obj->counter_id, &pwm_config); pin_function(pin, pwm_function); // These will be properly configured later on. obj->period = 0; obj->pulse_width = 0; obj->prescaler = 0; #if DEVICE_SLEEP && DEVICE_LPTICKER obj->pm_callback_handler.callback = pwm_pm_callback; obj->pm_callback_handler.type = CY_SYSPM_DEEPSLEEP; obj->pm_callback_handler.skipMode = 0; obj->pm_callback_handler.callbackParams = &obj->pm_callback_params; obj->pm_callback_params.base = obj->base; obj->pm_callback_params.context = obj; if (!Cy_SysPm_RegisterCallback(&obj->pm_callback_handler)) { error("PM callback registration failed!"); } #endif // DEVICE_SLEEP && DEVICE_LPTICKER } else { error("PWM OUT pinout mismatch."); } }
/** * @brief SPI initialization function * @param obj : pointer to spi_t structure * @param speed : spi output speed * @param mode : one of the spi modes * @param msb : set to 1 in msb first * @retval None */ void spi_init(spi_t *obj, uint32_t speed, spi_mode_e mode, uint8_t msb) { if(obj == NULL) return; SPI_HandleTypeDef *handle = &(obj->handle); GPIO_InitTypeDef GPIO_InitStruct; GPIO_TypeDef *port; uint32_t spi_freq = 0; // Determine the SPI to use SPI_TypeDef *spi_mosi = pinmap_peripheral(obj->pin_mosi, PinMap_SPI_MOSI); SPI_TypeDef *spi_miso = pinmap_peripheral(obj->pin_miso, PinMap_SPI_MISO); SPI_TypeDef *spi_sclk = pinmap_peripheral(obj->pin_sclk, PinMap_SPI_SCLK); SPI_TypeDef *spi_ssel = pinmap_peripheral(obj->pin_ssel, PinMap_SPI_SSEL); /* Pins MOSI/MISO/SCLK must not be NP. ssel can be NP. */ if(spi_mosi == NP || spi_miso == NP || spi_sclk == NP) { printf("ERROR: at least one SPI pin has no peripheral\n"); return; } SPI_TypeDef *spi_data = pinmap_merge_peripheral(spi_mosi, spi_miso); SPI_TypeDef *spi_cntl = pinmap_merge_peripheral(spi_sclk, spi_ssel); obj->spi = pinmap_merge_peripheral(spi_data, spi_cntl); // Are all pins connected to the same SPI instance? if(obj->spi == NP) { printf("ERROR: SPI pins mismatch\n"); return; } // Configure the SPI pins if (obj->pin_ssel != NC) { handle->Init.NSS = SPI_NSS_HARD_OUTPUT; } else { handle->Init.NSS = SPI_NSS_SOFT; } /* Fill default value */ handle->Instance = obj->spi; handle->Init.Mode = SPI_MODE_MASTER; spi_freq = spi_getClkFreqInst(obj->spi); if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV2_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_2; } else if(speed >= (spi_freq/SPI_SPEED_CLOCK_DIV4_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_4; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV8_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_8; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV16_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV32_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_32; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV64_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_64; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV128_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; } else if (speed >= (spi_freq/SPI_SPEED_CLOCK_DIV256_MHZ)) { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256; } else { handle->Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_16; } handle->Init.Direction = SPI_DIRECTION_2LINES; if((mode == SPI_MODE_0)||(mode == SPI_MODE_2)) { handle->Init.CLKPhase = SPI_PHASE_1EDGE; } else { handle->Init.CLKPhase = SPI_PHASE_2EDGE; } if((mode == SPI_MODE_0)||(mode == SPI_MODE_1)) { handle->Init.CLKPolarity = SPI_POLARITY_LOW; } else { handle->Init.CLKPolarity = SPI_POLARITY_HIGH; } handle->Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE; handle->Init.CRCPolynomial = 7; handle->Init.DataSize = SPI_DATASIZE_8BIT; if(msb == 0) { handle->Init.FirstBit = SPI_FIRSTBIT_LSB; } else { handle->Init.FirstBit = SPI_FIRSTBIT_MSB; } handle->Init.TIMode = SPI_TIMODE_DISABLE; #if defined(STM32F0xx) || defined(STM32F3xx) || defined(STM32F7xx) || defined(STM32L4xx) handle->Init.NSSPMode = SPI_NSS_PULSE_DISABLE; #endif if(obj->pin_mosi != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_mosi)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_mosi); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_mosi,PinMap_SPI_MOSI)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } if(obj->pin_miso != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_miso)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_miso); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_miso,PinMap_SPI_MISO)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } if(obj->pin_sclk != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_sclk)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_sclk); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); /* * According the STM32 Datasheet for SPI peripheral we need to PULLDOWN * or PULLUP the SCK pin according the polarity used. */ if(handle->Init.CLKPolarity == SPI_POLARITY_LOW) { GPIO_InitStruct.Pull = GPIO_PULLDOWN; } else { GPIO_InitStruct.Pull = GPIO_PULLUP; } GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_sclk,PinMap_SPI_SCLK)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } if(obj->pin_ssel != NC) { port = set_GPIO_Port_Clock(STM_PORT(obj->pin_ssel)); GPIO_InitStruct.Pin = STM_GPIO_PIN(obj->pin_ssel); GPIO_InitStruct.Mode = STM_PIN_MODE(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); GPIO_InitStruct.Pull = STM_PIN_PUPD(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH; #ifdef STM32F1xx pin_SetF1AFPin(STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL))); #else GPIO_InitStruct.Alternate = STM_PIN_AFNUM(pinmap_function(obj->pin_ssel,PinMap_SPI_SSEL)); #endif /* STM32F1xx */ HAL_GPIO_Init(port, &GPIO_InitStruct); } #if defined SPI1_BASE // Enable SPI clock if (handle->Instance == SPI1) { __HAL_RCC_SPI1_CLK_ENABLE(); } #endif #if defined SPI2_BASE if (handle->Instance == SPI2) { __HAL_RCC_SPI2_CLK_ENABLE(); } #endif #if defined SPI3_BASE if (handle->Instance == SPI3) { __HAL_RCC_SPI3_CLK_ENABLE(); } #endif #if defined SPI4_BASE if (handle->Instance == SPI4) { __HAL_RCC_SPI4_CLK_ENABLE(); } #endif #if defined SPI5_BASE if (handle->Instance == SPI5) { __HAL_RCC_SPI5_CLK_ENABLE(); } #endif #if defined SPI6_BASE if (handle->Instance == SPI6) { __HAL_RCC_SPI6_CLK_ENABLE(); } #endif HAL_SPI_Init(handle); /* In order to set correctly the SPI polarity we need to enable the peripheral */ __HAL_SPI_ENABLE(handle); }
/** @addtogroup STM32F4xx_System_Private_FunctionPrototypes * @{ */ static uint32_t get_adc_channel(PinName pin) { uint32_t function = pinmap_function(pin, PinMap_ADC); uint32_t channel = 0; switch(STM_PIN_CHANNEL(function)) { #ifdef ADC_CHANNEL_0 case 0: channel = ADC_CHANNEL_0; break; #endif case 1: channel = ADC_CHANNEL_1; break; case 2: channel = ADC_CHANNEL_2; break; case 3: channel = ADC_CHANNEL_3; break; case 4: channel = ADC_CHANNEL_4; break; case 5: channel = ADC_CHANNEL_5; break; case 6: channel = ADC_CHANNEL_6; break; case 7: channel = ADC_CHANNEL_7; break; case 8: channel = ADC_CHANNEL_8; break; case 9: channel = ADC_CHANNEL_9; break; case 10: channel = ADC_CHANNEL_10; break; case 11: channel = ADC_CHANNEL_11; break; case 12: channel = ADC_CHANNEL_12; break; case 13: channel = ADC_CHANNEL_13; break; case 14: channel = ADC_CHANNEL_14; break; case 15: channel = ADC_CHANNEL_15; break; case 16: channel = ADC_CHANNEL_TEMPSENSOR; break; case 17: channel = ADC_CHANNEL_VREFINT; break; #ifdef ADC_CHANNEL_VBAT case 18: channel = ADC_CHANNEL_VBAT; break; #endif default: channel = 0; break; } return channel; }