boolean Adafruit_STMPE610::begin() {
// hardware SPI
InitTransaction();
// SPI = mraa_spi_init(0); // which buss? will experment here...
SPI = mraa_spi_init_software_cs(0); // which buss? will experment here...
mraa_spi_frequency(SPI, 1000000);
mraa_spi_lsbmode(SPI, false);
mraa_spi_mode(SPI, MRAA_SPI_MODE0);
m_spiMode = MRAA_SPI_MODE0;
_gpioCS = mraa_gpio_init(_cs);
mraa_gpio_dir(_gpioCS, MRAA_GPIO_OUT);
CSHigh();
mraa_spi_write(SPI, 0x00);
// try mode0
if (getVersion() != 0x811) {
//Serial.println("try MODE1");
mraa_spi_frequency(SPI, 1000000);
mraa_spi_lsbmode(SPI, false);
mraa_spi_mode(SPI, MRAA_SPI_MODE1);
m_spiMode = MRAA_SPI_MODE1;
if (getVersion() != 0x811) {
return false;
}
}
writeRegister8(STMPE_SYS_CTRL1, STMPE_SYS_CTRL1_RESET);
delay(10);
for (uint8_t i=0; i<65; i++) {
readRegister8(i);
}
writeRegister8(STMPE_SYS_CTRL2, 0x0); // turn on clocks!
writeRegister8(STMPE_TSC_CTRL, STMPE_TSC_CTRL_XYZ | STMPE_TSC_CTRL_EN); // XYZ and enable!
//Serial.println(readRegister8(STMPE_TSC_CTRL), HEX);
writeRegister8(STMPE_INT_EN, STMPE_INT_EN_TOUCHDET);
writeRegister8(STMPE_ADC_CTRL1, STMPE_ADC_CTRL1_10BIT | (0x6 << 4)); // 96 clocks per conversion
writeRegister8(STMPE_ADC_CTRL2, STMPE_ADC_CTRL2_6_5MHZ);
writeRegister8(STMPE_TSC_CFG, STMPE_TSC_CFG_4SAMPLE | STMPE_TSC_CFG_DELAY_1MS | STMPE_TSC_CFG_SETTLE_5MS);
writeRegister8(STMPE_TSC_FRACTION_Z, 0x6);
writeRegister8(STMPE_FIFO_TH, 1);
writeRegister8(STMPE_FIFO_STA, STMPE_FIFO_STA_RESET);
writeRegister8(STMPE_FIFO_STA, 0); // unreset
writeRegister8(STMPE_TSC_I_DRIVE, STMPE_TSC_I_DRIVE_50MA);
writeRegister8(STMPE_INT_STA, 0xFF); // reset all ints
writeRegister8(STMPE_INT_CTRL, STMPE_INT_CTRL_POL_HIGH | STMPE_INT_CTRL_ENABLE);
return true;
}
void SPI_Init(void)
{
//MOSI --> J17-12 --> GPIO-115
//SCK --> J17-11 -->GPIO-109
spi = mraa_spi_init(1);
if (spi == NULL)
{
printf("SPI initialization failed, check syslog for details, exit...\n");
exit(1);
}
//printf("SPI initialized successfully\n");
mraa_spi_frequency (spi, fSCLK);
//printf("SPI clock frequency set to %iHz\n", fSCLK);
/*
MRAA_SPI_MODE0
CPOL = 0, CPHA = 0,
Clock idle low, data is clocked in on rising edge, output data (change) on falling edge
*/
mraa_spi_mode(spi, MRAA_SPI_MODE0);
//printf("SPI set to MODE0\n");
//LSB Transmission
mraa_spi_lsbmode(spi, 0);
}
mraa_spi_context
mraa_spi_init_raw(unsigned int bus, unsigned int cs)
{
mraa_spi_context dev = mraa_spi_init_internal(plat == NULL ? NULL : plat->adv_func);
if (dev == NULL) {
syslog(LOG_CRIT, "spi: Failed to allocate memory for context");
return NULL;
}
char path[MAX_SIZE];
sprintf(path, "/dev/spidev%u.%u", bus, cs);
dev->devfd = open(path, O_RDWR);
if (dev->devfd < 0) {
syslog(LOG_ERR, "spi: Failed opening SPI Device. bus:%s", path);
free(dev);
return NULL;
}
int speed = 0;
if (ioctl(dev->devfd, SPI_IOC_RD_MAX_SPEED_HZ, &speed) != -1) {
dev->clock = speed;
} else {
// We had this on Galileo Gen1, so let it be a fallback value
dev->clock = 4000000;
syslog(LOG_WARNING, "spi: Max speed query failed, setting %d", dev->clock);
}
if (mraa_spi_mode(dev, MRAA_SPI_MODE0) != MRAA_SUCCESS) {
free(dev);
return NULL;
}
if (mraa_spi_lsbmode(dev, 0) != MRAA_SUCCESS) {
free(dev);
return NULL;
}
if (mraa_spi_bit_per_word(dev, 8) != MRAA_SUCCESS) {
free(dev);
return NULL;
}
return dev;
}
mraa_spi_context
mraa_spi_init_raw(unsigned int bus, unsigned int cs)
{
mraa_spi_context dev = mraa_spi_init_internal(plat == NULL ? NULL : plat->adv_func);
if (dev == NULL) {
syslog(LOG_CRIT, "spi: Failed to allocate memory for context");
return NULL;
}
char path[MAX_SIZE];
sprintf(path, "/dev/spidev%u.%u", bus, cs);
dev->devfd = open(path, O_RDWR);
if (dev->devfd < 0) {
syslog(LOG_ERR, "spi: Failed opening SPI Device. bus:%s", path);
free(dev);
return NULL;
}
int speed = 0;
if ((ioctl(dev->devfd, SPI_IOC_RD_MAX_SPEED_HZ, &speed) != -1) && (speed < 4000000)) {
dev->clock = speed;
} else {
dev->clock = 4000000;
}
if (mraa_spi_mode(dev, MRAA_SPI_MODE0) != MRAA_SUCCESS) {
free(dev);
return NULL;
}
if (mraa_spi_lsbmode(dev, 0) != MRAA_SUCCESS) {
free(dev);
return NULL;
}
if (mraa_spi_bit_per_word(dev, 8) != MRAA_SUCCESS) {
free(dev);
return NULL;
}
return dev;
}
mraa_spi_context
mraa_spi_init_raw(unsigned int bus, unsigned int cs)
{
mraa_result_t status = MRAA_SUCCESS;
mraa_spi_context dev = mraa_spi_init_internal(plat == NULL ? NULL : plat->adv_func);
if (dev == NULL) {
syslog(LOG_CRIT, "spi: Failed to allocate memory for context");
status = MRAA_ERROR_NO_RESOURCES;
goto init_raw_cleanup;
}
if (IS_FUNC_DEFINED(dev, spi_init_raw_replace)) {
status = dev->advance_func->spi_init_raw_replace(dev, bus, cs);
if (status == MRAA_SUCCESS) {
return dev;
} else {
goto init_raw_cleanup;
}
}
char path[MAX_SIZE];
snprintf(path, MAX_SIZE, "/dev/spidev%u.%u", bus, cs);
dev->devfd = open(path, O_RDWR);
if (dev->devfd < 0) {
syslog(LOG_ERR, "spi: Failed opening SPI Device. bus:%s. Error %d %s", path, errno, strerror(errno));
status = MRAA_ERROR_INVALID_RESOURCE;
goto init_raw_cleanup;
}
int speed = 0;
if (ioctl(dev->devfd, SPI_IOC_RD_MAX_SPEED_HZ, &speed) != -1) {
dev->clock = speed;
} else {
// We had this on Galileo Gen1, so let it be a fallback value
dev->clock = 4000000;
syslog(LOG_WARNING, "spi: Max speed query failed, setting %d", dev->clock);
}
status = mraa_spi_mode(dev, MRAA_SPI_MODE0);
if (status != MRAA_SUCCESS) {
goto init_raw_cleanup;
}
status = mraa_spi_lsbmode(dev, 0);
if (status != MRAA_SUCCESS) {
goto init_raw_cleanup;
}
status = mraa_spi_bit_per_word(dev, 8);
if (status != MRAA_SUCCESS) {
goto init_raw_cleanup;
}
init_raw_cleanup:
if (status != MRAA_SUCCESS) {
if (dev != NULL) {
free(dev);
}
return NULL;
}
return dev;
}
// Init
lis3dh_context
lis3dh_init(int bus, int addr, int cs)
{
lis3dh_context dev = (lis3dh_context) malloc(sizeof(struct _lis3dh_context));
if (!dev) {
return NULL;
}
// Zero out context
memset((void*) dev, 0, sizeof(struct _lis3dh_context));
// Make sure MRAA is initialized
if (mraa_init() != MRAA_SUCCESS) {
printf("%s: mraa_init() failed\n", __FUNCTION__);
lis3dh_close(dev);
return NULL;
}
if (addr < 0) {
// SPI
if (!(dev->spi = mraa_spi_init(bus))) {
printf("%s: mraa_spi_init() for bus %d failed\n", __FUNCTION__, bus);
lis3dh_close(dev);
return NULL;
}
// Only create CS context if we are actually using a valid pin.
// A hardware controlled pin should specify CS as -1.
if (cs >= 0) {
if (!(dev->gpioCS = mraa_gpio_init(cs))) {
printf("%s: mraa_gpio_init() for CS pin %d failed\n", __FUNCTION__, cs);
lis3dh_close(dev);
return NULL;
}
mraa_gpio_dir(dev->gpioCS, MRAA_GPIO_OUT);
}
mraa_spi_mode(dev->spi, MRAA_SPI_MODE0);
if (mraa_spi_frequency(dev->spi, 5000000)) {
printf("%s: mraa_spi_frequency() failed\n", __FUNCTION__);
lis3dh_close(dev);
return NULL;
}
} else {
// I2C
if (!(dev->i2c = mraa_i2c_init(bus))) {
printf("%s: mraa_i2c_init() for bus %d failed\n", __FUNCTION__, bus);
lis3dh_close(dev);
return NULL;
}
if (mraa_i2c_address(dev->i2c, addr)) {
printf("%s: mraa_i2c_address() for address 0x%x failed\n", __FUNCTION__, addr);
lis3dh_close(dev);
return NULL;
}
}
// Check the chip id
uint8_t chipID = lis3dh_get_chip_id(dev);
if (chipID != LIS3DH_CHIPID) {
printf("%s: invalid chip id: %02x, expected %02x\n", __FUNCTION__, chipID, LIS3DH_CHIPID);
lis3dh_close(dev);
return NULL;
}
// Call devinit with default options
if (lis3dh_devinit(dev, LIS3DH_ODR_100HZ, LIS3DH_FS_2G, true)) {
printf("%s: lis3dh_devinit() failed\n", __FUNCTION__);
lis3dh_close(dev);
return NULL;
}
return dev;
}
void hal_aci_tl_init(aci_pins_t *a_pins, bool debug)
{
mraa_result_t error = MRAA_SUCCESS;
aci_debug_print = debug;
/* Needs to be called as the first thing for proper intialization*/
m_aci_pins_set(a_pins);
/*
* Init SPI
*/
a_pins->m_spi = mraa_spi_init (0);
if (a_pins->m_spi == NULL) {
throw std::invalid_argument(std::string(__FUNCTION__) +
": mraa_spi_init() failed");
}
mraa_spi_frequency (a_pins->m_spi, 2000000);
mraa_spi_mode (a_pins->m_spi, MRAA_SPI_MODE0);
/* Initialize the ACI Command queue. This must be called after the delay above. */
aci_queue_init(&aci_tx_q);
aci_queue_init(&aci_rx_q);
// Configure the IO lines
a_pins->m_rdy_ctx = mraa_gpio_init (a_pins->rdyn_pin);
if (a_pins->m_rdy_ctx == NULL) {
throw std::invalid_argument(std::string(__FUNCTION__) +
": mraa_gpio_init(rdyn) failed, invalid pin?");
}
a_pins->m_req_ctx = mraa_gpio_init (a_pins->reqn_pin);
if (a_pins->m_req_ctx == NULL) {
throw std::invalid_argument(std::string(__FUNCTION__) +
": mraa_gpio_init(reqn) failed, invalid pin?");
}
a_pins->m_rst_ctx = mraa_gpio_init (a_pins->reset_pin);
if (a_pins->m_rst_ctx == NULL) {
throw std::invalid_argument(std::string(__FUNCTION__) +
": mraa_gpio_init(reset) failed, invalid pin?");
}
error = mraa_gpio_dir (a_pins->m_rdy_ctx, MRAA_GPIO_IN);
if (error != MRAA_SUCCESS) {
printf ("[ERROR] GPIO failed to initilize \n");
}
error = mraa_gpio_dir (a_pins->m_req_ctx, MRAA_GPIO_OUT);
if (error != MRAA_SUCCESS) {
printf ("[ERROR] GPIO failed to initilize \n");
}
error = mraa_gpio_dir (a_pins->m_rst_ctx, MRAA_GPIO_OUT);
if (error != MRAA_SUCCESS) {
printf ("[ERROR] GPIO failed to initilize \n");
}
if (UNUSED != a_pins->active_pin) {
}
/* Pin reset the nRF8001, required when the nRF8001 setup is being changed */
hal_aci_tl_pin_reset();
/* Set the nRF8001 to a known state as required by the datasheet*/
mraa_gpio_write (a_pins->m_req_ctx, LOW);
usleep(30000); //Wait for the nRF8001 to get hold of its lines - the lines float for a few ms after the reset
/* Attach the interrupt to the RDYN line as requested by the caller */
if (a_pins->interface_is_interrupt) {
// We use the LOW level of the RDYN line as the atmega328 can wakeup from sleep only on LOW
// attachInterrupt(a_pins->interrupt_number, m_aci_isr, LOW);
}
}
uint8_t RF22::init()
{
// Wait for RF22 POR (up to 16msec)
usleep (16);
// Initialise the slave select pin
_cs = mraa_gpio_init(_slaveSelectPin);
mraa_gpio_dir(_cs, MRAA_GPIO_OUT);
mraa_gpio_write(_cs, 0x1);
// start the SPI library:
// Note the RF22 wants mode 0, MSB first and default to 1 Mbps
_spi = mraa_spi_init(0);
mraa_spi_mode (_spi, MRAA_SPI_MODE0);
mraa_spi_lsbmode(_spi, 0);
mraa_spi_frequency(_spi, 1000000); // 1Mhz
usleep (100);
// Software reset the device
reset();
// Get the device type and check it
// This also tests whether we are really connected to a device
_deviceType = spiRead(RF22_REG_00_DEVICE_TYPE);
if ( _deviceType != RF22_DEVICE_TYPE_RX_TRX
&& _deviceType != RF22_DEVICE_TYPE_TX)
return 0;
_irq = mraa_gpio_init(_interrupt + 2);
mraa_gpio_dir(_irq, MRAA_GPIO_IN);
gpio_edge_t edge = MRAA_GPIO_EDGE_FALLING;
// Set up interrupt handler
if (_interrupt == 0)
{
_RF22ForInterrupt[0] = this;
mraa_gpio_isr(_irq, edge, &RF22::isr0, NULL);
}
else if (_interrupt == 1)
{
_RF22ForInterrupt[1] = this;
mraa_gpio_isr(_irq, edge, &RF22::isr1, NULL);
}
else
return 0;
clearTxBuf();
clearRxBuf();
// Most of these are the POR default
spiWrite(RF22_REG_7D_TX_FIFO_CONTROL2, RF22_TXFFAEM_THRESHOLD);
spiWrite(RF22_REG_7E_RX_FIFO_CONTROL, RF22_RXFFAFULL_THRESHOLD);
spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_ENPACRX | RF22_ENPACTX | RF22_ENCRC | RF22_CRC_CRC_16_IBM);
// Configure the message headers
// Here we set up the standard packet format for use by the RF22 library
// 8 nibbles preamble
// 2 SYNC words 2d, d4
// Header length 4 (to, from, id, flags)
// 1 octet of data length (0 to 255)
// 0 to 255 octets data
// 2 CRC octets as CRC16(IBM), computed on the header, length and data
// On reception the to address is check for validity against RF22_REG_3F_CHECK_HEADER3
// or the broadcast address of 0xff
// If no changes are made after this, the transmitted
// to address will be 0xff, the from address will be 0xff
// and all such messages will be accepted. This permits the out-of the box
// RF22 config to act as an unaddresed, unreliable datagram service
spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_HEADER3 | RF22_HDCH_HEADER3);
spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_4 | RF22_SYNCLEN_2);
setPreambleLength(8);
uint8_t syncwords[] = { 0x2d, 0xd4 };
setSyncWords(syncwords, sizeof(syncwords));
setPromiscuous(0);
// Check the TO header against RF22_DEFAULT_NODE_ADDRESS
spiWrite(RF22_REG_3F_CHECK_HEADER3, RF22_DEFAULT_NODE_ADDRESS);
// Set the default transmit header values
setHeaderTo(RF22_DEFAULT_NODE_ADDRESS);
setHeaderFrom(RF22_DEFAULT_NODE_ADDRESS);
setHeaderId(0);
setHeaderFlags(0);
// Ensure the antenna can be switched automatically according to transmit and receive
// This assumes GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit
// This assumes GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive
spiWrite (RF22_REG_0B_GPIO_CONFIGURATION0, 0x12) ; // TX state
spiWrite (RF22_REG_0C_GPIO_CONFIGURATION1, 0x15) ; // RX state
// Enable interrupts
spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR);
spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL);
// Set some defaults. An innocuous ISM frequency, and reasonable pull-in
setFrequency(434.0, 0.05);
// setFrequency(900.0);
// Some slow, reliable default speed and modulation
setModemConfig(FSK_Rb2_4Fd36);
// setModemConfig(FSK_Rb125Fd125);
// Minimum power
setTxPower(RF22_TXPOW_8DBM);
// setTxPower(RF22_TXPOW_17DBM);
return 1;
}
/**
* Set the SPI device mode. see spidev0-3
*
* @param mode the mode. See Linux spidev doc
* @return Result of operation
*/
Result
mode(Spi_Mode mode)
{
return (Result) mraa_spi_mode(m_spi, (mraa_spi_mode_t) mode);
}
kx122_context kx122_init(int bus, int addr, int chip_select_pin, int spi_bus_frequency)
{
kx122_context dev = (kx122_context)malloc(sizeof(struct _kx122_context));
if(!dev){
return NULL;
}
dev->using_spi = false;
dev->i2c = NULL;
dev->spi = NULL;
dev->chip_select = NULL;
dev->gpio1 = NULL;
dev->gpio2 = NULL;
if(mraa_init() != MRAA_SUCCESS){
printf("%s: mraa_init() failed.\n", __FUNCTION__);
kx122_close(dev);
return NULL;
}
if(addr == -1){
dev->using_spi = true;
}
if(dev->using_spi){
if (spi_bus_frequency > 10000000){ // KX122 has a maximum SPI bus speed of 10MHz
printf("%s: bus frequency too high - KX122 has a maximum SPI bus speed of 10MHz.\n", __FUNCTION__);
kx122_close(dev);
return NULL;
}
if (!(dev->spi = mraa_spi_init(bus))){
printf("%s: mraa_spi_init() failed.\n", __FUNCTION__);
kx122_close(dev);
return NULL;
}
if (!(dev->chip_select = mraa_gpio_init(chip_select_pin))){
printf("%s: mraa_gpio_init() failed.\n", __FUNCTION__);
kx122_close(dev);
return NULL;
}
mraa_gpio_dir(dev->chip_select,MRAA_GPIO_OUT);
mraa_spi_mode(dev->spi,MRAA_SPI_MODE0);
if (mraa_spi_frequency(dev->spi, spi_bus_frequency)){
printf("%s: mraa_spi_frequency() failed.\n", __FUNCTION__);
kx122_close(dev);
return NULL;
}
}
else{ //Using I2C
if (!(dev->i2c = mraa_i2c_init(bus))){
printf("%s: mraa_i2c_init() failed, used bus: %d\n", __FUNCTION__,bus);
kx122_close(dev);
return NULL;
}
if (mraa_i2c_address(dev->i2c, addr)){
printf("%s: mraa_i2c_address() failed.\n", __FUNCTION__);
kx122_close(dev);
return NULL;
}
}
uint8_t who_am_i;
kx122_get_who_am_i(dev,&who_am_i);
if(who_am_i != KX122_WHO_AM_I_WIA_ID){
printf("%s: Wrong WHO AM I received, expected: 0x%x | got: 0x%x\n", __FUNCTION__,KX122_WHO_AM_I_WIA_ID,who_am_i);
kx122_close(dev);
return NULL;
}
kx122_set_default_values(dev);
kx122_device_init(dev,KX122_ODR_50,HIGH_RES,KX122_RANGE_2G);
return dev;
}
inline void Adafruit_STMPE610::spi_begin(void) {
BeginTranscation();
mraa_spi_frequency(SPI, 1000000);
mraa_spi_mode(SPI, m_spiMode);
}
