AJ_Status AJS_TargetIO_SpiOpen(uint8_t mosi, uint8_t miso, uint8_t cs, uint8_t clk, uint32_t clock,
uint8_t master, uint8_t cpol, uint8_t cpha, uint8_t data, void** spiCtx)
{
SPI_Pin* spi;
uint8_t mode = 0;
uint16_t mosiPin = AJS_TargetIO_GetInfo(mosi)->physicalPin;
uint16_t misoPin = AJS_TargetIO_GetInfo(miso)->physicalPin;
uint16_t csPin = AJS_TargetIO_GetInfo(cs)->physicalPin;
uint16_t clkPin = AJS_TargetIO_GetInfo(clk)->physicalPin;
uint8_t indexMosi, indexMiso, indexCs, indexClk;
/*
* Get the pin information for all the SPI pins
*/
for (indexMosi = 0; indexMosi < ArraySize(spiInfo); ++indexMosi) {
if (spiInfo[indexMosi].pinNum == mosiPin) {
break;
}
}
for (indexMiso = 0; indexMiso < ArraySize(spiInfo); ++indexMiso) {
if (spiInfo[indexMiso].pinNum == misoPin) {
break;
}
}
for (indexCs = 0; indexCs < ArraySize(spiInfo); ++indexCs) {
if (spiInfo[indexCs].pinNum == csPin) {
break;
}
}
for (indexClk = 0; indexClk < ArraySize(spiInfo); ++indexClk) {
if (spiInfo[indexClk].pinNum == clkPin) {
break;
}
}
spi = (SPI_Pin*)AJS_Alloc(NULL, sizeof(SPI_Pin));
spi->object = new SPI((PinName)spiInfo[indexMosi].pinId, (PinName)spiInfo[indexMiso].pinId, (PinName)spiInfo[indexClk].pinId);
spi->cs = new DigitalOut((PinName)spiInfo[indexCs].pinId);
spi->object->frequency(clock);
/*
* Mode cpol cpha
* 0 0 0
* 1 0 1
* 2 1 0
* 3 1 1
*/
mode = (cpol << 1 | cpha << 0);
if (mode > 3) {
AJ_ErrPrintf(("AJS_TargetIO_SpiOpen(): cpol/cpha must be either 0 or 1\n"));
return AJ_ERR_UNEXPECTED;
}
spi->object->format(data, mode);
*spiCtx = spi;
return AJ_OK;
}
AJ_Status AJS_TargetIO_PinOpen(uint16_t pinIndex, AJS_IO_PinConfig config, void** pinCtx)
{
GPIO* gpio;
GPIO_InitTypeDef GPIO_Pin;
size_t pin;
uint16_t physicalPin = AJS_TargetIO_GetInfo(pinIndex)->physicalPin;
for (pin = 0; pin < ArraySize(pinInfo); ++pin) {
if (pinInfo[pin].pinNum == physicalPin) {
break;
}
}
if (pin >= ArraySize(pinInfo)) {
return AJ_ERR_INVALID;
}
gpio = AJS_Alloc(NULL, sizeof(GPIO));
memset(gpio, 0, sizeof(GPIO));
gpio->trigId = -1;
gpio->gpioAF = 0;
gpio->GPIOx = pinInfo[pin].GPIOx;
gpio->gpioPin = pinInfo[pin].physicalPin;
GPIO_Pin.GPIO_Speed = GPIO_Speed_50MHz;
if (config & AJS_IO_PIN_OUTPUT) {
GPIO_Pin.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Pin.GPIO_OType = GPIO_OType_PP;
GPIO_Pin.GPIO_Pin = pinInfo[pin].physicalPin;
GPIO_Pin.GPIO_PuPd = GPIO_PuPd_UP;
} else if (config & AJS_IO_PIN_INPUT) {
GPIO_Pin.GPIO_Mode = GPIO_Mode_IN;
GPIO_Pin.GPIO_OType = GPIO_OType_PP;
GPIO_Pin.GPIO_Pin = pinInfo[pin].physicalPin;
GPIO_Pin.GPIO_PuPd = GPIO_PuPd_UP;
} else {
if (config & AJS_IO_PIN_OPEN_DRAIN) {
GPIO_Pin.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Pin.GPIO_OType = GPIO_OType_OD;
GPIO_Pin.GPIO_Pin = pinInfo[pin].physicalPin;
GPIO_Pin.GPIO_PuPd = GPIO_PuPd_UP;
} else if (config & AJS_IO_PIN_PULL_UP) {
GPIO_Pin.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Pin.GPIO_OType = GPIO_OType_PP;
GPIO_Pin.GPIO_Pin = pinInfo[pin].physicalPin;
GPIO_Pin.GPIO_PuPd = GPIO_PuPd_UP;
} else {
GPIO_Pin.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Pin.GPIO_OType = GPIO_OType_PP;
GPIO_Pin.GPIO_Pin = pinInfo[pin].physicalPin;
GPIO_Pin.GPIO_PuPd = GPIO_PuPd_DOWN;
}
}
GPIO_Init(gpio->GPIOx, &GPIO_Pin);
*pinCtx = gpio;
return AJ_OK;
}
AJ_Status AJS_TargetIO_I2cOpen(uint8_t sda, uint8_t scl, uint32_t clock, uint8_t mode, uint8_t ownAddress, void** ctx)
{
GPIO_InitTypeDef i2cGPIO;
I2C_InitTypeDef i2cInit;
uint16_t sdaPin = AJS_TargetIO_GetInfo(sda)->physicalPin;
uint16_t sclPin = AJS_TargetIO_GetInfo(scl)->physicalPin;
uint8_t indexSda, indexScl;
I2C_Pin* i2cPin;
uint8_t pinSource;
i2cPin = AJS_Alloc(NULL, sizeof(I2C_Pin));
RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
for (indexSda = 0; indexSda < ArraySize(i2cInfo); indexSda++) {
if (i2cInfo[indexSda].pinNum == sda) {
break;
}
}
for (indexScl = 0; indexScl < ArraySize(i2cInfo); indexScl++) {
if (i2cInfo[indexScl].pinNum == scl) {
break;
}
}
i2cGPIO.GPIO_Pin = i2cInfo[indexSda].physicalPin | i2cInfo[indexScl].physicalPin;
i2cGPIO.GPIO_Mode = GPIO_Mode_AF;
i2cGPIO.GPIO_OType = GPIO_OType_OD;
i2cGPIO.GPIO_PuPd = GPIO_PuPd_UP;
i2cGPIO.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(i2cInfo[indexSda].GPIOx, &i2cGPIO);
pinSource = pinToSource(i2cInfo[indexSda].physicalPin);
GPIO_PinAFConfig(i2cInfo[indexSda].GPIOx, pinSource, GPIO_AF_I2C1);
pinSource = pinToSource(i2cInfo[indexScl].physicalPin);
GPIO_PinAFConfig(i2cInfo[indexScl].GPIOx, pinSource, GPIO_AF_I2C1);
i2cInit.I2C_Ack = I2C_Ack_Disable;
i2cInit.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
i2cInit.I2C_ClockSpeed = clock;
i2cInit.I2C_DutyCycle = I2C_DutyCycle_2;
i2cInit.I2C_Mode = I2C_Mode_I2C;
i2cInit.I2C_OwnAddress1 = 0x00;
I2C_Init(I2C1, &i2cInit);
I2C_Cmd(I2C1, ENABLE);
*ctx = i2cCtx;
return AJ_OK;
}
extern "C" AJ_Status AJS_TargetIO_PinOpen(uint16_t pinIndex, AJS_IO_PinConfig config, void** pinCtx)
{
GPIO* gpio;
size_t pin;
uint16_t physicalPin = AJS_TargetIO_GetInfo(pinIndex)->physicalPin;
for (pin = 0; pin < ArraySize(pinInfo); ++pin) {
if (pinInfo[pin].pinNum == physicalPin) {
break;
}
}
if (pin >= ArraySize(pinInfo)) {
return AJ_ERR_INVALID;
}
gpio = (GPIO*)AJS_Alloc(NULL, sizeof(GPIO));
memset(gpio, 0, sizeof(GPIO));
/*
* Find if this is a digitalOut, digitalIn or both
*/
uint32_t direction = AJS_TargetIO_GetInfo(pinIndex)->functions;
if (direction & AJS_IO_FUNCTION_DIGITAL_OUT) {
gpio->out = new DigitalOut((PinName)pinInfo[pin].pinId, 0);
*(gpio->out) = 0;
} else if ((direction & AJS_IO_FUNCTION_DIGITAL_IN) && (config != AJS_IO_PIN_OUTPUT)) {
gpio->in = new DigitalIn((PinName)pinInfo[pin].pinId);
switch (config) {
case (AJS_IO_PIN_OPEN_DRAIN):
//gpio->in->mode(OpenDrain); //TODO: This enum does not exist
break;
case (AJS_IO_PIN_PULL_UP):
gpio->in->mode(PullUp);
break;
case (AJS_IO_PIN_PULL_DOWN):
gpio->in->mode(PullDown);
break;
default:
break;
}
} else {
gpio->inOut = new DigitalInOut((PinName)pinInfo[pin].pinId);
}
gpio->trigId = -1;
gpio->pinIdx = pinIndex;
*pinCtx = gpio;
return AJ_OK;
}
AJ_Status AJS_TargetIO_AdcOpen(uint16_t pinIndex, void** adcCtx)
{
ADC* adc;
size_t pin;
uint16_t physicalPin = AJS_TargetIO_GetInfo(pinIndex)->physicalPin;
for (pin = 0; pin < ArraySize(pinInfo); ++pin) {
if (pinInfo[pin].pinNum == physicalPin) {
break;
}
}
if (pin >= ArraySize(pinInfo)) {
return AJ_ERR_INVALID;
}
adc = (ADC*)AJS_Alloc(NULL, sizeof(ADC));
memset(adc, 0, sizeof(ADC));
adc->adcObj = new AnalogIn((PinName)pinInfo[pin].pinId);
*adcCtx = adc;
return AJ_OK;
}
AJ_Status AJS_TargetIO_UartOpen(uint8_t txPin, uint8_t rxPin, uint32_t baud, void** uartCtx)
{
UART* uart;
uint16_t pinTx, pinRx;
uint16_t physicalTxPin = AJS_TargetIO_GetInfo(txPin)->physicalPin;
uint16_t physicalRxPin = AJS_TargetIO_GetInfo(rxPin)->physicalPin;
for (pinTx = 0; pinTx < ArraySize(uartInfo); ++pinTx) {
if (uartInfo[pinTx].pinNum == physicalTxPin) {
break;
}
}
// Make sure the pin exists and its a TX pin
if (pinTx >= ArraySize(uartInfo) || uartInfo[pinTx].function != AJS_IO_FUNCTION_UART_TX) {
return AJ_ERR_INVALID;
}
for (pinRx = 0; pinRx < ArraySize(uartInfo); ++pinRx) {
if (uartInfo[pinRx].pinNum == physicalRxPin) {
break;
}
}
// Make sure the pin exists and its an RX pin
if (pinRx >= ArraySize(uartInfo) || uartInfo[pinRx].function != AJS_IO_FUNCTION_UART_RX) {
return AJ_ERR_INVALID;
}
// Dont initialize the UART peripheral, just point the object to the current UART class
if (uartInfo[pinTx].init == false || uartInfo[pinRx].init == false) {
uart->object = pc;
*uartCtx = uart;
return AJ_OK;
}
uart = (UART*)AJS_Alloc(NULL, sizeof(UART));
uart->object = new Serial((PinName)uartInfo[pinTx].pinId, (PinName)uartInfo[pinRx].pinId);
uart->object->baud(baud);
*uartCtx = uart;
return AJ_OK;
}
