Esempio n. 1
0
static uint16_t ads7843e_sendcmd(FAR struct ads7843e_dev_s *priv, uint8_t cmd)
{
  uint8_t  buffer[2];
  uint16_t result;

  /* Select the ADS7843E */

  SPI_SELECT(priv->spi, SPIDEV_TOUCHSCREEN, true);

  /* Send the command */

  (void)SPI_SEND(priv->spi, cmd);

  /* Wait a tiny amount to make sure that the aquisition time is complete */

   up_udelay(3); /* 3 microseconds */

  /* Read the 12-bit data (LS 4 bits will be padded with zero) */

  SPI_RECVBLOCK(priv->spi, buffer, 2);
  SPI_SELECT(priv->spi, SPIDEV_TOUCHSCREEN, false);

  result = ((uint16_t)buffer[0] << 8) | (uint16_t)buffer[1];
  result = result >> 4;

  ivdbg("cmd:%02x response:%04x\n", cmd, result);
  return result;
}
Esempio n. 2
0
static uint16_t max11802_sendcmd(FAR struct max11802_dev_s *priv,
                                 uint8_t cmd, int *tags)
{
  uint8_t  buffer[2];
  uint16_t result;

  /* Select the MAX11802 */

  SPI_SELECT(priv->spi, SPIDEV_TOUCHSCREEN, true);

  /* Send the command */

  (void)SPI_SEND(priv->spi, cmd);

  /* Read the data */

  SPI_RECVBLOCK(priv->spi, buffer, 2);
  SPI_SELECT(priv->spi, SPIDEV_TOUCHSCREEN, false);

  result = ((uint16_t)buffer[0] << 8) | (uint16_t)buffer[1];
  *tags = result & 0xF;
  result >>= 4; /* Get rid of tags */

  iinfo("cmd:%02x response:%04x\n", cmd, result);
  return result;
}
Esempio n. 3
0
static uint16_t ads7843e_sendcmd(FAR struct ads7843e_dev_s *priv, uint8_t cmd)
{
  uint8_t  buffer[2];
  uint16_t result;

  /* Select the ADS7843E */

  SPI_SELECT(priv->spi, SPIDEV_TOUCHSCREEN, true);

  /* Send the command */

  (void)SPI_SEND(priv->spi, cmd);
  ads7843e_waitbusy(priv);

  /* Read the data */

  SPI_RECVBLOCK(priv->spi, buffer, 2);
  SPI_SELECT(priv->spi, SPIDEV_TOUCHSCREEN, false);

  result = ((uint16_t)buffer[0] << 8) | (uint16_t)buffer[1];
  result = result >> 4;

  ivdbg("cmd:%02x response:%04x\n", cmd, result);
  return result;
}
Esempio n. 4
0
static uint8_t nrf24l01_access(FAR struct nrf24l01_dev_s *dev,
    nrf24l01_access_mode_t mode, uint8_t cmd, FAR uint8_t *buf, int length)
{
  uint8_t status;

  /* Prepare SPI */

  nrf24l01_select(dev);

  /* Transfer */

  status = SPI_SEND(dev->spi, cmd);

  switch (mode)
    {
    case MODE_WRITE:
      if (length > 0)
        {
          SPI_SNDBLOCK(dev->spi, buf, length);
        }
      break;

    case MODE_READ:
      SPI_RECVBLOCK(dev->spi, buf, length);
      break;
    }

  nrf24l01_deselect(dev);
  return status;
}
Esempio n. 5
0
uint8_t adxl345_getreg8(FAR struct adxl345_dev_s *priv, uint8_t regaddr)
{
  uint8_t regval;

  /* If SPI bus is shared then lock and configure it */

#ifndef CONFIG_SPI_OWNBUS
  (void)SPI_LOCK(priv->spi, true);
  adxl345_configspi(priv->spi);
#endif

  /* Select the ADXL345 */

  SPI_SELECT(priv->spi, SPIDEV_GSENSOR, true);
  
  /* Send register to read and get the next byte */

  (void)SPI_SEND(priv->spi, regaddr);
  SPI_RECVBLOCK(priv->spi, &regval, 1);

  /* Deselect the ADXL345 */

  SPI_SELECT(priv->spi, SPIDEV_GSENSOR, false);

  /* Unlock bus */

#ifndef CONFIG_SPI_OWNBUS
  (void)SPI_LOCK(priv->spi, false);
#endif

#ifdef CONFIG_ADXL345_REGDEBUG
  dbg("%02x->%02x\n", regaddr, regval);
#endif
  return regval;
}
Esempio n. 6
0
int pn532_read_more(struct pn532_dev_s *dev, uint8_t *buff, uint8_t n)
{
  pn532_lock(dev->spi);
  pn532_select(dev);
  SPI_RECVBLOCK(dev->spi, buff, n);
  pn532_deselect(dev);
  pn532_unlock(dev->spi);

  tracerx("read_more", buff, n);
  return n;
}
Esempio n. 7
0
int pn532_read(struct pn532_dev_s *dev, uint8_t *buff, uint8_t n)
{
  pn532_lock(dev->spi);
  pn532_select(dev);
  SPI_SEND(dev->spi, PN532_SPI_DATAREAD);
  SPI_RECVBLOCK(dev->spi, buff, n);
  pn532_deselect(dev);
  pn532_unlock(dev->spi);

  tracerx("read", buff, n);
  return n;
}
Esempio n. 8
0
static ssize_t max31855_read(FAR struct file *filep, FAR char *buffer, size_t buflen)
{
  FAR struct inode          *inode = filep->f_inode;
  FAR struct max31855_dev_s *priv  = inode->i_private;
  FAR uint16_t              *temp  = (FAR uint16_t *) buffer;
  int                       ret    = 2;
  int32_t                   regmsb;
  int32_t                   regval;

  /* Check for issues */

  if (!buffer)
    {
      sndbg("Buffer is null\n");
      return -EINVAL;
    }

  if (buflen != 2)
    {
      sndbg("You can't read something other than 16 bits (2 bytes)\n");
      return -EINVAL;
    }

  /* Enable MAX31855's chip select */

  SPI_SELECT(priv->spi, SPIDEV_TEMPERATURE, true);

  /* Read temperature */

  SPI_RECVBLOCK(priv->spi, &regmsb, 4);

  /* Disable MAX31855's chip select */

  SPI_SELECT(priv->spi, SPIDEV_TEMPERATURE, false);

  regval  = (regmsb & 0xFF000000) >> 24;
  regval |= (regmsb & 0xFF0000) >> 8;
  regval |= (regmsb & 0xFF00) << 8;
  regval |= (regmsb & 0xFF) << 24;

  sndbg("Read from MAX31855 = 0x%08X\n", regval);

  /* If negative, fix signal bits */

  if (regval & 0x80000000)
    {
      *temp = 0xc000 | (regval >> 18);
    }
Esempio n. 9
0
int cc1101_access(struct cc1101_dev_s * dev, uint8_t addr, uint8_t *buf, int length)
{
  int stabyte;

  /* Address cannot explicitly define READ command while length WRITE.
   * Also access to these cells is only permitted as one byte, eventhough
   * transfer is marked as BURST!
   */

  if ((addr & CC1101_READ_SINGLE) && length != 1)
        return ERROR;

    /* Prepare SPI */

    cc1101_access_begin(dev);

    if (length>1 || length < -1)
        SPI_SETFREQUENCY(dev->spi, CC1101_SPIFREQ_BURST);
    else SPI_SETFREQUENCY(dev->spi, CC1101_SPIFREQ_SINGLE);

    /* Transfer */

    if (length <= 0) {      /* 0 length are command strobes */
        if (length < -1)
            addr |= CC1101_WRITE_BURST;

        stabyte = SPI_SEND(dev->spi, addr);
        if (length) {
            SPI_SNDBLOCK(dev->spi, buf, -length);
        }
    }
    else {
        addr |= CC1101_READ_SINGLE;
        if (length > 1)
            addr |= CC1101_READ_BURST;

        stabyte = SPI_SEND(dev->spi, addr);
        SPI_RECVBLOCK(dev->spi, buf, length);
    }

    cc1101_access_end(dev);

    return stabyte;
}
Esempio n. 10
0
static char spi_read(int port, int addr, int frequency, int bits, int conf)
{
	unsigned char buf[2];
	buf[0] = addr | 0x80;

	SPI_LOCK(spi_dev, true);

	SPI_SETFREQUENCY(spi_dev, frequency);
	SPI_SETBITS(spi_dev, bits);
	SPI_SETMODE(spi_dev, conf);

	SPI_SELECT(spi_dev, port, true);
	SPI_RECVBLOCK(spi_dev, buf, 2);
	SPI_SELECT(spi_dev, port, false);

	SPI_LOCK(spi_dev, false);

	return buf[1];
}
Esempio n. 11
0
static ssize_t max6675_read(FAR struct file *filep, FAR char *buffer, size_t buflen)
{
  FAR struct inode         *inode = filep->f_inode;
  FAR struct max6675_dev_s *priv  = inode->i_private;
  FAR uint16_t             *temp  = (FAR uint16_t *) buffer;
  int                       ret   = 2;
  int16_t                   regmsb;
  int16_t                   regval;

  /* Check for issues */

  if (!buffer)
    {
      snerr("ERROR: Buffer is null\n");
      return -EINVAL;
    }

  if (buflen != 2)
    {
      snerr("ERROR: You can't read something other than 16 bits (2 bytes)\n");
      return -EINVAL;
    }

  /* Enable MAX6675's chip select */

  max6675_lock(priv->spi);
  SPI_SELECT(priv->spi, SPIDEV_TEMPERATURE(0), true);

  /* Read temperature */

  SPI_RECVBLOCK(priv->spi, &regmsb, 2);

  /* Disable MAX6675's chip select */

  SPI_SELECT(priv->spi, SPIDEV_TEMPERATURE(0), false);
  max6675_unlock(priv->spi);

  regval  = (regmsb & 0xFF00) >> 8;
  regval |= (regmsb & 0xFF) << 8;

  sninfo("Read from MAX6675 = 0x%04X\n", regval);

  /* Verify if the device ID bit is really zero */

  if (regval & MAX6675_DEV_ID)
    {
      snerr("ERROR: The Device ID bit needs to be 0 !\n");
      ret = -EINVAL;
    }

  /* Detect if termocople input is open */

  if (regval & MAX6675_OPEN_CIRCUIT)
    {
      snerr("ERROR: The thermocouple input is not connected!\n");
      ret = -EINVAL;
    }

  /* Feed sensor data to entropy pool */

  add_sensor_randomness(regval);

  /* Get the temperature */

  *temp = (regval & MAX6675_TEMP_COUPLE) >> 3;

  /* Return two bytes, the temperature is fixed point Q10.2, then divide by 4
   * in your application in order to get real temperature in Celsius degrees.
   */

  return ret;
}