uint16_t rdwr_vcon_pot(uint8_t *val, CyBool_t write) {
    uint16_t status;
    CyU3PI2cPreamble_t preamble;

    preamble.length    = 1;
    uint8_t addr = UXN1330_VCON_POT;
    if (!write) {
        addr |= 1; // read
    }
    preamble.buffer[0] = addr;
    preamble.ctrlMask  = 0x0000;

    if (write) {
        status = CyU3PI2cTransmitBytes(&preamble, val, 1, 1);
    } else {
        status = CyU3PI2cReceiveBytes(&preamble, val, 1, 1);
    }
    if(status) {
        log_debug ( "vcon_pot CyU3PI2c status: %d\n", status );
        return status;

        /* Wait for the write to complete. */
        preamble.length = 1;
        status = CyU3PI2cWaitForAck(&preamble, 200);
        if(status) {
          log_error( "CyU3PI2cWaitForAck fail %d\n", status );
          return status;
        }
    }

    return 0;
}
Exemplo n.º 2
0
CyU3PReturnStatus_t SensorWrite(uint8_t slaveAddr, uint8_t highAddr,
		uint8_t lowAddr, uint8_t count, uint8_t *buf) {
	CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
	CyU3PI2cPreamble_t preamble;

	/* Validate the I2C slave address. */
	if ((slaveAddr != SENSOR_ADDR_WR) && (slaveAddr != I2C_MEMORY_ADDR_WR)) {
		CyU3PDebugPrint(4, "I2C Slave address is not valid!\n");
		return 1;
	}

	if (count > 64) {
		CyU3PDebugPrint(4, "ERROR: SensorWrite count > 64\n");
		return 1;
	}

	/* Set up the I2C control parameters and invoke the write API. */
	preamble.buffer[0] = slaveAddr;
	preamble.buffer[1] = 0xab;//highAddr;
	preamble.buffer[2] = 0xcd;//lowAddr;
	preamble.length = 3;
	preamble.ctrlMask = 0x0000;

	apiRetStatus = CyU3PI2cTransmitBytes(&preamble, buf, count, 0);
	SensorI2CAccessDelay(apiRetStatus);

	return apiRetStatus;
}
Exemplo n.º 3
0
/* Write to an I2C slave with two bytes of data. */
CyU3PReturnStatus_t SensorWrite2B(
	uint8_t slaveAddr,
	uint8_t highAddr,
	uint8_t lowAddr, 
	uint8_t highData, 
	uint8_t lowData) {
	
	CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
	CyU3PI2cPreamble_t preamble;
	uint8_t buf[2];

	/* Validate the I2C slave address. */
	if ((slaveAddr != SENSOR_ADDR_WR) && (slaveAddr != I2C_MEMORY_ADDR_WR)) {
		CyU3PDebugPrint(4, "I2C Slave address is not valid!\n");
		return 1;
	}
	preamble.buffer[0] = slaveAddr;						/************** command block ***************************************/
	preamble.buffer[1] = highAddr;
	preamble.buffer[2] = lowAddr;
	preamble.ctrlMask = 0x0000;
	preamble.length = 3; /*  Three byte preamble. */
	buf[0] = highData;

	apiRetStatus = CyU3PI2cTransmitBytes(&preamble, buf, 1, 0);
#ifdef DbgInfo
	CyU3PDebugPrint(4, "sensor write2B(0) %d %d %d\r\n", lowAddr, buf[0], lowData); //additional debug
#endif
	SensorI2CAccessDelay(apiRetStatus);

	buf[0] = lowData;								/****************** data block *****************************************/
	preamble.ctrlMask = 0x0000;
	preamble.length = 1;
	apiRetStatus = CyU3PI2cTransmitBytes(&preamble, buf, 1, 0);
#ifdef DbgInfo
	CyU3PDebugPrint(4, "sensor write2B(1) %d %d %d\r\n", lowAddr, buf[0], buf[1]); //additional debug
#endif
	/* Set the parameters for the I2C API access and then call the write API. */
	SensorI2CAccessDelay(apiRetStatus);
	return apiRetStatus;
}
Exemplo n.º 4
0
CyU3PReturnStatus_t SensorRead2B2(
		uint8_t slaveAddr, 
		uint8_t highAddr,
		uint8_t lowAddr, 
		uint8_t RegAdd,
		uint8_t *buf) {
	
	CyU3PReturnStatus_t apiRetStatus = CY_U3P_SUCCESS;
	CyU3PI2cPreamble_t preamble;

	if ((slaveAddr != SENSOR_ADDR_RD) && (slaveAddr != I2C_MEMORY_ADDR_RD)) {
		CyU3PDebugPrint(4, "I2C Slave address is not valid!\n");
		return 1;
	}
	preamble.buffer[0] = slaveAddr & I2C_SLAVEADDR_MASK; /*  Mask out the transfer type bit. */
	preamble.buffer[1] = highAddr; //highAddr;
	preamble.buffer[2] = lowAddr; //lowAddr;
	preamble.length = 3;
	preamble.ctrlMask = 0x0000; /*  Send start bit after third byte of preamble. */
	buf[0] = RegAdd;
#ifdef DbgInfo
	CyU3PDebugPrint(4, "sensor read2B(0) %d %d %d\r\n", lowAddr, buf[0], buf[1]); //additional debug
#endif
#if 0
	apiRetStatus = CyU3PI2cTransmitBytes(&preamble, buf, 1, 0); //send command block to prepare for reading
	/*** test I2C bus ready ****/
	if(apiRetStatus != CY_U3P_SUCCESS){
		CyU3PDebugPrint(4, "sensor read2B(T) %d %d %d\r\n", apiRetStatus, buf[0], buf[1]);
	}

#ifdef DbgInfo
	CyU3PDebugPrint(4, "sensor read2B(1) %d %d %d\r\n", lowAddr, buf[0], buf[1]); //additional debug
#endif
	SensorI2CAccessDelay(apiRetStatus);
	preamble.buffer[0] = slaveAddr;
	preamble.length = 1;
	preamble.ctrlMask = 0x0000;
#endif
	apiRetStatus = CyU3PI2cReceiveBytes(&preamble, buf, 1, 0);//send data block read one byte
	/*** test I2C bus ready ****/
	if(apiRetStatus != CY_U3P_SUCCESS){
		CyU3PDebugPrint(4, "sensor read2B(R) %d %d %d\r\n", apiRetStatus, buf[0], buf[1]);
	}
	SensorI2CAccessDelay(apiRetStatus);
#ifdef DbgInfo
	CyU3PDebugPrint(4, "sensor read2B(2) %d %d %d\r\n", apiRetStatus, buf[0], buf[1]); //additional debug
#endif
	return apiRetStatus;
}
Exemplo n.º 5
0
// Write to an I2C slave with two bytes of data.
static CyU3PReturnStatus_t SensorWrite2B(uint8_t slaveAddress,
					 uint8_t highAddress,
					 uint8_t lowAddress,
					 uint8_t highData,
					 uint8_t lowData) {
	CyU3PReturnStatus_t api_status = CY_U3P_SUCCESS;
	CyU3PI2cPreamble_t preamble;
	uint8_t buf[2];


	// Validate the I2C slave address.
	if (slaveAddress != SENSOR_WRITE_ADDRESS)
	{
		CyU3PDebugPrint(4, "I2C Slave address is not valid!\r\n");
		return 1;
	}

	// Set the parameters for the I2C API access and then call the write API.
	preamble.buffer[0] = slaveAddress;
	preamble.buffer[1] = highAddress;
	preamble.buffer[2] = lowAddress;
	preamble.length = 3;            //  Three byte preamble.
	preamble.ctrlMask = 0x0000;     //  No additional start and stop bits.

	buf[0] = highData;
	buf[1] = lowData;

	api_status = CyU3PI2cTransmitBytes(&preamble, buf, 2, 0);
	SensorI2CAccessDelay(api_status);

	if (api_status == CY_U3P_SUCCESS) {
		CyU3PDebugPrint (4, "Write Camera REG address = 0x%x%x%x%x data = 0x%x%x%x%x\r\n",
				 highAddress >> 4,
				 highAddress & 0x0f,
				 lowAddress >> 4,
				 lowAddress & 0x0f,
				 highData >> 4,
				 highData & 0x0f,
				 lowData >> 4,
				 lowData & 0x0f);

	} else {
Exemplo n.º 6
0
CyBool_t handle_serial_num(uint8_t bReqType, uint16_t wLength) {
  CyU3PI2cPreamble_t preamble;
  uint32_t reg_addr = FX3_PROM_SERIALNUM0_0;
  uint8_t dev_addr = 0x50;
  uint8_t size = 17; // size of prom
  uint16_t status;

  if (wLength != 16) {
    log_error("Bad length=%d \n", wLength);
    return CY_U3P_ERROR_BAD_ARGUMENT;
  }

  switch(bReqType) {
  case 0xC0:
    preamble.length    = 4;
    preamble.buffer[0] = m24xx_get_dev_addr(dev_addr, reg_addr, size, 0);
    preamble.buffer[1] = (uint8_t)(reg_addr >> 8);
    preamble.buffer[2] = (uint8_t)(reg_addr & 0xFF);
    preamble.buffer[3] = m24xx_get_dev_addr(dev_addr, reg_addr, size, 1);
    preamble.ctrlMask  = 0x0004;
    status = CyU3PI2cReceiveBytes (&preamble, gSerialNum, 16, 1);
    if(status) {
      log_error("Error reading serial num from prom (%d)\n", status);
      return CyFalse;
    }
    status = CyU3PUsbSendEP0Data(16, gSerialNum);
    if(status) {
      log_error("Error Sending serial num to EP0 (%d)\n", status);
      return CyFalse;
    }
    return CyTrue;

  case 0x40:
    status = CyU3PUsbGetEP0Data(wLength, gSerialNum, 0);
    if(status) {
      log_error("Error getting serial num from EP0 (%d)\n", status);
      return status;
    }

    preamble.length    = 3;
    preamble.buffer[0] = m24xx_get_dev_addr(dev_addr, reg_addr, size, 0);
    preamble.buffer[1] = (uint8_t)(reg_addr >> 8);
    preamble.buffer[2] = (uint8_t)(reg_addr & 0xFF);
    preamble.ctrlMask  = 0x0000;
    
    status = CyU3PI2cTransmitBytes(&preamble, gSerialNum, 16, 1);
    if(status) {
      log_error("Error writing serial num to I2C (%d)\n", status);
      return CyFalse;
    }
    
    /* Wait for the write to complete. */
    preamble.length = 1;
    status = CyU3PI2cWaitForAck(&preamble, 200);
    if(status) {
      log_error("Error waiting for i2c ACK after writing serial num (%d)\n", status);
      return CyFalse;
    }
    
    /* An additional delay seems to be required after receiving an ACK. */
    CyU3PThreadSleep (1);
    return CyTrue;


  default:
    log_error("Bad ReqType=%d \n", bReqType);
    return CY_U3P_ERROR_BAD_ARGUMENT;
  }
}