ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

LPC55S69_NS: Add explicit pinmap support

pull/11892/head
Przemyslaw Stekiel 2019-09-30 09:59:17 +02:00
parent a2320f2e5c
commit a83756504f
8 changed files with 321 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/analogin_api.c
View File

@ -32,19 +32,25 @@ extern void ADC_ClockPower_Configuration(void);
#define MAX_FADC 6000000
#define MAX_ADC_CLOCK 80000000
void analogin_init(analogin_t *obj, PinName pin)
#if EXPLICIT_PINMAP_READY
#define ANALOGIN_INIT_DIRECT analogin_init_direct
void analogin_init_direct(analogin_t *obj, const PinMap *pinmap)
#else
#define ANALOGIN_INIT_DIRECT _analogin_init_direct
static void _analogin_init_direct(analogin_t *obj, const PinMap *pinmap)
#endif
{
uint32_t clkval;
uint32_t clkdiv = 1;
obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC);
obj->adc = (ADCName)pinmap->peripheral;
MBED_ASSERT(obj->adc != (ADCName)NC);
uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;
adc_config_t adc_config;
uint32_t reg;
uint32_t pin_number = pin & 0x1F;
uint8_t port_number = pin / 32;
uint32_t pin_number = pinmap->pin & 0x1F;
uint8_t port_number = pinmap->pin / 32;
ADC_ClockPower_Configuration();
@ -64,13 +70,24 @@ void analogin_init(analogin_t *obj, PinName pin)
adc_config.clockDividerNumber = (clkdiv - 1);
ADC_Init(adc_addrs[instance], &adc_config);
pinmap_pinout(pin, PinMap_ADC);
pin_function(pinmap->pin, pinmap->function);
pin_mode(pinmap->pin, PullNone);
/* Clear the DIGIMODE & MODE bits */
reg = IOCON->PIO[port_number][pin_number] & ~(IOCON_PIO_DIGIMODE_MASK | IOCON_PIO_MODE_MASK);
IOCON->PIO[port_number][pin_number] = reg;
}
void analogin_init(analogin_t *obj, PinName pin)
{
int peripheral = (int)pinmap_peripheral(pin, PinMap_ADC);
int function = (int)pinmap_find_function(pin, PinMap_ADC);
const PinMap explicit_pinmap = {pin, peripheral, function};
ANALOGIN_INIT_DIRECT(obj, &explicit_pinmap);
}
uint16_t analogin_read_u16(analogin_t *obj)
{
uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;

33
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/i2c_api.c
View File

@ -26,11 +26,15 @@
/* Array of I2C peripheral base address. */
static I2C_Type *const i2c_addrs[] = I2C_BASE_PTRS;
void i2c_init(i2c_t *obj, PinName sda, PinName scl)
#if EXPLICIT_PINMAP_READY
#define I2C_INIT_DIRECT i2c_init_direct
void i2c_init_direct(i2c_t *obj, const i2c_pinmap_t *pinmap)
#else
#define I2C_INIT_DIRECT _i2c_init_direct
static void _i2c_init_direct(i2c_t *obj, const i2c_pinmap_t *pinmap)
#endif
{
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);
obj->instance = (uint32_t) pinmap->peripheral;
obj->next_repeated_start = 0;
obj->issue_start = 0;
MBED_ASSERT((int)obj->instance != NC);
@ -87,8 +91,25 @@ void i2c_init(i2c_t *obj, PinName sda, PinName scl)
I2C_MasterGetDefaultConfig(&master_config);
I2C_MasterInit(i2c_addrs[obj->instance], &master_config, 12000000);
pinmap_pinout(sda, PinMap_I2C_SDA);
pinmap_pinout(scl, PinMap_I2C_SCL);
pin_function(pinmap->sda_pin, pinmap->sda_function);
pin_mode(pinmap->sda_pin, PullNone);
pin_function(pinmap->scl_pin, pinmap->scl_function);
pin_mode(pinmap->scl_pin, PullNone);
}
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);
int peripheral = (int)pinmap_merge(i2c_sda, i2c_scl);
int sda_function = (int)pinmap_find_function(sda, PinMap_I2C_SDA);
int scl_function = (int)pinmap_find_function(scl, PinMap_I2C_SCL);
const i2c_pinmap_t explicit_i2c_pinmap = {peripheral, sda, sda_function, scl, scl_function};
I2C_INIT_DIRECT(obj, &explicit_i2c_pinmap);
}
int i2c_start(i2c_t *obj)

29
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/lp_analogin_api.c
View File

@ -32,18 +32,24 @@ extern void ADC_ClockPower_Configuration(void);
#define LPADC_USER_CMDID 1U /* CMD1 */
void analogin_init(analogin_t *obj, PinName pin)
#if EXPLICIT_PINMAP_READY
#define ANALOGIN_INIT_DIRECT analogin_init_direct
void analogin_init_direct(analogin_t *obj, const PinMap *pinmap)
#else
#define ANALOGIN_INIT_DIRECT _analogin_init_direct
static void _analogin_init_direct(analogin_t *obj, const PinMap *pinmap)
#endif
{
gpio_t gpio;
obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC);
obj->adc = (ADCName)pinmap->peripheral;
MBED_ASSERT(obj->adc != (ADCName)NC);
uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;
lpadc_config_t adc_config;
uint32_t reg;
uint32_t pin_number = pin & 0x1F;
uint8_t port_number = pin / 32;
uint32_t pin_number = pinmap->pin & 0x1F;
uint8_t port_number = pinmap->pin / 32;
ADC_ClockPower_Configuration();
@ -75,10 +81,11 @@ void analogin_init(analogin_t *obj, PinName pin)
LPADC_DoAutoCalibration(adc_addrs[instance]);
#endif /* FSL_FEATURE_LPADC_HAS_CFG_CALOFS */
pinmap_pinout(pin, PinMap_ADC);
pin_function(pinmap->pin, pinmap->function);
pin_mode(pinmap->pin, PullNone);
/* Need to ensure the pin is in input mode */
gpio_init(&gpio, pin);
gpio_init(&gpio, pinmap->pin);
gpio_dir(&gpio, PIN_INPUT);
reg = IOCON->PIO[port_number][pin_number];
@ -101,6 +108,16 @@ void analogin_init(analogin_t *obj, PinName pin)
IOCON->PIO[port_number][pin_number] = reg;
}
void analogin_init(analogin_t *obj, PinName pin)
{
int peripheral = (int)pinmap_peripheral(pin, PinMap_ADC);
int function = (int)pinmap_find_function(pin, PinMap_ADC);
const PinMap explicit_pinmap = {pin, peripheral, function};
ANALOGIN_INIT_DIRECT(obj, &explicit_pinmap);
}
uint16_t analogin_read_u16(analogin_t *obj)
{
uint32_t instance = obj->adc >> ADC_INSTANCE_SHIFT;

82
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/serial_api.c
View File

@ -38,11 +38,15 @@ static USART_Type *const uart_addrs[] = USART_BASE_PTRS;
int stdio_uart_inited = 0;
serial_t stdio_uart;
void serial_init(serial_t *obj, PinName tx, PinName rx)
#if EXPLICIT_PINMAP_READY
#define SERIAL_INIT_DIRECT serial_init_direct
void serial_init_direct(serial_t *obj, const serial_pinmap_t *pinmap)
#else
#define SERIAL_INIT_DIRECT _serial_init_direct
static void _serial_init_direct(serial_t *obj, const serial_pinmap_t *pinmap)
#endif
{
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);
obj->index = (uint32_t)pinmap->peripheral;
MBED_ASSERT((int)obj->index != NC);
usart_config_t config;
@ -101,14 +105,14 @@ void serial_init(serial_t *obj, PinName tx, PinName rx)
USART_Init(uart_addrs[obj->index], &config, 12000000);
pinmap_pinout(tx, PinMap_UART_TX);
pinmap_pinout(rx, PinMap_UART_RX);
pin_function(pinmap->tx_pin, pinmap->tx_function);
pin_function(pinmap->rx_pin, pinmap->rx_function);
if (tx != NC) {
pin_mode(tx, PullUp);
if (pinmap->tx_pin != NC) {
pin_mode(pinmap->tx_pin, PullUp);
}
if (rx != NC) {
pin_mode(rx, PullUp);
if (pinmap->rx_pin != NC) {
pin_mode(pinmap->rx_pin, PullUp);
}
if (obj->index == STDIO_UART) {
@ -117,6 +121,21 @@ void serial_init(serial_t *obj, PinName tx, PinName rx)
}
}
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);
int peripheral = (int)pinmap_merge(uart_tx, uart_rx);
int tx_function = (int)pinmap_find_function(tx, PinMap_UART_TX);
int rx_function = (int)pinmap_find_function(rx, PinMap_UART_RX);
const serial_pinmap_t explicit_uart_pinmap = {peripheral, tx, tx_function, rx, rx_function, false};
SERIAL_INIT_DIRECT(obj, &explicit_uart_pinmap);
}
void serial_free(serial_t *obj)
{
USART_Deinit(uart_addrs[obj->index]);
@ -386,39 +405,45 @@ void serial_break_clear(serial_t *obj)
/*
* Only hardware flow control is implemented in this API.
*/
void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
#if EXPLICIT_PINMAP_READY
#define SERIAL_SET_FC_DIRECT serial_set_flow_control_direct
void serial_set_flow_control_direct(serial_t *obj, FlowControl type, const serial_fc_pinmap_t *pinmap)
#else
#define SERIAL_SET_FC_DIRECT _serial_set_flow_control_direct
static void _serial_set_flow_control_direct(serial_t *obj, FlowControl type, const serial_fc_pinmap_t *pinmap)
#endif
{
gpio_t gpio;
switch(type) {
case FlowControlRTS:
pinmap_pinout(rxflow, PinMap_UART_RTS);
pin_function(pinmap->rx_flow_pin, pinmap->rx_flow_function);
pin_mode(pinmap->rx_flow_pin, PullNone);
uart_addrs[obj->index]->CFG &= ~USART_CFG_CTSEN_MASK;
break;
case FlowControlCTS:
/* Do not use RTS, configure pin to GPIO input */
if (rxflow != NC) {
gpio_init(&gpio, rxflow);
gpio_dir(&gpio, PIN_INPUT);
}
gpio_init(&gpio, pinmap->rx_flow_pin);
gpio_dir(&gpio, PIN_INPUT);
pinmap_pinout(txflow, PinMap_UART_CTS);
pin_function(pinmap->tx_flow_pin, pinmap->tx_flow_function);
pin_mode(pinmap->tx_flow_pin, PullNone);
uart_addrs[obj->index]->CFG |= USART_CFG_CTSEN_MASK;
break;
case FlowControlRTSCTS:
pinmap_pinout(rxflow, PinMap_UART_RTS);
pinmap_pinout(txflow, PinMap_UART_CTS);
pin_function(pinmap->rx_flow_pin, pinmap->rx_flow_function);
pin_mode(pinmap->rx_flow_pin, PullNone);
pin_function(pinmap->tx_flow_pin, pinmap->tx_flow_function);
pin_mode(pinmap->tx_flow_pin, PullNone);
uart_addrs[obj->index]->CFG |= USART_CFG_CTSEN_MASK;
break;
case FlowControlNone:
/* Do not use RTS, configure pin to GPIO input */
if (rxflow != NC) {
gpio_init(&gpio, rxflow);
gpio_dir(&gpio, PIN_INPUT);
}
gpio_init(&gpio, pinmap->rx_flow_pin);
gpio_dir(&gpio, PIN_INPUT);
uart_addrs[obj->index]->CFG &= ~USART_CFG_CTSEN_MASK;
break;
@ -427,6 +452,17 @@ void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, Pi
break;
}
}
void serial_set_flow_control(serial_t *obj, FlowControl type, PinName rxflow, PinName txflow)
{
int tx_flow_function = (int)pinmap_find_function(txflow, PinMap_UART_CTS);
int rx_flow_function = (int)pinmap_find_function(rxflow, PinMap_UART_RTS);
const serial_fc_pinmap_t explicit_uart_fc_pinmap = {0, txflow, tx_flow_function, rxflow, rx_flow_function};
SERIAL_SET_FC_DIRECT(obj, type, &explicit_uart_fc_pinmap);
}
#endif
const PinMap *serial_tx_pinmap()
{

57
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC/spi_api.c
View File

@ -30,17 +30,15 @@
static SPI_Type *const spi_address[] = SPI_BASE_PTRS;
static int baud_rate = 0;
void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel)
#if EXPLICIT_PINMAP_READY
#define SPI_INIT_DIRECT spi_init_direct
void spi_init_direct(spi_t *obj, const spi_pinmap_t *pinmap)
#else
#define SPI_INIT_DIRECT _spi_init_direct
static void _spi_init_direct(spi_t *obj, const spi_pinmap_t *pinmap)
#endif
{
// 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);
obj->instance = pinmap->peripheral;
MBED_ASSERT((int)obj->instance != NC);
obj->ssel_num = 0;
@ -92,15 +90,42 @@ void spi_init(spi_t *obj, PinName mosi, PinName miso, PinName sclk, PinName ssel
}
// 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);
obj->ssel_num = pinmap_function(ssel, PinMap_SPI_SSEL) >> SSELNUM_SHIFT;
pin_function(pinmap->mosi_pin, pinmap->mosi_function);
pin_mode(pinmap->mosi_pin, PullNone);
pin_function(pinmap->miso_pin, pinmap->miso_function);
pin_mode(pinmap->miso_pin, PullNone);
pin_function(pinmap->sclk_pin, pinmap->sclk_function);
pin_mode(pinmap->sclk_pin, PullNone);
if (pinmap->ssel_pin != NC) {
pin_function(pinmap->ssel_pin, pinmap->ssel_function);
pin_mode(pinmap->ssel_pin, PullNone);
obj->ssel_num = pinmap->ssel_function >> SSELNUM_SHIFT;
}
}
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);
int peripheral = (int)pinmap_merge(spi_data, spi_cntl);
// pin out the spi pins
int mosi_function = (int)pinmap_find_function(mosi, PinMap_SPI_MOSI);
int miso_function = (int)pinmap_find_function(miso, PinMap_SPI_MISO);
int sclk_function = (int)pinmap_find_function(sclk, PinMap_SPI_SCLK);
int ssel_function = (int)pinmap_find_function(ssel, PinMap_SPI_SSEL);
const spi_pinmap_t explicit_spi_pinmap = {peripheral, mosi, mosi_function, miso, miso_function, sclk, sclk_function, ssel, ssel_function};
SPI_INIT_DIRECT(obj, &explicit_spi_pinmap);
}
void spi_free(spi_t *obj)
{
SPI_Deinit(spi_address[obj->instance]);

145
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC55S69/TARGET_LPCXpresso/PeripheralPinMaps.h Normal file
View File

@ -0,0 +1,145 @@
/* mbed Microcontroller Library
* Copyright (c) 2006-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MBED_PERIPHERALPINMAPS_H
#define MBED_PERIPHERALPINMAPS_H
#include <mstd_cstddef>
/************RTC***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_RTC[] = {
{NC, OSC32KCLK, 0},
};
/************ADC***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_ADC[] = {
{P0_23, ADC0_SE0, 0},
{P0_10, ADC0_SE1, 0},
{P0_31, ADC0_SE3, 0},
{P1_8, ADC0_SE4, 0},
{P2_0, ADC0_SE5, 0},
{P2_13, ADC0_SE6, 0},
{P2_11, ADC0_SE7, 0},
{NC , NC , 0}
};
/************CAN***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_CAN_TD[] = {
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_CAN_RD[] = {
{NC , NC , 0}
};
/************DAC***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_DAC[] = {
{NC , NC , 0}
};
/************I2C***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_I2C_SDA[] = {
{P0_13, I2C_0, 1},
{P1_21, I2C_1, 5},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_I2C_SCL[] = {
{P0_14, I2C_0, 1},
{P1_20, I2C_1, 5},
{NC , NC , 0}
};
/************UART***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_UART_TX[] = {
{P0_30, UART_0, 1},
{P1_6, UART_0, 1},
{P0_27, UART_1, 1},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_UART_RX[] = {
{P0_29, UART_0, 1},
{P1_5, UART_0, 1},
{P1_24, UART_1, 1},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_UART_CTS[] = {
{P1_8, UART_0, 1},
{P1_26, UART_1, 1},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_UART_RTS[] = {
{P1_7, UART_0, 1},
{P1_27, UART_1, 1},
{NC , NC , 0}
};
/************SPI***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_SPI_SCLK[] = {
{P0_6, SPI_0, 1},
{P0_21, SPI_1, 7},
{P1_2, SPI_2, 6},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_SPI_MOSI[] = {
{P0_3, SPI_0, 1},
{P0_20, SPI_1, 7},
{P0_26, SPI_2, 9},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_SPI_MISO[] = {
{P0_2, SPI_0, 1},
{P0_19, SPI_1, 7},
{P1_3, SPI_2, 6},
{NC , NC , 0}
};
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_SPI_SSEL[] = {
{P0_4, SPI_0, 8},
{P1_20, SPI_1, ((1 << SSELNUM_SHIFT) | 1)},
{P1_1, SPI_2, ((1 << SSELNUM_SHIFT) | 5)},
{NC , NC , 0}
};
/************PWM***************/
MSTD_CONSTEXPR_OBJ_11 PinMap PinMap_PWM[] = {
{NC , NC , 0}
};
#define PINMAP_ANALOGIN PinMap_ADC
#define PINMAP_ANALOGOUT PinMap_DAC
#define PINMAP_I2C_SDA PinMap_I2C_SDA
#define PINMAP_I2C_SCL PinMap_I2C_SCL
#define PINMAP_UART_TX PinMap_UART_TX
#define PINMAP_UART_RX PinMap_UART_RX
#define PINMAP_UART_CTS PinMap_UART_CTS
#define PINMAP_UART_RTS PinMap_UART_RTS
#define PINMAP_SPI_SCLK PinMap_SPI_SCLK
#define PINMAP_SPI_MOSI PinMap_SPI_MOSI
#define PINMAP_SPI_MISO PinMap_SPI_MISO
#define PINMAP_SPI_SSEL PinMap_SPI_SSEL
#define PINMAP_PWM PinMap_PWM
#define PINMAP_CAN_TD PinMap_CAN_TD
#define PINMAP_CAN_RD PinMap_CAN_RD
#endif

107
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC55S69/TARGET_LPCXpresso/PeripheralPins.c
View File

@ -15,109 +15,4 @@
*/
#include "PeripheralPins.h"
/************RTC***************/
const PinMap PinMap_RTC[] = {
{NC, OSC32KCLK, 0},
};
/************ADC***************/
const PinMap PinMap_ADC[] = {
{P0_23, ADC0_SE0, 0},
{P0_10, ADC0_SE1, 0},
{P0_31, ADC0_SE3, 0},
{P1_8, ADC0_SE4, 0},
{P2_0, ADC0_SE5, 0},
{P2_13, ADC0_SE6, 0},
{P2_11, ADC0_SE7, 0},
{NC , NC , 0}
};
/************CAN***************/
const PinMap PinMap_CAN_TD[] = {
{NC , NC , 0}
};
const PinMap PinMap_CAN_RD[] = {
{NC , NC , 0}
};
/************DAC***************/
const PinMap PinMap_DAC[] = {
{NC , NC , 0}
};
/************I2C***************/
const PinMap PinMap_I2C_SDA[] = {
{P0_13, I2C_0, 1},
{P1_21, I2C_1, 5},
{NC , NC , 0}
};
const PinMap PinMap_I2C_SCL[] = {
{P0_14, I2C_0, 1},
{P1_20, I2C_1, 5},
{NC , NC , 0}
};
/************UART***************/
const PinMap PinMap_UART_TX[] = {
{P0_30, UART_0, 1},
{P1_6, UART_0, 1},
{P0_27, UART_1, 1},
{NC , NC , 0}
};
const PinMap PinMap_UART_RX[] = {
{P0_29, UART_0, 1},
{P1_5, UART_0, 1},
{P1_24, UART_1, 1},
{NC , NC , 0}
};
const PinMap PinMap_UART_CTS[] = {
{P1_8, UART_0, 1},
{P1_26, UART_1, 1},
{NC , NC , 0}
};
const PinMap PinMap_UART_RTS[] = {
{P1_7, UART_0, 1},
{P1_27, UART_1, 1},
{NC , NC , 0}
};
/************SPI***************/
const PinMap PinMap_SPI_SCLK[] = {
{P0_6, SPI_0, 1},
{P0_21, SPI_1, 7},
{P1_2, SPI_2, 6},
{NC , NC , 0}
};
const PinMap PinMap_SPI_MOSI[] = {
{P0_3, SPI_0, 1},
{P0_20, SPI_1, 7},
{P0_26, SPI_2, 9},
{NC , NC , 0}
};
const PinMap PinMap_SPI_MISO[] = {
{P0_2, SPI_0, 1},
{P0_19, SPI_1, 7},
{P1_3, SPI_2, 6},
{NC , NC , 0}
};
const PinMap PinMap_SPI_SSEL[] = {
{P0_4, SPI_0, 8},
{P1_20, SPI_1, ((1 << SSELNUM_SHIFT) | 1)},
{P1_1, SPI_2, ((1 << SSELNUM_SHIFT) | 5)},
{NC , NC , 0}
};
/************PWM***************/
const PinMap PinMap_PWM[] = {
{NC , NC , 0}
};
#include "PeripheralPinMaps.h"

3
targets/TARGET_NXP/TARGET_MCUXpresso_MCUS/TARGET_LPC55S69/TARGET_LPCXpresso/PinNames.h
View File

@ -22,6 +22,9 @@
extern "C" {
#endif
/* If this macro is defined, then constexpr utility functions for pin-map seach can be used. */
#define EXPLICIT_PINMAP_READY 1
typedef enum {
PIN_INPUT,
PIN_OUTPUT