cascoda_sensorif.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2019, Cascoda Ltd.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef CASCODA_SENSORIF_H
#define CASCODA_SENSORIF_H
 
#include "cascoda-bm/cascoda_types.h"
#include "ca821x_api.h"
#include "cascoda_chili_config.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* declarations */
#define SENSORIF_I2C_TIMEOUT 100           /* I2C bus access time-out time in [ms] */
#define SENSORIF_I2C_CLK_FREQUENCY 100000  /* I2C SCL frequency [Hz], 100kHz (full-speed) */
#define SENSORIF_INT_PULLUPS 0             /* I2C use internal pull-ups flag */
#define SENSORIF_SPI_CLK_FREQUENCY 4000000 /* SPI CLK frequency [Hz], 4MHz (max frequency for E-paper display) */
#define SENSORIF_SPI_DATA_WIDTH 8
#define UART_SENSORIF_BAUDRATE 115200
 
#if defined(CASCODA_CHILI2_CONFIG)
u8_t SENSORIF_SPI_Chip_Select(void);
void SENSORIF_SECURE_I2C_Config(u32_t portnum);
void SENSORIF_SECURE_SPI_Config(u32_t portnum);
void SENSORIF_SECURE_UART_Config(u32_t portnum);
#endif
 
/* Note: most internal GPIO pull-ups have a value of around 50kOhms which is usually
 * too high for I2C pull-up values, depending  on number of peripherals connected and
 * overall load capacitance. The SCL clock frequency might have to be lowered to below
 * full-speed if no external pull-ups on SDA and SCL are available.
 */
 
enum sensorif_i2c_status
{
    SENSORIF_I2C_ST_START         = 0x08, 
    SENSORIF_I2C_ST_RSTART        = 0x10, 
    SENSORIF_I2C_ST_TX_AD_ACK     = 0x18, 
    SENSORIF_I2C_ST_TX_AD_NACK    = 0x20, 
    SENSORIF_I2C_ST_TX_DT_ACK     = 0x28, 
    SENSORIF_I2C_ST_TX_DT_NACK    = 0x30, 
    SENSORIF_I2C_ST_ARB_LOST      = 0x38, 
    SENSORIF_I2C_ST_RX_AD_ACK     = 0x40, 
    SENSORIF_I2C_ST_RX_AD_NACK    = 0x48, 
    SENSORIF_I2C_ST_RX_DT_ACK     = 0x50, 
    SENSORIF_I2C_ST_RX_DT_NACK    = 0x58, 
    SENSORIF_I2C_ST_BUS_ERROR_RAW = 0x00, 
    SENSORIF_I2C_ST_STOP          = 0xF0, 
    SENSORIF_I2C_ST_RELEASED      = 0xF8, 
    SENSORIF_I2C_ST_NOT_IMPLEMENTED = 0xFE, 
    SENSORIF_I2C_ST_SUCCESS         = 0x00, 
    SENSORIF_I2C_ST_TIMEOUT         = 0xFF, 
    SENSORIF_I2C_ST_BUS_ERROR       = 0xF1, 
};
 
/* PWM type to indicate whether Basic PWM or Extended PWM is used */
typedef enum
{
    NOT_INITIALISED = 0,
    USING_BPWM      = 1,
    USING_EPWM      = 2,
} PWM_type_t;
 
/* functions for platform implementation */
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_I2C_Init(void);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_I2C_Deinit(void);
 
/******************************************************************************/
/***************************************************************************/ 
enum sensorif_i2c_status SENSORIF_I2C_Write(u8_t slaveaddr, u8_t *data, u32_t *len);
 
/******************************************************************************/
/***************************************************************************/ 
enum sensorif_i2c_status SENSORIF_I2C_Read(u8_t slaveaddr, u8_t *pdata, u32_t *plen);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_SPI_Init(bool is_eink_display_present);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_SPI_Deinit(void);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
ca_error SENSORIF_SPI_Write(u8_t out_data);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
void SENSORIF_SPI_FULL_DUPLEX_RXONLY(u8_t *RxBuf, u8_t RxLen);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
void SENSORIF_SPI_WRITE_THEN_READ(u8_t *RxBuf, u8_t *TxBuf, u8_t RxLen, u8_t TxLen);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_UART_Init(void);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_UART_Deinit(void);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
u32_t SENSORIF_UART_Write(u8_t *out_data, u32_t writebytes);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
u32_t SENSORIF_UART_Read(u8_t *in_data, u32_t readbytes);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
void SENSORIF_I2C_Config(u32_t portnum);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
void SENSORIF_SPI_Config(u32_t portnum);
 
/************************************************************************************************************/
/*********************************************************************************************************/ 
void SENSORIF_UART_Config(u32_t portnum);
 
/******************************************************************************/
/***************************************************************************/ 
ca_error SENSORIF_PWM_Init(u8_t pin, u32_t u32Frequency, u32_t u32DutyCycle);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_PWM_Deinit(void);
 
/******************************************************************************/
/***************************************************************************/ 
void SENSORIF_PWM_SetDutyCycle(u32_t u32DutyCycle);
 
#ifdef __cplusplus
}
#endif
 
#endif // CASCODA_SENSORIF_H