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_UART_TypeDef *)uart; // enable power switch (uart) { case UART_0: LPC_SC->PCONP |= 1 << 3; break; case UART_1: LPC_SC->PCONP |= 1 << 4; break; case UART_2: LPC_SC->PCONP |= 1 << 24; break; case UART_3: LPC_SC->PCONP |= 1 << 25; break; } // 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 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); 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); 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); serial_setup_clock(); lpuart_config_t config; LPUART_GetDefaultConfig(&config); config.baudRate_Bps = 9600; config.enableTx = false; config.enableRx = false; LPUART_Init(uart_addrs[obj->index], &config, serial_get_clock()); 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, PullDefault); } if (rx != NC) { LPUART_EnableRx(uart_addrs[obj->index], true); pin_mode(rx, PullDefault); } 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) { // 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); // OpenDrain must explicitly be enabled for p0.0 and p0.1 if (sda == P0_0) { pin_mode(sda, OpenDrain); } if (scl == P0_1) { pin_mode(scl, OpenDrain); } }
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 I2C clock if (obj->i2c == I2C_1) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE); RCC_I2CCLKConfig(RCC_I2C1CLK_SYSCLK); } if (obj->i2c == I2C_2) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); } // Configure I2C pins pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(scl, OpenDrain); pinmap_pinout(sda, PinMap_I2C_SDA); pin_mode(sda, OpenDrain); // 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 = (I2C_TypeDef *)pinmap_merge(i2c_sda, i2c_scl); MBED_ASSERT((int)obj->i2c != NC); // enable power i2c_power_enable(obj); pinmap_pinout(sda, PinMap_I2C_SDA); pinmap_pinout(scl, PinMap_I2C_SCL); pin_mode(sda, OpenDrain); pin_mode(scl, OpenDrain); // Force reset if the bus is stuck in the BUSY state if (obj->i2c->SR2 & I2C_SR2_BUSY) { obj->i2c->CR1 |= I2C_CR1_SWRST; obj->i2c->CR1 &= ~I2C_CR1_SWRST; } // Set the peripheral clock frequency obj->i2c->CR2 |= 42; // set default frequency at 100k i2c_frequency(obj, 100000); i2c_interface_enable(obj); }
void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow) { if (type == FlowControlRTSCTS || type == FlowControlRTS) { NRF_GPIO->DIR |= (1<<rxflow); pin_mode(rxflow, PullUp); obj->uart->PSELRTS = rxflow; obj->uart->CONFIG |= 0x01; // Enable HWFC } if (type == FlowControlRTSCTS || type == FlowControlCTS) { NRF_GPIO->DIR &= ~(1<<txflow); pin_mode(txflow, PullUp); obj->uart->PSELCTS = txflow; obj->uart->CONFIG |= 0x01; // Enable HWFC; } if (type == FlowControlNone) { obj->uart->PSELRTS = 0xFFFFFFFF; // Disable RTS obj->uart->PSELCTS = 0xFFFFFFFF; // Disable CTS obj->uart->CONFIG &= ~0x01; // Enable HWFC; } }
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); if (obj->i2c == (I2CName)NC) { error("I2C error: pinout mapping failed."); } // Enable I2C clock if (obj->i2c == I2C_1) { __HAL_RCC_I2C1_CONFIG(RCC_I2C1CLKSOURCE_SYSCLK); __I2C1_CLK_ENABLE(); } if (obj->i2c == I2C_2) { __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); // Reset to clear pending flags if any i2c_reset(obj); // I2C configuration i2c_frequency(obj, 100000); // 100 kHz per default }
void gpio_pin_enable(gpio_t *obj, uint8_t enable) { if (enable) { pin_mode(obj->pin, obj->mode); } else { pin_mode(obj->pin, Disabled); // TODO_LP return mode to default value } }
void spiflash_pins_init(void) { pin_mode(PIN_PTC0, PIN_MODE_MUX_ALT2); pin_mode(PIN_PTC5, PIN_MODE_MUX_ALT2); pin_mode(PIN_PTC6, PIN_MODE_MUX_ALT2); pin_mode(PIN_PTC7, PIN_MODE_MUX_ALT2); }
void can_init(can_t *obj, PinName rd, PinName td) { 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; } #if defined(CAN2_BASE) && (CAN_NUM == 2) else if (obj->can == CAN_2) { __HAL_RCC_CAN1_CLK_ENABLE(); // needed to set filters __HAL_RCC_CAN2_CLK_ENABLE(); obj->index = 1; } #endif 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); } 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"); } // Set initial CAN frequency to 100 kb/s can_frequency(obj, 100000); uint32_t filter_number = (obj->can == CAN_1) ? 0 : 14; 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 UART clock if (obj->uart == UART_1) { __USART1_FORCE_RESET(); __USART1_RELEASE_RESET(); __HAL_RCC_USART1_CLK_ENABLE(); obj->index = 0; } if (obj->uart == UART_2) { __USART2_FORCE_RESET(); __USART2_RELEASE_RESET(); __HAL_RCC_USART2_CLK_ENABLE(); obj->index = 1; } if (obj->uart == UART_3) { __USART3_FORCE_RESET(); __USART3_RELEASE_RESET(); __HAL_RCC_USART3_CLK_ENABLE(); obj->index = 2; } // Configure 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 pwmout_enable_pins(pwmout_t *obj, uint8_t enable) { if (enable) { pin_mode(obj->pin, PushPull); } else { // TODO_LP return PinMode to the previous state pin_mode(obj->pin, Disabled); } }
static void disable_power(void) { pin_mode(EZPORT_CS, PIN_MODE_MUX_ANALOG); pin_mode(EZPORT_CLK, PIN_MODE_MUX_ANALOG); pin_mode(EZPORT_DI, PIN_MODE_MUX_ANALOG); pin_mode(EZPORT_DO, PIN_MODE_MUX_ANALOG); pin_mode(EZPORT_POWER, PIN_MODE_MUX_ANALOG); }
USBHAL::USBHAL(void) { NVIC_DisableIRQ(OTG_FS_IRQn); epCallback[0] = &USBHAL::EP1_OUT_callback; epCallback[1] = &USBHAL::EP1_IN_callback; epCallback[2] = &USBHAL::EP2_OUT_callback; epCallback[3] = &USBHAL::EP2_IN_callback; epCallback[4] = &USBHAL::EP3_OUT_callback; epCallback[5] = &USBHAL::EP3_IN_callback; // Enable power and clocking RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; #if defined(TARGET_STM32F407VG) || defined(TARGET_STM32F401RE) || defined(TARGET_STM32F411RE) || defined(TARGET_STM32F412ZG) || defined(TARGET_STM32F429ZI) pin_function(PA_8, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); pin_function(PA_9, STM_PIN_DATA(STM_MODE_INPUT, GPIO_PULLDOWN, GPIO_AF10_OTG_FS)); pin_function(PA_10, STM_PIN_DATA(STM_MODE_AF_OD, GPIO_PULLUP, GPIO_AF10_OTG_FS)); pin_function(PA_11, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); pin_function(PA_12, STM_PIN_DATA(STM_MODE_AF_PP, GPIO_NOPULL, GPIO_AF10_OTG_FS)); #else pin_function(PA_8, STM_PIN_DATA(2, 10)); pin_function(PA_9, STM_PIN_DATA(0, 0)); pin_function(PA_10, STM_PIN_DATA(2, 10)); pin_function(PA_11, STM_PIN_DATA(2, 10)); pin_function(PA_12, STM_PIN_DATA(2, 10)); // Set ID pin to open drain with pull-up resistor pin_mode(PA_10, OpenDrain); GPIOA->PUPDR &= ~(0x3 << 20); GPIOA->PUPDR |= 1 << 20; // Set VBUS pin to open drain pin_mode(PA_9, OpenDrain); #endif RCC->AHB2ENR |= RCC_AHB2ENR_OTGFSEN; // Enable interrupts OTG_FS->GREGS.GAHBCFG |= (1 << 0); // Turnaround time to maximum value - too small causes packet loss OTG_FS->GREGS.GUSBCFG |= (0xF << 10); // Unmask global interrupts OTG_FS->GREGS.GINTMSK |= (1 << 3) | // SOF (1 << 4) | // RX FIFO not empty (1 << 12); // USB reset OTG_FS->DREGS.DCFG |= (0x3 << 0) | // Full speed (1 << 2); // Non-zero-length status OUT handshake OTG_FS->GREGS.GCCFG |= (1 << 19) | // Enable VBUS sensing (1 << 16); // Power Up instance = this; NVIC_SetVector(OTG_FS_IRQn, (uint32_t)&_usbisr); NVIC_SetPriority(OTG_FS_IRQn, 1); }
static void enable_spi(void) { spi_init(); pin_mode(EZPORT_CS, PIN_MODE_MUX_ALT2); pin_mode(EZPORT_CLK, PIN_MODE_MUX_ALT2); pin_mode(EZPORT_DI, PIN_MODE_MUX_ALT2); pin_mode(EZPORT_DO, PIN_MODE_MUX_ALT2); }
void spi_init(void) { pin_mode(SCLK, OUTPUT); pin_mode(MOSI, OUTPUT); pin_mode(SS, OUTPUT); /* Should be output in Master mode. */ SPCR &= ~(_BV(DORD)); /* MSB first. */ SPCR |= _BV(MSTR); /* Act as master. */ SPCR |= _BV(SPE); /* Enable SPI. */ }
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); MBED_ASSERT((int)uart != NC); obj->uart = (LPC_USART_Type *)uart; LPC_SYSCON->SYSAHBCLKCTRL |= (1<<12); // [TODO] Consider more elegant approach // disconnect USBTX/RX mapping mux, for case when switching ports #ifdef USBTX pin_function(USBTX, 0); pin_function(USBRX, 0); #endif // 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 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 if (tx != NC) { pin_mode(tx, PullUp); } if (rx != NC) { pin_mode(rx, PullUp); } switch (uart) { case UART_0: 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) { // 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); } if (obj->uart == UART_2) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); } if (obj->uart == UART_3) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); } if (obj->uart == UART_4) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART4, ENABLE); } if (obj->uart == UART_5) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART5, ENABLE); } // Configure the UART pins pinmap_pinout(tx, PinMap_UART_TX); pinmap_pinout(rx, PinMap_UART_RX); pin_mode(tx, PullUp); 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; if (obj->uart == UART_4) obj->index = 3; if (obj->uart == UART_5) obj->index = 4; // For stdio management if (obj->uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void i2c_enable_pins(i2c_t *obj, uint8_t enable) { if (enable) { pin_mode(obj->i2c.scl, WiredAndPullUp); pin_mode(obj->i2c.sda, WiredAndPullUp); } else { // TODO_LP return PinMode to the previous state pin_mode(obj->i2c.sda, Disabled); pin_mode(obj->i2c.scl, Disabled); } }
void gpio_init(gpio_t *obj, PinName pin, PinDirection direction) { if(pin == NC) return; obj->pin = pin; obj->mask = gpio_set(pin); #if defined(TARGET_LPC1768) || defined(TARGET_LPC2368) LPC_GPIO_TypeDef *port_reg = (LPC_GPIO_TypeDef *) ((int)pin & ~0x1F); obj->reg_set = &port_reg->FIOSET; obj->reg_clr = &port_reg->FIOCLR; obj->reg_in = &port_reg->FIOPIN; obj->reg_dir = &port_reg->FIODIR; #elif defined(TARGET_LPC11U24) unsigned int port = (unsigned int)pin >> PORT_SHIFT; obj->reg_set = &LPC_GPIO->SET[port]; obj->reg_clr = &LPC_GPIO->CLR[port]; obj->reg_in = &LPC_GPIO->PIN[port]; obj->reg_dir = &LPC_GPIO->DIR[port]; #elif defined(TARGET_LPC11Cxx) int gpionum = ((int) pin) >> 5; int pinnum = ((int) pin) & 0x1f; LPC_GPIO_TypeDef* lpc = 0; switch(gpionum) { case 0: lpc = LPC_GPIO0; break; case 1: lpc = LPC_GPIO1; break; case 2: lpc = LPC_GPIO2; break; case 3: lpc = LPC_GPIO3; break; default: { extern void abort(void); abort(); } } obj->reg_dir = &lpc->DIR; obj->reg_set = &lpc->MASKED_ACCESS[1<<pinnum]; // TODO(bracz) this is not strictly speaking true. You have to write 0 here // to clear the pin state. obj->reg_clr = &lpc->MASKED_ACCESS[1<<pinnum]; obj->reg_in = &lpc->DATA; #else #error CPU undefined. #endif gpio_dir(obj, direction); switch (direction) { case PIN_OUTPUT: pin_mode(pin, PullNone); break; case PIN_INPUT : pin_mode(pin, PullDown); break; } }
void config_pins() { // REMOTE_EN pin pin_mode(PIN_PTD3, PIN_MODE_MUX_GPIO); gpio_dir(PIN_PTD3, GPIO_OUTPUT); // UART pin_mode(PIN_PTA1, PIN_MODE_MUX_ALT2); pin_mode(PIN_PTA2, PIN_MODE_MUX_ALT2); // for I2C devices i2c_init(I2C_RATE_100); PORTB.pcr[pin_physpin_from_pin(PIN_PTB0)].raw = ((struct PCR_t) {.mux=2,.ode=1}).raw;
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)); } }
/** Set the input pin mode * * @param obj The GPIO object * @param mode The pin mode to be set */ void gpio_mode(gpio_t *obj, PinMode mode) { uint32_t pin = obj->gpioPin; /* Set the mode for the pin */ pin_mode((PinName)pin, mode); }
static void init(void) { /* set modes before to enable the port */ gpio_dir(PROG_BUTTON, GPIO_INPUT); pin_mode(PROG_BUTTON, PIN_MODE_PULLUP); gpio_dir(TARGET_RESET, GPIO_INPUT); gpio_dir(TARGET_LED, GPIO_INPUT); /* set digital debounce/filter */ pin_physport_from_pin(PROG_BUTTON)->dfcr.cs = PORT_CS_LPO; pin_physport_from_pin(PROG_BUTTON)->dfwr.filt = 31; /* button interrupt */ pin_physport_from_pin(PROG_BUTTON)->dfer |= 1 << pin_physpin_from_pin(PROG_BUTTON); pin_physport_from_pin(PROG_BUTTON)->pcr[pin_physpin_from_pin(PROG_BUTTON)].irqc = PCR_IRQC_INT_FALLING; /* reset interrupt */ pin_physport_from_pin(TARGET_RESET)->pcr[pin_physpin_from_pin(TARGET_RESET)].irqc = PCR_IRQC_INT_RISING; /* LED interrupt */ pin_physport_from_pin(TARGET_LED)->pcr[pin_physpin_from_pin(TARGET_LED)].irqc = PCR_IRQC_INT_FALLING; int_enable(IRQ_PORTD); gpio_dir(LED_SUCCESS, GPIO_OUTPUT); gpio_dir(LED_FAIL, GPIO_OUTPUT); timeout_init(); }
void analogout_init(dac_t *obj, PinName pin) { /* init in-memory structure */ obj->dac = (DAC_TypeDef *) pinmap_peripheral(pin, PinMap_DAC); MBED_ASSERT((int) obj->dac != NC); obj->channel = pin_location(pin, PinMap_DAC); MBED_ASSERT((int) obj->channel != NC); pin_mode(pin, Disabled); if (!dac_initialized) { /* Initialize the DAC. Will disable both DAC channels, so should only be done once */ /* Use default settings */ CMU_ClockEnable(cmuClock_DAC0, true); DAC_Init_TypeDef init = DAC_INIT_DEFAULT; /* Calculate the DAC clock prescaler value that will result in a DAC clock * close to 500kHz. Second parameter is zero. This uses the current HFPERCLK * frequency instead of setting a new one. */ init.prescale = DAC_PrescaleCalc(500000, REFERENCE_FREQUENCY); /* Set reference voltage to VDD */ init.reference = dacRefVDD; DAC_Init(obj->dac, &init); dac_initialized = 1; } /* Use default channel settings */ DAC_InitChannel_TypeDef initChannel = DAC_INITCHANNEL_DEFAULT; initChannel.enable = true; DAC_InitChannel(obj->dac, &initChannel, obj->channel); }
/* * This code will increase the PWM duty cycle from 0% to 100%, then * decrease it from 100% to 0%, and so on. */ int main(void) { int inc = 1; /* Currently incrementing */ long fract v = 0.0; /* Current PWM duty cycle */ /* Initialize FTM and set PWM pin mode */ ftm_init(); pin_mode(PIN_PTC1, PIN_MODE_MUX_ALT4); /* XXX: Switch to timeouts instead of busy-wait */ for (;;) { /* Increment or decrement PWM duty slightly */ if (inc) v += 0.00001lr; else v -= 0.00001lr; /* Switch between increment and decrement */ if (v >= 1 || v <= 0) inc = !inc; /* Set the actual PWM duty cycle */ ftm_set(FTM_CH0, v); } }
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) { RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE); obj->index = 0; } if (obj->uart == UART_2) { RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); obj->index = 1; } // 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; 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 serial_init(serial_t *obj, PinName tx, PinName rx) { UARTName uart = UART_0; MBED_ASSERT((int)uart != NC); 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 if (tx != NC) { pin_mode(tx, PullUp); } if (rx != NC) { pin_mode(rx, PullUp); } if (uart == STDIO_UART) { stdio_uart_inited = 1; memcpy(&stdio_uart, obj, sizeof(serial_t)); } }
void initialize() { // Disable timers 0, 1 LPC_CT16B0->TCR = TCR_OFF; LPC_CT16B1->TCR = TCR_OFF; //Power timers 0, 1 LPC_SYSCON->SYSAHBCLKCTRL |= 1 << (7 + 0); LPC_SYSCON->SYSAHBCLKCTRL |= 1 << (7 + 1); // Enable counter mode (non PWM) for timers 0, 1 LPC_CT16B0->PWMC = 0b0000; LPC_CT16B1->PWMC = 0b0000; // Reset functionality on MR0 controlling the counter time period LPC_CT16B0->MCR = (1 << 1); // Timer0: reset counter 0 o0 MR0 match LPC_CT16B1->MCR = (1 << 4); // Timer1: reset counter 1 on MR1 match // Set prescalers to 1. Timer is incremented 'SystemCoreClock' times a second. LPC_CT16B0->PR = 0; LPC_CT16B1->PR = 0; // TODO: is this reset needed? LPC_CT16B0->TCR = TCR_RESET; LPC_CT16B1->TCR = TCR_RESET; // Clear output on match (tone are off, keep outputs low). LPC_CT16B0->EMR = (0b01 << 4); // Timer0: output LOW on MR0 match LPC_CT16B1->EMR = (0b10 << 6); // Timer1: output HIGH on MR1 match // Set arbitrary cycle, just to have counter matches which sets // the outputs to desired values based on EMR setting. // Values don't matter much since we override latter when dialing // the tones. LPC_CT16B0->MR0 = COUNT(1000); LPC_CT16B1->MR1 = COUNT(1300); LPC_CT16B0->TCR = TCR_EN; LPC_CT16B1->TCR = TCR_EN; // Pinout // TODO: define a const for the PWM pin function 2. pin_function(P0_8, 2); // CT16B0_MAT0 pin_mode(P0_8, PullNone); pin_function(P0_22, 2); // CT16B1_MAT1 pin_mode(P0_22, PullNone); }
void port_mode(port_t *obj, PinMode mode) { uint32_t i; for (i = 0; i < 16; i++) { // Process all pins if (obj->mask & (1 << i)) { // If the pin is used pin_mode(port_pin(obj->port, i), mode); } } }