外设

/:io
io gpio     -- io gpio [GPIONum] [IN:1/OUT:0] [H:1/L:0]
io gpiodrv  -- io gpiodrv [GPIONum] [Level]
io gpiopull -- io gpiopull [GPIONum] [pull enable] [pull H/L]
io pwm      -- io pwm [PWMIndex] [PadMode] [Freq(Hz)] [shift(%)] [duty(%)] [NOT invert]

/:io gpio 15 0 1
====GPIO : 15 ,Is Input? : 0, H/L : 0====

/:io gpio 15 0 0
====GPIO : 15 ,Is Input? : 0, H/L : 1====

I2CErrorCode_e DrvI2cOpen(s32 *pHandle, I2COptions_t *psI2cSettings);
I2CErrorCode_e DrvI2cClose(s32 nHandle);
I2CErrorCode_e DrvI2cWrite(s32 nHandle, void * pDataToWrite, u32 nNbBytes, bool bStopBit);
I2CErrorCode_e DrvI2cRead(s32 nHandle, void * pDataToRead, u32 nNbBytes);
I2CErrorCode_e DrvI2cWriteAndRead(s32 nHandle, void * pDataToWrite, u32 nNbBytesToWrite, void * pDataToRead, u32 nNbBytesToRead);
I2CErrorCode_e DrvI2cOpenSW(u32 nAddress, I2cClockSpeed_e eClkSpeed, IoChipPadNum_e eScl, IoChipPadNum_e eSda, s32 *pHandle);
I2CErrorCode_e DrvI2cAddrWrite(s32 nHandle, u16 nAddress, u16 nDataToWrite, bool bStopBit);
I2CErrorCode_e DrvI2cAddrRead(s32 nHandle, u16 nAddress, u16 *pDataToRead, bool bStopBit);

MSpiErrorCode_e DrvMSpiOpen(MSpiChannel_e *pHandle, MSpiSettings_t *ptMSpiSetting);
MSpiErrorCode_e DrvMSpiClose(MSpiChannel_e nHandle);
MSpiErrorCode_e DrvMSpiWrite(MSpiChannel_e nHandle, void *pDataToWrite, u32 nWriteLen);
MSpiErrorCode_e DrvMSpiRead(MSpiChannel_e nHandle, void *pDataToRead, u32 nReadLen);
MSpiErrorCode_e DrvMSpiReadEx(MSpiChannel_e nHandle, void *pDataToWrite, u32 nWriteLen, void *pDataToRead, u32 nReadLen);

typedef struct
{
    MSpiChannel_e       eChannel;
    MSpiRWMethod_e      eRWMethod;                      
    MSpiMode_e          eMSpiMode;                      
    MSpiPad_e           ePadSelect;                     
    u32                 nMspiClk;                       
    MSpi_BufferConfig   sBufferCfg;
} MSpiSettings_t;

typedef struct
{
    u8 u8WBitConfig[8];      //bits will be transferred in write buffer ,0~7 means 1bit~8bit
    u8 u8RBitConfig[8];      //bits Will be transferred in read buffer ,0~7 means 1bit~8bit
} MSpi_BufferConfig;

MSpiErrorCode_e eRtn;
MSpiSettings_t  tSetting;

tSetting.eChannel       = MSPI_CH1;
tSetting.eMSpiMode  = MSPI_MODE0; 
tSetting.ePadSelect     = MSPI_PAD1;
tSetting.eRWMethod  = MSPI_RW_METHOD_POLLING;
tSetting.nMspiClk       = 27000000;
for (i = 0 ; i < 8 ; i++) {
    tSetting.sBufferCfg.u8RBitConfig[i] = 7; //Read Buffer有效位数，参数7表示8bit有效
    tSetting.sBufferCfg.u8WBitConfig[i] = 7; //Write Buffer 有效位数，参数7表示8bit有效
}   
eRtn = (DrvMSpiOpen(&eSPIHandle,&tSetting));
if(MSPI_PROC_DONE != eRtn)
    UartSendTrace(" MSpi Open err  %d \n", eRtn);

//SPI Read Data
{
    int i;
    MSpiErrorCode_e eRtn;

    u8 aReadBuf[8] = {0};
    memset(aReadBuf, 0x0, sizeof(aReadBuf));

    eRtn = DrvMSpiRead(eSPIHandle, aReadBuf, sizeof(aReadBuf));
    UartSendTrace("=== DrvMSpiRead res = [%d] ===\r\n", eRtn);
    for(i = 0 ; i < sizeof(aReadBuf) ; i++)
    {       
        UartSendTrace(" %x ", aReadBuf[i]);
    }
    UartSendTrace("\r\n");
}

//SPI Write Data
{
    MSpiErrorCode_e eRtn;
    u8 aWriteBuf[8] = {0};

    memset(aWriteBuf, 0x0, sizeof(aWriteBuf));
    aWriteBuf[0] = 0x00;
    aWriteBuf[1] = 0x01;
    aWriteBuf[2] = 0x02;
    aWriteBuf[3] = 0x03;
    aWriteBuf[4] = 0x04;
    aWriteBuf[5] = 0x05;
    aWriteBuf[6] = 0x06;
    aWriteBuf[7] = 0x07;

    eRtn = DrvMSpiWrite(eSPIHandle, aWriteBuf, sizeof(aWriteBuf));
    UartSendTrace("=== DrvMSpiWrite res = [%d] ===\r\n", eRtn);
}

s32 uart_Open( Uart_Num_t uart_num, Uart_cfg_t *uart_cfg );
void uart_SetRate(Uart_Num_t uart_num, vm_v24_Rate_t Rate );
void uart_SetFraming( Uart_Num_t uart_num, vm_v24_Framing_t Framing );
s32 uart_Write( Uart_Num_t uart_num, u8 *string,  u32 length);
s32 uart_Read( Uart_Num_t uart_num, u8 *string,  u32 length);
s32 uart_GetRxFifoLevel( Uart_Num_t uart_num);
bool uart_IsTxFifoEmpty( Uart_Num_t uart_num);
s32 uart_ClearRxBuffer( Uart_Num_t uart_num);

typedef struct {
    vm_v24_SerialLength_t       length;           ///< length in number of bits
    vm_v24_SerialParity_t       parity;           ///< parity
    vm_v24_SerialStop_t         stop;              ///< stop bit
    vm_v24_Rate_t           rate;              ///< bit rate
    vm_v24_FlowControl_t      RxFlowCtrlMethod; ///< type of Rx flow control
    vm_v24_FlowControl_t      TxFlowCtrlMethod; ///< type of Tx flow control
    u8                  signal_mask;    ///< signals to use
    u8                  padMode;        ///< pad mode
    UartCallbackData_t              rxCallback;     ///< callback called when data received in hardware FIFO
    UartCallbackData_t          txCallback;     ///< callback called when all data of software FIFO sent
    UartCallbackInd_t           EvtCallback;        ///< callback called when UART event raise of type \ref Uart_Ind_t
    u32                       dmaEnable;      ///< TX/RX by dma>
    u32                       autoCtsRts;
} Uart_cfg_t;

typedef enum {
    UART_1,
    UART_2,
    UART_3,
    FUART,
    NB_UART
} Uart_Num_t;

//Rx CallBack
void Uart_rxCallback(Uart_Num_t uart_num, u8 *buffer, u32 size)
{   
    UartSendTrace("# Uart_rxCallback -%d read[%d] sz[%d]\r\n", __LINE__, *buffer, size);
}
//Uart Init
{
    Uart_cfg_t      uart_cfg;
    memset(&uart_cfg, 0, sizeof(Uart_cfg_t));
    uart_cfg.length             = VM_V24_8BIT_LENGTH;
    uart_cfg.parity             = VM_V24_NO_PARITY;
    uart_cfg.stop               = VM_V24_1STOP_BIT;
    uart_cfg.padMode            = 7;
    uart_cfg.rate               = VM_V24_115200;
    uart_cfg.signal_mask        = (VM_V24_SIGNAL_RX | VM_V24_SIGNAL_TX);
    uart_cfg.RxFlowCtrlMethod   = VM_V24_NONE;
    uart_cfg.TxFlowCtrlMethod   = VM_V24_NONE;
    uart_cfg.autoCtsRts     = 0;
    uart_cfg.rxCallback         = Uart_rxCallback; 
    uart_cfg.txCallback         = NULL;
    uart_cfg.EvtCallback        = NULL;
    uart_Open(UART_3, &uart_cfg);
}
//Uart Write
{
    u8 u8SendString[]=”Hello,I’m UART2 Mode7!”;
    uart_Write(UART_3, u8SendString, sizeof(u8SendString));
}