void serial_init(serial_t *obj, PinName tx, PinName rx) { uint32_t uart_tx, uart_rx; uint32_t uart_sel; uint8_t uart_idx; PHAL_RUART_OP pHalRuartOp; PHAL_RUART_ADAPTER pHalRuartAdapter; // Determine the UART to use (UART0, UART1, or UART3) uart_tx = pinmap_peripheral(tx, PinMap_UART_TX); uart_rx = pinmap_peripheral(rx, PinMap_UART_RX); uart_sel = pinmap_merge(uart_tx, uart_rx); uart_idx = RTL_GET_PERI_IDX(uart_sel); if (unlikely(uart_idx == (uint8_t)NC)) { DBG_UART_ERR("%s: Cannot find matched UART\n", __FUNCTION__); return; } pHalRuartOp = &(obj->hal_uart_op); pHalRuartAdapter = &(obj->hal_uart_adp); if ((NULL == pHalRuartOp) || (NULL == pHalRuartAdapter)) { DBG_UART_ERR("%s: Allocate Adapter Failed\n", __FUNCTION__); return; } HalRuartOpInit((VOID*)pHalRuartOp); pHalRuartOp->HalRuartAdapterLoadDef(pHalRuartAdapter, uart_idx); pHalRuartAdapter->PinmuxSelect = RTL_GET_PERI_SEL(uart_sel); pHalRuartAdapter->BaudRate = 9600; // Configure the UART pins // TODO: // pinmap_pinout(tx, PinMap_UART_TX); // pinmap_pinout(rx, PinMap_UART_RX); // pin_mode(tx, PullUp); // pin_mode(rx, PullUp); pHalRuartOp->HalRuartInit(pHalRuartAdapter); pHalRuartOp->HalRuartRegIrq(pHalRuartAdapter); pHalRuartOp->HalRuartIntEnable(pHalRuartAdapter); #ifdef CONFIG_MBED_ENABLED // For stdio management if (uart_idx == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } #endif }
void serial_init(serial_t *obj, PinName tx, PinName rx) { int is_stdio_uart = 0; // determine the UART to use UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); UARTName uart = (UARTName)pinmap_merge(uart_tx, uart_rx); if ((int)uart == NC) { error("Serial pinout mapping failed"); } obj->uart = (LPC_USART_T *)uart; // enable fifos and default rx trigger level obj->uart->FCR = 1 << 0 // FIFO Enable - 0 = Disables, 1 = Enabled | 0 << 1 // Rx Fifo Reset | 0 << 2 // Tx Fifo Reset | 0 << 6; // Rx irq trigger level - 0 = 1 char, 1 = 4 chars, 2 = 8 chars, 3 = 14 chars // disable irqs obj->uart->IER = 0 << 0 // Rx Data available irq enable | 0 << 1 // Tx Fifo empty irq enable | 0 << 2; // Rx Line Status irq enable // set default baud rate and format is_stdio_uart = (uart == STDIO_UART) ? (1) : (0); serial_baud (obj, is_stdio_uart ? 115200 : 9600); serial_format(obj, 8, ParityNone, 1); // pinout the chosen uart pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); // set rx/tx pins in PullUp mode pin_mode(tx, PullUp); pin_mode(rx, PullUp); switch (uart) { case UART_0: obj->index = 0; break; case UART_1: obj->index = 1; break; case UART_2: obj->index = 2; break; case UART_3: obj->index = 3; break; } uart_data[obj->index].sw_rts.pin = NC; uart_data[obj->index].sw_cts.pin = NC; serial_set_flow_control(obj, FlowControlNone, NC, NC); if (is_stdio_uart) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { // determine the SPI to use SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK); SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); obj->spi = (SPI_Type*)pinmap_merge(spi_data, spi_cntl); if ((int)obj->spi == NC) { error("SPI pinout mapping failed"); } // enable power and clocking switch ((int)obj->spi) { case SPI_0: SIM->SCGC5 |= 1 << 11; SIM->SCGC4 |= 1 << 22; break; case SPI_1: SIM->SCGC5 |= 1 << 13; SIM->SCGC4 |= 1 << 23; break; } // set default format and frequency if (ssel == NC) { spi_format(obj, 8, 0, 0); // 8 bits, mode 0, master } else { spi_format(obj, 8, 0, 1); // 8 bits, mode 0, slave } spi_frequency(obj, 1000000); // enable SPI obj->spi->C1 |= SPI_C1_SPE_MASK; // pin out the spi pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } }
void can_init(can_t *obj, PinName rd, PinName td) { uint32_t filter_number; CANName can_rd = (CANName)pinmap_peripheral(rd, PinMap_CAN_RD); CANName can_td = (CANName)pinmap_peripheral(td, PinMap_CAN_TD); obj->can = (CANName)pinmap_merge(can_rd, can_td); MBED_ASSERT((int)obj->can != NC); if(obj->can == CAN_1) { __HAL_RCC_CAN1_CLK_ENABLE(); obj->index = 0; } else { __HAL_RCC_CAN2_CLK_ENABLE(); obj->index = 1; } // Configure the CAN pins pinmap_pinout(rd, PinMap_CAN_RD); pinmap_pinout(td, PinMap_CAN_TD); if (rd != NC) { pin_mode(rd, PullUp); } if (td != NC) { pin_mode(td, PullUp); } CanHandle.Instance = (CAN_TypeDef *)(obj->can); CanHandle.Init.TTCM = DISABLE; CanHandle.Init.ABOM = DISABLE; CanHandle.Init.AWUM = DISABLE; CanHandle.Init.NART = DISABLE; CanHandle.Init.RFLM = DISABLE; CanHandle.Init.TXFP = DISABLE; CanHandle.Init.Mode = CAN_MODE_NORMAL; CanHandle.Init.SJW = CAN_SJW_1TQ; CanHandle.Init.BS1 = CAN_BS1_6TQ; CanHandle.Init.BS2 = CAN_BS2_8TQ; CanHandle.Init.Prescaler = 2; if (HAL_CAN_Init(&CanHandle) != HAL_OK) { error("Cannot initialize CAN"); } filter_number = (obj->can == CAN_1) ? 0 : 14; // Set initial CAN frequency to 100kb/s can_frequency(obj, 100000); can_filter(obj, 0, 0, CANStandard, filter_number); }
void serial_init(serial_t *obj, PinName tx, PinName rx) { // Determine the UART to use (UART_1, UART_2, ...) UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object obj->uart = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(obj->uart != (UARTName)NC); // Enable USART clock if (obj->uart == UART_1) { __USART1_CLK_ENABLE(); obj->index = 0; } if (obj->uart == UART_2) { __USART2_CLK_ENABLE(); obj->index = 1; } if (obj->uart == UART_6) { __USART6_CLK_ENABLE(); obj->index = 2; } // Configure the UART pins pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { pin_mode(tx, PullUp); } if (rx != NC) { pin_mode(rx, PullUp); } // Configure UART obj->baudrate = 9600; obj->databits = UART_WORDLENGTH_8B; obj->stopbits = UART_STOPBITS_1; obj->parity = UART_PARITY_NONE; obj->pin_tx = tx; obj->pin_rx = rx; init_uart(obj); // For stdio management if (obj->uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { // determine the SPI to use SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK); SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); obj->spi = (LPC_SSP_TypeDef*)pinmap_merge(spi_data, spi_cntl); if ((int)obj->spi == NC) { error("SPI pinout mapping failed"); } // enable power and clocking switch ((int)obj->spi) { case SPI_0: LPC_SC->PCONP |= 1 << 21; break; case SPI_1: LPC_SC->PCONP |= 1 << 10; break; } // set default format and frequency if (ssel == NC) { spi_format(obj, 8, 0, 0); // 8 bits, mode 0, master } else { spi_format(obj, 8, 0, 1); // 8 bits, mode 0, slave } spi_frequency(obj, 1000000); // enable the ssp channel ssp_enable(obj); // pin out the spi pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } }
void serial_init(serial_t *obj, PinName tx, PinName rx) { // Determine the UART to use UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); // Get the peripheral name from the pin and assign it to the object obj->uart = (UARTName)pinmap_merge(uart_tx, uart_rx); MBED_ASSERT(obj->uart != (UARTName)NC); // Enable USART clock if (obj->uart == UART_1) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); } if (obj->uart == UART_2) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); } if (obj->uart == UART_3) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); } // Configure the UART pins pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { pin_mode(tx, PullUp); } if (rx != NC) { pin_mode(rx, PullUp); } // Configure UART obj->baudrate = 9600; obj->databits = USART_WordLength_8b; obj->stopbits = USART_StopBits_1; obj->parity = USART_Parity_No; init_usart(obj); // The index is used by irq if (obj->uart == UART_1) obj->index = 0; if (obj->uart == UART_2) obj->index = 1; if (obj->uart == UART_3) obj->index = 2; // For stdio management if (obj->uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { // determine the SPI to use uint32_t spi_mosi = pinmap_peripheral(mosi, PinMap_SPI_MOSI); uint32_t spi_miso = pinmap_peripheral(miso, PinMap_SPI_MISO); uint32_t spi_sclk = pinmap_peripheral(sclk, PinMap_SPI_SCLK); uint32_t spi_ssel = pinmap_peripheral(ssel, PinMap_SPI_SSEL); uint32_t spi_data = pinmap_merge(spi_mosi, spi_miso); uint32_t spi_cntl = pinmap_merge(spi_sclk, spi_ssel); obj->instance = pinmap_merge(spi_data, spi_cntl); MBED_ASSERT((int)obj->instance != NC); // pin out the spi pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } spi_setup_clock(); }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { // determine the SPI to use SPIName spi_mosi = (SPIName)pinmap_peripheral(mosi, PinMap_SPI_MOSI); SPIName spi_miso = (SPIName)pinmap_peripheral(miso, PinMap_SPI_MISO); SPIName spi_sclk = (SPIName)pinmap_peripheral(sclk, PinMap_SPI_SCLK); SPIName spi_ssel = (SPIName)pinmap_peripheral(ssel, PinMap_SPI_SSEL); SPIName spi_data = (SPIName)pinmap_merge(spi_mosi, spi_miso); SPIName spi_cntl = (SPIName)pinmap_merge(spi_sclk, spi_ssel); obj->spi = (SPI_Type*)pinmap_merge(spi_data, spi_cntl); MBED_ASSERT((int)obj->spi != NC); SIM->SCGC5 |= SIM_SCGC5_PORTC_MASK | SIM_SCGC5_PORTD_MASK; SIM->SCGC6 |= SIM_SCGC6_SPI0_MASK; obj->spi->MCR &= ~(SPI_MCR_MDIS_MASK | SPI_MCR_HALT_MASK); //obj->spi->MCR |= SPI_MCR_DIS_RXF_MASK | SPI_MCR_DIS_TXF_MASK; // set default format and frequency if (ssel == NC) { spi_format(obj, 8, 0, 0); // 8 bits, mode 0, master } else { spi_format(obj, 8, 0, 1); // 8 bits, mode 0, slave } spi_frequency(obj, 1000000); // not halt in the debug mode obj->spi->SR |= SPI_SR_EOQF_MASK; // pin out the spi pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } }
//****************************************************************************** void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow) { pin_function_t rtscts_pin_func = {0}; obj->cfg.cts = 0; obj->cfg.rts = 0; if ((FlowControlCTS == type) || (FlowControlRTSCTS == type)) { UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS); UARTName uart = (UARTName)pinmap_merge(uart_cts, (UARTName)obj->uart); // Assert pin is usable with existing uart MBED_ASSERT(uart != (UARTName)NC); pin_function_t *pin_func; pin_func = (pin_function_t *)pinmap_find_function(txflow, PinMap_UART_CTS); rtscts_pin_func.req_val |= pin_func->req_val; obj->cfg.cts = 1; } if ((FlowControlRTS == type) || (FlowControlRTSCTS == type)) { UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS); UARTName uart = (UARTName)pinmap_merge(uart_rts, (UARTName)obj->uart); MBED_ASSERT(uart != (UARTName)NC); pin_function_t *pin_func; pin_func = (pin_function_t *)pinmap_find_function(rxflow, PinMap_UART_RTS); rtscts_pin_func.req_val |= pin_func->req_val; obj->cfg.rts = 1; } obj->sys_cfg.io_cfg.req_val.value |= rtscts_pin_func.req_val; int retval = UART_Init(obj->uart, &obj->cfg, &obj->sys_cfg); MBED_ASSERT(retval == E_NO_ERROR); }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // Determine the I2C to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT(obj->i2c != (I2CName)NC); // Enable I2C1 clock and pinout if not done if ((obj->i2c == I2C_1) && !i2c1_inited) { i2c1_inited = 1; __I2C1_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Enable I2C2 clock and pinout if not done if ((obj->i2c == I2C_2) && !i2c2_inited) { i2c2_inited = 1; __I2C2_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Enable I2C3 clock and pinout if not done if ((obj->i2c == I2C_3) && !i2c3_inited) { i2c3_inited = 1; __I2C3_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default // I2C master by default obj->slave = 0; }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // determine the SPI to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); #if defined(TARGET_LPC1768) || defined(TARGET_LPC2368) obj->i2c = (LPC_I2C_TypeDef *)pinmap_merge(i2c_sda, i2c_scl); #elif defined(TARGET_LPC11U24) obj->i2c = (LPC_I2C_Type *)pinmap_merge(i2c_sda, i2c_scl); #endif if ((int)obj->i2c == NC) { error("I2C pin mapping failed"); } // enable power i2c_power_enable(obj); // set default frequency at 100k i2c_frequency(obj, 100000); i2c_conclr(obj, 1, 1, 1, 1); i2c_interface_enable(obj); pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); }
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel) { // determine the SPI to use uint32_t spi_mosi = pinmap_peripheral(mosi, PinMap_SPI_MOSI); uint32_t spi_miso = pinmap_peripheral(miso, PinMap_SPI_MISO); uint32_t spi_sclk = pinmap_peripheral(sclk, PinMap_SPI_SCLK); uint32_t spi_ssel = pinmap_peripheral(ssel, PinMap_SPI_SSEL); uint32_t spi_data = pinmap_merge(spi_mosi, spi_miso); uint32_t spi_cntl = pinmap_merge(spi_sclk, spi_ssel); obj->instance = pinmap_merge(spi_data, spi_cntl); MBED_ASSERT((int)obj->instance != NC); // enable power and clocking clock_manager_set_gate(kClockModuleSPI, obj->instance, true); dspi_hal_disable(obj->instance); // set default format and frequency if (ssel == NC) { spi_format(obj, 8, 0, 0); // 8 bits, mode 0, master } else { spi_format(obj, 8, 0, 1); // 8 bits, mode 0, slave } spi_set_delays(obj->instance); spi_frequency(obj, 1000000); dspi_hal_enable(obj->instance); dspi_hal_start_transfer(obj->instance); // pin out the spi pins pinmap_pinout(mosi, PinMap_SPI_MOSI); pinmap_pinout(miso, PinMap_SPI_MISO); pinmap_pinout(sclk, PinMap_SPI_SCLK); if (ssel != NC) { pinmap_pinout(ssel, PinMap_SPI_SSEL); } }
void serial_init(serial_t *obj, PinName tx, PinName rx) { // determine the UART to use -- for mcu's with multiple uart connections UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); UARTName uart = (UARTName)pinmap_merge(uart_tx, uart_rx); if ((int)uart == NC) { error("Serial pinout mapping failed"); } obj->uart = (NRF_UART_Type *)uart; //pin configurations -- //outputs NRF_GPIO->DIR |= (1<<tx);//TX_PIN_NUMBER); NRF_GPIO->DIR |= (1<<RTS_PIN_NUMBER); NRF_GPIO->DIR &= ~(1<<rx);//RX_PIN_NUMBER); NRF_GPIO->DIR &= ~(1<<CTS_PIN_NUMBER); obj->uart->PSELRTS = RTS_PIN_NUMBER; obj->uart->PSELTXD = tx;//TX_PIN_NUMBER; //inputs obj->uart->PSELCTS = CTS_PIN_NUMBER; obj->uart->PSELRXD = rx;//RX_PIN_NUMBER; // set default baud rate and format serial_baud (obj, 9600); serial_format(obj, 8, ParityNone, 1); obj->uart->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos);; obj->uart->TASKS_STARTTX = 1; obj->uart->TASKS_STARTRX = 1; obj->uart->EVENTS_RXDRDY =0; obj->index = 0; // set rx/tx pins in PullUp mode pin_mode(tx, PullUp); pin_mode(rx, PullUp); if (uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
/** Initialize the I2C peripheral. It sets the default parameters for I2C * peripheral, and configures its specifieds pins. * * @param obj The I2C object * @param sda The sda pin * @param scl The scl pin */ void i2c_init(i2c_t *obj, PinName sda, PinName scl) { struct i2c_s *obj_s = I2C_S(obj); /* find the I2C by pins */ uint32_t i2c_sda = pinmap_peripheral(sda, PinMap_I2C_SDA); uint32_t i2c_scl = pinmap_peripheral(scl, PinMap_I2C_SCL); obj_s->sda = sda; obj_s->scl = scl; obj_s->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT(obj_s->i2c != (I2CName)NC); switch (obj_s->i2c) { case I2C_0: /* enable I2C0 clock and configure the pins of I2C0 */ obj_s->index = 0; rcu_periph_clock_enable(RCU_I2C0); break; case I2C_1: /* enable I2C1 clock and configure the pins of I2C1 */ obj_s->index = 1; rcu_periph_clock_enable(RCU_I2C1); break; default: break; } /* configure the pins of I2C */ pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); /* 100 KHz as the default I2C frequence */ i2c_frequency(obj, 100000); obj_s->state = (operation_state_enum)I2C_STATE_NONE; obj_s->previous_state_mode = I2C_STATE_NONE; obj_s->global_trans_option = I2C_FIRST_AND_LAST_FRAME; #if DEVICE_I2CSLAVE /* I2C master by default */ obj_s->slave = 0; #endif }
/** * Set HW Control Flow * @param obj The serial object * @param type The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS) * @param rxflow Pin for the rxflow * @param txflow Pin for the txflow */ void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow) { struct serial_s *obj_s = SERIAL_S(obj); // Determine the UART to use (UART_1, UART_2, ...) UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS); UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS); // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object obj_s->uart = (UARTName)pinmap_merge(uart_cts, uart_rts); MBED_ASSERT(obj_s->uart != (UARTName)NC); if(type == FlowControlNone) { // Disable hardware flow control obj_s->hw_flow_ctl = UART_HWCONTROL_NONE; } if (type == FlowControlRTS) { // Enable RTS MBED_ASSERT(uart_rts != (UARTName)NC); obj_s->hw_flow_ctl = UART_HWCONTROL_RTS; obj_s->pin_rts = rxflow; // Enable the pin for RTS function pinmap_pinout(rxflow, PinMap_UART_RTS); } if (type == FlowControlCTS) { // Enable CTS MBED_ASSERT(uart_cts != (UARTName)NC); obj_s->hw_flow_ctl = UART_HWCONTROL_CTS; obj_s->pin_cts = txflow; // Enable the pin for CTS function pinmap_pinout(txflow, PinMap_UART_CTS); } if (type == FlowControlRTSCTS) { // Enable CTS & RTS MBED_ASSERT(uart_rts != (UARTName)NC); MBED_ASSERT(uart_cts != (UARTName)NC); obj_s->hw_flow_ctl = UART_HWCONTROL_RTS_CTS; obj_s->pin_rts = rxflow; obj_s->pin_cts = txflow; // Enable the pin for CTS function pinmap_pinout(txflow, PinMap_UART_CTS); // Enable the pin for RTS function pinmap_pinout(rxflow, PinMap_UART_RTS); } init_uart(obj); }
/** * Set HW Control Flow * @param obj The serial object * @param type The Control Flow type (FlowControlNone, FlowControlRTS, FlowControlCTS, FlowControlRTSCTS) * @param rxflow Pin for the rxflow * @param txflow Pin for the txflow */ void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow) { struct serial_s *obj_s = SERIAL_S(obj); // Checked used UART name (UART_1, UART_2, ...) UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS); UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS); if (((UARTName)pinmap_merge(uart_rts, obj_s->uart) == (UARTName)NC) || ((UARTName)pinmap_merge(uart_cts, obj_s->uart) == (UARTName)NC)) { MBED_ASSERT(0); return; } if (type == FlowControlNone) { // Disable hardware flow control obj_s->hw_flow_ctl = UART_HWCONTROL_NONE; } if (type == FlowControlRTS) { // Enable RTS MBED_ASSERT(uart_rts != (UARTName)NC); obj_s->hw_flow_ctl = UART_HWCONTROL_RTS; obj_s->pin_rts = rxflow; // Enable the pin for RTS function pinmap_pinout(rxflow, PinMap_UART_RTS); } if (type == FlowControlCTS) { // Enable CTS MBED_ASSERT(uart_cts != (UARTName)NC); obj_s->hw_flow_ctl = UART_HWCONTROL_CTS; obj_s->pin_cts = txflow; // Enable the pin for CTS function pinmap_pinout(txflow, PinMap_UART_CTS); } if (type == FlowControlRTSCTS) { // Enable CTS & RTS MBED_ASSERT(uart_rts != (UARTName)NC); MBED_ASSERT(uart_cts != (UARTName)NC); obj_s->hw_flow_ctl = UART_HWCONTROL_RTS_CTS; obj_s->pin_rts = rxflow; obj_s->pin_cts = txflow; // Enable the pin for CTS function pinmap_pinout(txflow, PinMap_UART_CTS); // Enable the pin for RTS function pinmap_pinout(rxflow, PinMap_UART_RTS); } init_uart(obj); }
void serial_init(serial_t *obj, PinName tx, PinName rx) { // Determine the UART to use (UART_1, UART_2, ...) UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); // Get the peripheral name (UART_1, UART_2, ...) from the pin and assign it to the object obj->uart = (UARTName)pinmap_merge(uart_tx, uart_rx); if (obj->uart == (UARTName)NC) { error("Serial pinout mapping failed"); } // Enable USART clock if (obj->uart == UART_1) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); obj->index = 0; } if (obj->uart == UART_2) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); obj->index = 1; } if (obj->uart == UART_3) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); obj->index = 2; } // Configure the UART pins pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); // Configure UART obj->baudrate = 9600; obj->databits = USART_WordLength_8b; obj->stopbits = USART_StopBits_1; obj->parity = USART_Parity_No; obj->pin_tx = tx; obj->pin_rx = rx; init_usart(obj); // For stdio management if (obj->uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { uint32_t i2c_sda = pinmap_peripheral(sda, PinMap_I2C_SDA); uint32_t i2c_scl = pinmap_peripheral(scl, PinMap_I2C_SCL); obj->instance = pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT((int)obj->instance != NC); clock_manager_set_gate(kClockModuleI2C, obj->instance, true); clock_manager_set_gate(kClockModulePORT, sda >> GPIO_PORT_SHIFT, true); clock_manager_set_gate(kClockModulePORT, scl >> GPIO_PORT_SHIFT, true); i2c_hal_enable(obj->instance); i2c_frequency(obj, 100000); pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); port_hal_configure_open_drain(sda >> GPIO_PORT_SHIFT, sda & 0xFF, true); port_hal_configure_open_drain(scl >> GPIO_PORT_SHIFT, scl & 0xFF, true); }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // determine the SPI to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (LPC_I2C_TypeDef *)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT((int)obj->i2c != NC); // enable power i2c_power_enable(obj); // set default frequency at 100k i2c_frequency(obj, 100000); i2c_conclr(obj, 1, 1, 1, 1); i2c_interface_enable(obj); pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { /* determine the I2C to use */ I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT((int)obj->i2c != NC); /* enable power */ i2c_power_enable(obj); /* set default frequency at 100k */ i2c_frequency(obj, 100000); pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); obj->last_stop_flag = 1; }
void serial_init(serial_t *obj, PinName tx, PinName rx) { int is_stdio_uart = 0; // determine the UART to use UARTName uart_tx = (UARTName)pinmap_peripheral(tx, PinMap_UART_TX); UARTName uart_rx = (UARTName)pinmap_peripheral(rx, PinMap_UART_RX); UARTName uart = (UARTName)pinmap_merge(uart_tx, uart_rx); if ((int)uart == NC) { error("Serial pinout mapping failed"); } RCC->APB2ENR |= RCC_APB2ENR_AFIOEN ; switch (uart) { case UART_1: RCC->APB2ENR |= RCC_APB2ENR_USART1EN; break; case UART_2: RCC->APB1ENR |= RCC_APB1ENR_USART2EN; break; } obj->uart = (USART_TypeDef *)uart; // set default baud rate and format serial_baud (obj, 9600); serial_format(obj, 8, ParityNone, 1); // pinout the chosen uart pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); // set rx/tx pins in PullUp mode pin_mode(tx, PullUp); pin_mode(rx, PullUp); obj->uart->CR1 = USART_CR1_UE | USART_CR1_TE | USART_CR1_RE; switch (uart) { case UART_1: obj->index = 0; break; } is_stdio_uart = (uart == STDIO_UART) ? (1) : (0); if (is_stdio_uart) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void serial_init(serial_t *obj, PinName tx, PinName rx) { uint32_t uart_tx = pinmap_peripheral(tx, PinMap_UART_TX); uint32_t uart_rx = pinmap_peripheral(rx, PinMap_UART_RX); obj->index = pinmap_merge(uart_tx, uart_rx); MBED_ASSERT((int)obj->index != NC); // Need to initialize the clocks here as ticker init gets called before mbed_sdk_init if (SystemCoreClock == DEFAULT_SYSTEM_CLOCK) BOARD_BootClockRUN(); /* Set the LPUART clock source */ if (obj->index == LPUART_0) { CLOCK_SetLpuart0Clock(1U); } else { CLOCK_SetLpuart1Clock(1U); } lpuart_config_t config; LPUART_GetDefaultConfig(&config); config.baudRate_Bps = 9600; config.enableTx = false; config.enableRx = false; LPUART_Init(uart_addrs[obj->index], &config, CLOCK_GetFreq(uart_clocks[obj->index])); pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { LPUART_EnableTx(uart_addrs[obj->index], true); pin_mode(tx, PullUp); } if (rx != NC) { LPUART_EnableRx(uart_addrs[obj->index], true); pin_mode(rx, PullUp); } if (obj->index == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { uint32_t i2c_sda = pinmap_peripheral(sda, PinMap_I2C_SDA); uint32_t i2c_scl = pinmap_peripheral(scl, PinMap_I2C_SCL); obj->instance = pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT((int)obj->instance != NC); CLOCK_SYS_EnableI2cClock(obj->instance); uint32_t i2c_addrs[] = I2C_BASE_ADDRS; I2C_HAL_Init(i2c_addrs[obj->instance]); I2C_HAL_Enable(i2c_addrs[obj->instance]); I2C_HAL_SetIntCmd(i2c_addrs[obj->instance], true); i2c_frequency(obj, 100000); pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); uint32_t port_addrs[] = PORT_BASE_ADDRS; PORT_HAL_SetOpenDrainCmd(port_addrs[sda >> GPIO_PORT_SHIFT], sda & 0xFF, true); PORT_HAL_SetOpenDrainCmd(port_addrs[scl >> GPIO_PORT_SHIFT], scl & 0xFF, true); }
/** init the CAN frequency. * * @param rd receive pin. * @param td transmit pin. * @param hz The bus frequency in hertz. */ void can_init_freq(can_t *obj, PinName rd, PinName td, int hz) { CANName can_rd = (CANName)pinmap_peripheral(rd, PinMap_CAN_RD); CANName can_td = (CANName)pinmap_peripheral(td, PinMap_CAN_TD); obj->can = (CANName)pinmap_merge(can_rd, can_td); MBED_ASSERT((int)obj->can != NC); if (obj->can == CAN_0) { rcu_periph_clock_enable(RCU_CAN0); can_deinit(obj->can); obj->index = 0; } else if (obj->can == CAN_1) { rcu_periph_clock_enable(RCU_CAN0); rcu_periph_clock_enable(RCU_CAN1); can_deinit(obj->can); obj->index = 1; } else { return; } /* Configure the CAN pins */ pinmap_pinout(rd, PinMap_CAN_RD); pinmap_pinout(td, PinMap_CAN_TD); if (rd != NC) { pin_mode(rd, PullUp); } if (td != NC) { pin_mode(td, PullUp); } dev_can_mode_config(obj->can, CAN_NORMAL_MODE); can_frequency(obj, hz); if (obj->can == CAN_0) { can_filter(obj, 0, 0, CANStandard, 0); } else { can_filter(obj, 0, 0, CANStandard, 14); } }
//****************************************************************************** void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow) { uint32_t ctrl = obj->uart->ctrl; // Disable hardware flow control ctrl &= ~(MXC_F_UART_CTRL_RTS_EN | MXC_F_UART_CTRL_CTS_EN); if (FlowControlNone != type) { // Check to see if we can use HW flow control UARTName uart_cts = (UARTName)pinmap_peripheral(txflow, PinMap_UART_CTS); UARTName uart_rts = (UARTName)pinmap_peripheral(rxflow, PinMap_UART_RTS); UARTName uart = (UARTName)pinmap_merge(uart_cts, uart_rts); // Make sure that the pins are pointing to the same UART MBED_ASSERT(uart != (UARTName)NC); if ((FlowControlCTS == type) || (FlowControlRTSCTS == type)) { // Make sure pin is in the PinMap MBED_ASSERT(uart_cts != (UARTName)NC); // Enable the pin for CTS function pinmap_pinout(txflow, PinMap_UART_CTS); // Enable active-low hardware flow control ctrl |= (MXC_F_UART_CTRL_CTS_EN | MXC_F_UART_CTRL_CTS_POLARITY); } if ((FlowControlRTS == type) || (FlowControlRTSCTS == type)) { // Make sure pin is in the PinMap MBED_ASSERT(uart_rts != (UARTName)NC); // Enable the pin for RTS function pinmap_pinout(rxflow, PinMap_UART_RTS); // Enable active-low hardware flow control ctrl |= (MXC_F_UART_CTRL_RTS_EN | MXC_F_UART_CTRL_RTS_POLARITY); } } obj->uart->ctrl = ctrl; }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // Determine the I2C to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (I2CName)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT(obj->i2c != (I2CName)NC); // Enable I2C1 clock and pinout if not done if ((obj->i2c == I2C_1) && !i2c1_inited) { i2c1_inited = 1; __HAL_RCC_I2C1_CONFIG(RCC_I2C1CLKSOURCE_SYSCLK); __I2C1_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } #if defined(I2C2_BASE) // Enable I2C2 clock and pinout if not done if ((obj->i2c == I2C_2) && !i2c2_inited) { i2c2_inited = 1; __I2C2_CLK_ENABLE(); // Configure I2C pins pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); } #endif // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default }
void i2c_init(i2c_t *obj, PinName sda, PinName scl) { // determine the SPI to use I2CName i2c_sda = (I2CName)pinmap_peripheral(sda, PinMap_I2C_SDA); I2CName i2c_scl = (I2CName)pinmap_peripheral(scl, PinMap_I2C_SCL); obj->i2c = (MPS2_I2C_TypeDef *)pinmap_merge(i2c_sda, i2c_scl); if ((int)obj->i2c == NC) { error("I2C pin mapping failed"); } pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); switch ((int)obj->i2c) { case I2C_2: CMSDK_GPIO0->ALTFUNCSET |= 0x8020; break; case I2C_3: CMSDK_GPIO1->ALTFUNCSET |= 0x8000; CMSDK_GPIO2->ALTFUNCSET |= 0x0200; break; } }
void serial_init(serial_t *obj, PinName tx, PinName rx) { uint32_t uart_tx = pinmap_peripheral(tx, PinMap_UART_TX); uint32_t uart_rx = pinmap_peripheral(rx, PinMap_UART_RX); obj->index = pinmap_merge(uart_tx, uart_rx); MBED_ASSERT((int)obj->index != NC); uint32_t uartSourceClock = CLOCK_SYS_GetUartFreq(obj->index); CLOCK_SYS_EnableUartClock(obj->index); uint32_t uart_addrs[] = UART_BASE_ADDRS; UART_HAL_Init(uart_addrs[obj->index]); UART_HAL_SetBaudRate(uart_addrs[obj->index], uartSourceClock, 9600); UART_HAL_SetParityMode(uart_addrs[obj->index], kUartParityDisabled); #if FSL_FEATURE_UART_HAS_STOP_BIT_CONFIG_SUPPORT UART_HAL_SetStopBitCount(uart_addrs[obj->index], kUartOneStopBit); #endif UART_HAL_SetBitCountPerChar(uart_addrs[obj->index], kUart8BitsPerChar); UART_HAL_DisableTransmitter(uart_addrs[obj->index]); UART_HAL_DisableReceiver(uart_addrs[obj->index]); pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { UART_HAL_FlushTxFifo(uart_addrs[obj->index]); UART_HAL_EnableTransmitter(uart_addrs[obj->index]); pin_mode(tx, PullUp); } if (rx != NC) { UART_HAL_EnableReceiver(uart_addrs[obj->index]); pin_mode(rx, PullUp); } if (obj->index == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void serial_init(serial_t *obj, PinName tx, PinName rx) { uint32_t uart_tx = pinmap_peripheral(tx, PinMap_UART_TX); uint32_t uart_rx = pinmap_peripheral(rx, PinMap_UART_RX); obj->index = pinmap_merge(uart_tx, uart_rx); MBED_ASSERT((int)obj->index != NC); /* Set the LPUART clock source */ if (obj->index == LPUART_0) { CLOCK_SetLpuart0Clock(1U); } else { CLOCK_SetLpuart1Clock(1U); } lpuart_config_t config; LPUART_GetDefaultConfig(&config); config.baudRate_Bps = 9600; config.enableTx = false; config.enableRx = false; LPUART_Init(uart_addrs[obj->index], &config, CLOCK_GetFreq(uart_clocks[obj->index])); pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); if (tx != NC) { LPUART_EnableTx(uart_addrs[obj->index], true); pin_mode(tx, PullUp); } if (rx != NC) { LPUART_EnableRx(uart_addrs[obj->index], true); pin_mode(rx, PullUp); } if (obj->index == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }