Exemplo n.º 1
0
uint8_t ov7670_get(uint8_t reg) {
	uint8_t data = 0;
	I2C_start(I2C2, 0x42, I2C_Direction_Transmitter);
	I2C_write(I2C2, reg);
	I2C_stop(I2C2);
	delayx(1000);
	I2C_start(I2C2, 0x43, I2C_Direction_Receiver);
	data = I2C_read_nack(I2C2);
	I2C_stop(I2C2);
	delayx(1000);
	return data;
}
Exemplo n.º 2
0
uint8_t I2C_Read_Reg(I2C_TypeDef* I2Cx, uint8_t Device, uint8_t Register)
{
	uint8_t data;
	
	I2C_start(I2Cx, Device <<1, I2C_Direction_Transmitter); // start a transmission in Master transmitter mode
	I2C_write(I2Cx, Register); // Select the register you want to read from.
	I2C_stop(I2Cx); // stop the transmission

	I2C_start(I2Cx, Device <<1, I2C_Direction_Receiver); // start a transmission in Master receiver mode
	data = I2C_read_nack(I2Cx); // read one byte from the register of interest.
	I2C_stop(I2Cx);
	return data;
}
Exemplo n.º 3
0
//-----------------------------------------------------------------------------
// /brief Write a register on the AIC3106.
// 
// /param uint8_t in_reg_addr: The address of the register to be written to.
//
// /param uint8_t data: Data to be written to the register
//
// /return uint32_t ERR_NO_ERROR on sucess
//
//-----------------------------------------------------------------------------
uint32_t AIC3106_writeRegister(uint8_t in_reg_addr, uint8_t in_data)
{
   uint32_t rtn;
   uint8_t i2c_data[2];
   
   i2c_data[0] = in_reg_addr;
   i2c_data[1] = in_data;

   // write the register that we want to read.
   rtn = I2C_write(I2C_PORT_AIC3106, I2C_ADDR_AIC3106, i2c_data, 2, SET_STOP_BIT_AFTER_WRITE);

   return (rtn);
}
// ds1307 rtc write 
bit rtwr (void) 
{                     
    unsigned char i;                   // return 0=ok 1=error 
    bit err;
    I2C_start();
    err = I2C_write(0xd0);             // address & r/w bit 
    if (!err) 
    {
        err = I2C_write(0x00);         // start register addr=0 
        if (!err) 	
        {
            for (i=0;i<=7;i++) 
            {
                err = I2C_write(TIMBUF[i]);
                if (err) 
                    break;
            }
        }
    }
    I2C_stop();
    return (err);
}
Exemplo n.º 5
0
void mRGB_SetColor(uint8_t *color)
{
	// Addresses was set previously, only require functional code and
	// data
	mRGB_cmd[FUNCODE] = SET_RGB;			// Set pullup register
	
	// Load the requested color in RGB format into the command buffer
	for(U8 i=0;i<3;i++)
		mRGB_cmd[DATA1+i]	  = *(color+i);

	// Write data on I2C bus	
	I2C_write(mRGB_cmd, 7);				
}									
Exemplo n.º 6
0
void AK8963_ReadMag(IMU_DATA_t *mag)
{
    int i = 0;
    uint8_t buffer[7];  // x/y/z gyro register data, ST2 register stored here, must read ST2 at end of data acquisition
    uint16_t rmag[3];

    I2C_start(I2C1, AK8963_ADDRESS<<1, I2C_Direction_Transmitter);
    I2C_write(I2C1, AK8963_ST1);
    I2C_stop(I2C1); // stop the transmission

    // start a transmission in Master receiver mode
    I2C_start(I2C1, AK8963_ADDRESS<<1, I2C_Direction_Receiver);
    if(I2C_read_nack(I2C1) & 0x01){
        I2C_start(I2C1, AK8963_ADDRESS<<1, I2C_Direction_Transmitter);
        I2C_write(I2C1, AK8963_XOUT_L);
        I2C_stop(I2C1); // stop the transmission
        I2C_start(I2C1, AK8963_ADDRESS<<1, I2C_Direction_Receiver);

        for(i = 0; i < 7-1; i++){
            buffer[i] = I2C_read_ack(I2C1);
        }
        // read one byte and don't request another byte, stop transmission
        buffer[7-1] = I2C_read_nack(I2C1);

        if(!(buffer[6] & 0x08)) { // Check if magnetic sensor overflow set, if not then report data
            // maybe change to 1, 0, 3, 2,  5, 4
            rmag[0] = (((int16_t) buffer[0]) << 8) | buffer[1];  // X axis (internal sensor y axis)
            rmag[1] = (((int16_t) buffer[2]) << 8) | buffer[3];  // Y axis (internal sensor x axis)
            rmag[2] = (((int16_t) buffer[4]) << 8) | buffer[5];  // Z axis (internal sensor z axis)

            // maybe it should look lik this:
            // (float)buffer[0]*MAG_SCALE*mag_calibration[0] - MAG_X_OFFSET;
            mag->Roll = (float)(rmag[0] - MAG_X_OFFSET) * MAG_SCALE * mag_calibration[0];
            mag->Pitch = (float)(rmag[1] - MAG_Y_OFFSET) * MAG_SCALE * mag_calibration[1];
            mag->Yaw = (float)(rmag[2] - MAG_Z_OFFSET) * MAG_SCALE * mag_calibration[2];
        }
    }
}
Exemplo n.º 7
0
//-----------------------------------------------------------------------------
// /brief Read data from a register on the AIC3106.
// 
// /param uint8_t in_reg_addr: The address of the register to be read from.
//
// /param uint8_t * dest_buffer: Pointer to buffer to store retrieved data.
//
// /return uint32_t ERR_NO_ERROR on sucess
//
//-----------------------------------------------------------------------------
uint32_t AIC3106_readRegister(uint8_t in_reg_addr, uint8_t *dest_buffer)
{
   uint32_t rtn;

   // write the register address that we want to read.
   rtn = I2C_write(I2C_PORT_AIC3106, I2C_ADDR_AIC3106, &in_reg_addr, 1, SKIP_STOP_BIT_AFTER_WRITE);
   if (rtn != ERR_NO_ERROR)
      return (rtn);

   // clock out the register data.
   rtn = I2C_read(I2C_PORT_AIC3106, I2C_ADDR_AIC3106, dest_buffer, 1, SKIP_BUSY_BIT_CHECK);
   
   return (rtn);
}
Exemplo n.º 8
0
/*----------------------------------------------------------------------------
//Initialises the GPIO device with a set of default paramters
 *----------------------------------------------------------------------------*/
void	I2C_GPIO_Init(void){
	
	//Select config register values
		uint8_t config_reg_data = 0x00;
		uint8_t seqop				=	0;	//Sequential Operation mode bit
		uint8_t disslw			=	0;	//Slew Rate control bit for SDA output
		uint8_t	odr					=	0;	//INT pin as an open-drain output
		uint8_t intpol			=	0;	//Sets the polarity of the INT output pin.

	//Merge config reg values into a single byte
		config_reg_data  = 0x00;
		config_reg_data |= (seqop		<<	5);
		config_reg_data |= (disslw	<<	4);
		config_reg_data |= (odr			<<	2);
		config_reg_data |= (intpol	<<	1);
		
	//Initialise by writing the config variable to the CONFIG register
		I2C_start(I2C3, GPIO_ADDRESS, I2C_Direction_Transmitter); // start a transmission in Master transmitter mode
		I2C_write(I2C3, GPIO_IOCON_REG);	//Set device pointer to configuration register
		I2C_write(I2C3, config_reg_data);	//Write the config reg data to the config reg
		I2C_stop(I2C3);
		Delay_Millis(5);	//Ensure config values are implemented before continuing
}
Exemplo n.º 9
0
// \return  uint32_t
//    ERR_NO_ERROR - register written to correctly.
//
//-----------------------------------------------------------------------------
uint32_t CDCE913_writeByte(uint8_t in_offset, uint8_t in_data)
{
   uint32_t rtn;
   uint8_t i2c_data[2];
   
   // set bit to indicate this is a byte write.
   i2c_data[0] = in_offset | BYTE_READ_WRITE_BIT;
   i2c_data[1] = in_data;

   // write the register that we want to read.
   rtn = I2C_write(I2C_PORT_CDCE913, I2C_ADDR_CDCE913, i2c_data, 2, SET_STOP_BIT_AFTER_WRITE);

   return (rtn);
}
Exemplo n.º 10
0
void ADXL345_init(void)
{
  I2C_write(ADXL345_Address,0x31,0x08);   //测量范围,正负2g,13位模式 分辨率4mg
  I2C_write(ADXL345_Address,0x2C,0x08);   //速率设定为12.5 参考pdf13页
  I2C_write(ADXL345_Address,0x2D,0x08);   //选择电源模式   参考pdf24页
  //I2C_write(ADXL345_Address,0x2E,0x80);   //使能 DATA_READY 中断
  I2C_write(ADXL345_Address,0x1E,0x00);   //X 偏移量 根据测试传感器的状态写入pdf29页
  I2C_write(ADXL345_Address,0x1F,0x00);   //Y 偏移量 根据测试传感器的状态写入pdf29页
  I2C_write(ADXL345_Address,0x20,0x00);   //Z 偏移量 根据测试传感器的状态写入pdf29页
  I2C_write(ADXL345_Address,0x2F,0x00);		//配置freefall 为int1脚
  I2C_write(ADXL345_Address,0x28,0x07);
  I2C_write(ADXL345_Address,0x29,0x04);
  I2C_write(ADXL345_Address,0x2E,0x00+BIT2);//开启freefall int
  
  
  
  P1DIR&=~BIT0;
  P1IFG = 0;
  P1IES&=~BIT0;//上升中断
  P1IE |= BIT0;//17号  
  
  delay_ms(10);
}
Exemplo n.º 11
0
static PyObject *I2CDev_write(I2CDev *self, PyObject *args, PyObject *kwds) {
  uint32_t n_bytes, i, addr;
  long byte;
  PyObject *data, *byte_obj;
  uint8_t *txbuf; 
  if(!PyArg_ParseTuple(args, "IO!", &addr, &PyList_Type, &data)) {
    return NULL;
  }

  if (self->slave_addr != addr) {
    if (setSlaveAddress(self->i2c_fd, addr) < 0) {
      PyErr_SetString(PyExc_IOError, "could not configure I2C interface");
      return NULL;
    }
    self->slave_addr = addr;
  }

  n_bytes = PyList_Size(data);
  txbuf = malloc(n_bytes);

  for (i=0; i<n_bytes; i++) {
    byte_obj = PyList_GetItem(data, i);
    if (!PyInt_Check(byte_obj)) {
      PyErr_SetString(PyExc_ValueError, 
        "data list to transmit can only contain integers");
      free(txbuf);
      return NULL;
    }
    byte = PyInt_AsLong(byte_obj);
    if (byte < 0) {
      // Check for error from PyInt_AsLong:
      if (PyErr_Occurred() != NULL) return NULL;
      // Negative numbers are set to 0:
      byte = 0;
    }
    // Just send the LSB if value longer than 1 byte:
    byte &= 255;
    txbuf[i] = (uint8_t) byte;
  }

  if (I2C_write(self->i2c_fd, (void *) txbuf, n_bytes) < 0) {
    PyErr_SetString(PyExc_IOError, "could not write to I2C device");
    free(txbuf);
    return NULL;
  }
  free(txbuf);
  Py_INCREF(Py_None);
  return Py_None;
}
Exemplo n.º 12
0
alt_u8 i2c_hdmi_rx_hdmi_map_r(alt_u8 reg)
{
    uint32_t offset = reg;
    uint32_t data;
    pcie_i2c_read(0x68>>1, offset, &data, 1);
    return data;
#if 0
	 I2C_start(I2C_CTRL_BASE,0x68>>1,0); //address the chip in write mode
	data =  I2C_write(I2C_CTRL_BASE,reg,0);  // set command to read input register.
	I2C_start(I2C_CTRL_BASE,0x68>>1,1); //send start again but this time in read mode
	data =  I2C_read(I2C_CTRL_BASE,1);  // read the input register and send stop

	return data;
#endif
}
/*************************************************************************
 Writes a string or char to the Midas MCCOG21605B6W-SPTLYI LCD display

 Input:   String to display as "Hello World!"

 Return:

*************************************************************************/
void LCD_Write(const char *format, ...){

	va_list aptr;
	int len;
	Int16 ret;

	va_start(aptr, format);
	len = vsprintf(buffer, format, aptr);

	Uint16 startStop = ((CSL_I2C_START) | (CSL_I2C_STOP));
	CSL_Status  status;

	lcd_Init();

	int t;
	Uint16 ustr[sizeof(buffer)+1];
	ustr[0] = 0x40;
	for(t = 0; t < len; t++)
	{
		ustr[t+1] = (Uint16)buffer[t];
	}

	status = I2C_write(ustr, (len <= 16)?(len+1):17, I2C_DISPLAY_ADDRESS, TRUE, startStop, CSL_I2C_MAX_TIMEOUT);
	lcd_Delay();

	if(len > 16) {
		Uint16 l[] = {0x00, 0xC0};
		status = I2C_write(l, 2, I2C_DISPLAY_ADDRESS, TRUE, startStop, CSL_I2C_MAX_TIMEOUT);
		lcd_Delay();

		ustr[16] = 0x40;
		status = I2C_write(ustr+16, len-15, I2C_DISPLAY_ADDRESS, TRUE, startStop, CSL_I2C_MAX_TIMEOUT);
		lcd_Delay();
	}

}
Exemplo n.º 14
0
//
//	Originally, 'endTransmission' was an f(void) function.
//	It has been modified to take one parameter indicating
//	whether or not a STOP should be performed on the bus.
//	Calling endTransmission(false) allows a sketch to 
//	perform a repeated start. 
//
//	WARNING: Nothing in the library keeps track of whether
//	the bus tenure has been properly ended with a STOP. It
//	is very possible to leave the bus in a hung state if
//	no call to endTransmission(true) is made. Some I2C
//	devices will behave oddly if they do not see a STOP.
//
uint32 I2CBus::endTransmission(bool sendStop)
{
	//  int8_t ret = 0;
  // transmit buffer (blocking)
	if ( sendStop ) {
		if ( I2C_write(i2cx, dstaddress, txbuffer, txlength) ) {
			return txlength;
		}
	} else {
		if ( I2C_request(i2cx, dstaddress, txbuffer, txlength) ) {
			return txlength;
		}
	}
	return 0;
}
Exemplo n.º 15
0
// Чтение из регистра кодека
uint16 aic3204_get(uint16 regnum, uint16* regval) {
// Локальные данные
	int16 retcode = 0;
	uint8 cmd[1];
// Сформировать пакет I2C
	cmd[0] = regnum & 0x007F; // 7 бит адреса регистра
// Выдать команду
	retcode |= I2C_write(AIC3204_ICADDR, cmd, 1);
// Получить ответ
	retcode |= I2C_read(AIC3204_ICADDR, cmd, 1);
// Ожидание завершения переходных процессов
	c5515_wait(10);
// Возврат результата
	*regval = cmd[0];
	return retcode;
}
Exemplo n.º 16
0
/*----------------------------------------------------------------------------
//Reads the GPIO register of the GPIO device
//Returns: GPIO register byte ( LSB is GP0, MSB is GP7 )
//IMPORTANT: Data is only valid for pins configured as INPUT pins!
 *----------------------------------------------------------------------------*/
uint8_t	I2C_GPIO_Read(void){
	
	uint8_t rxData	=	0x00;
	
	//Indicate we'd like to read the GPIO register
		I2C_start(I2C3, GPIO_ADDRESS, I2C_Direction_Transmitter);
		I2C_write(I2C3, GPIO_GPIO_REG);
		I2C_stop(I2C3);

	//Then  open in RX mode and get the data
		I2C_start(I2C3, GPIO_ADDRESS, I2C_Direction_Receiver);
		rxData	=	I2C_read_nack(I2C3);
		I2C_stop(I2C3);	// stop the transmission
	
	return rxData;
}
Exemplo n.º 17
0
// \return  uint32_t
//    ERR_NO_ERROR - register read correctly.
//
//-----------------------------------------------------------------------------
uint32_t CDCE913_readByte(uint8_t in_offset, uint8_t *dest_buffer)
{
   uint32_t rtn;
   
   // set bit to indicate this is a byte read.
   SETBIT(in_offset, BYTE_READ_WRITE_BIT);

   // write the register address that we want to read.
   rtn = I2C_write(I2C_PORT_CDCE913, I2C_ADDR_CDCE913, &in_offset, 1, SKIP_STOP_BIT_AFTER_WRITE);
   if (rtn != ERR_NO_ERROR)
      return (rtn);

   // clock out the register data.
   rtn = I2C_read(I2C_PORT_CDCE913, I2C_ADDR_CDCE913, dest_buffer, 1, SKIP_BUSY_BIT_CHECK);
   
   return (rtn);
}
Exemplo n.º 18
0
Arquivo: LED.c Projeto: decyborg/clock
/*	write_display(string, dot)
*	Writes to the display the string that is passed (string must be 4 characters long), and sets the dot of the last segment if dot = 1
*/
void write_display(unsigned char* string, unsigned char dot)
{
	unsigned char displayBuffer[9];
	displayBuffer[0] = 0x00;
	for(int i = 1, j = 0; i < 9; i++)
	{	
		if(i%2)
			displayBuffer[i] = alphafonttable[string[j]] & 0xFF;
		else{
			displayBuffer[i] = alphafonttable[string[j]] >> 8;
			++j;
		}
	}
	if(dot)
		displayBuffer[8] |= 1 << 6;
	I2C_write(HT16K33_SLA, displayBuffer, 9);	
}
Exemplo n.º 19
0
int ds2482_write_config(int8 config){
int8 read_config; 

i2c_start();
i2c_write(DS2482_I2C_ADDR | I2C_FLAG_WRITE);
i2c_write(DS2482_CMD_WCFG);
I2C_write(config | (~config << 4)); //This makes the ones compliment in the top nibble ***Checked Working***
i2c_start();
i2c_write(DS2482_I2C_ADDR | I2C_FLAG_READ);
read_config = i2c_read(0);
i2c_stop();
// check for failure due to incorrect read back
if (config != read_config){
   DS2482_reset();
   return false;
}
return true;
}
Exemplo n.º 20
0
uint8_t I2C_readreg(uint32_t reg)
{
    uint8_t tmp;

    I2C_start(i2c_dev, SLAVE_ADDRESS, I2C_Direction_Transmitter); // start a transmission in Master transmitter mode
    I2C_write(i2c_dev, (uint8_t) reg); // write one byte to the slave
    I2C_stop(i2c_dev); // stop the transmission

    Delay(100);

    I2C_start(i2c_dev, SLAVE_ADDRESS, I2C_Direction_Receiver); // start a transmission in Master receiver mode
    tmp = I2C_read_nack(i2c_dev);
    I2C_stop(i2c_dev); // stop the transmission

    Delay(100);

    return tmp;
}
Exemplo n.º 21
0
void I2C_Read_Multi_Reg(I2C_TypeDef* I2Cx, uint8_t Device, uint8_t Register, uint8_t* buf, uint8_t count)
{	uint8_t i = 0;
	I2C_start(I2Cx, Device  <<1, I2C_Direction_Transmitter); 	// start a transmission in Master transmitter mode
	I2C_write(I2Cx, Register); 									// Select the register you want to start your read at.
	I2C_stop(I2Cx); 											// stop the transmission

	I2C_start(I2Cx, Device <<1, I2C_Direction_Receiver); // start a transmission in Master receiver mode
	for(i =0; i < count; i++)
	{
		if (i < (count - 1))
		{
			buf[i] = I2C_read_ack(I2Cx); // Read one byte and send an ack to the slave.
		}
		else
		{
			buf[i] = I2C_read_nack(I2Cx); // Read the last register and send a Nack.
			I2C_stop(I2Cx);
		}
	}
}
Exemplo n.º 22
0
/*----------------------------------------------------------------------------
//Reads temperature registers from temp sensor
//Returns the temperature, in Celsius
 *----------------------------------------------------------------------------*/
double	I2C_Temp_Read(void){
	
	double	temperature;
	uint16_t	recievedData[2]	=	{0,0};
	
	//Indicate we'd like to read the temperature register
		I2C_start(I2C3, TEMP_ADDRESS, I2C_Direction_Transmitter);
		I2C_write(I2C3, TEMP_READ_REG);
		I2C_stop(I2C3);

	//Then  open in RX mode and get the data
		I2C_start(I2C3, TEMP_ADDRESS, I2C_Direction_Receiver);
		recievedData[0]	=	I2C_read_ack(I2C3);		//read first byte
		recievedData[1]	=	I2C_read_nack(I2C3);	//read second byte
		I2C_stop(I2C3);	// stop the transmission	
		
	recievedData[1]	|=	recievedData[0]<<8;
	temperature	=	pow(2,-8)	*	(double)recievedData[1];

	return temperature;
}
Exemplo n.º 23
0
static PyObject *I2CDev_readTransaction(I2CDev *self, PyObject *args, 
                                        PyObject *kwds) {
  uint32_t n_bytes, i, addr;
  uint8_t byte;
  PyObject *data, *byte_obj;
  uint8_t *rxbuf; 
  if(!PyArg_ParseTuple(args, "IbI", &addr, &byte, &n_bytes)) {
    return NULL;
  }

  if (self->slave_addr != addr) {
    if (setSlaveAddress(self->i2c_fd, addr) < 0) {
      PyErr_SetString(PyExc_IOError, "could not configure I2C interface");
      return NULL;
    }
    self->slave_addr = addr;
  }

  rxbuf = malloc(n_bytes);

  if (I2C_write(self->i2c_fd, (void *) &byte, 1) < 0) {
    PyErr_SetString(PyExc_IOError, "could not write to I2C device");
    free(rxbuf);
    return NULL;
  }
  if (I2C_read(self->i2c_fd, (void *) rxbuf, n_bytes) < 0) {
    PyErr_SetString(PyExc_IOError, "could not read from I2C device");
    free(rxbuf);
    return NULL;
  }

  data = PyList_New(0);
  for (i=0; i<n_bytes; i++) {
    byte_obj = PyInt_FromLong((long) rxbuf[i]);
    PyList_Append(data, byte_obj);
    Py_DECREF(byte_obj);
  }
  free(rxbuf);
  return data;
}
Exemplo n.º 24
0
CSL_Status AIC_Write(Uint16 regAddr, Uint16 regValue)
{
	CSL_Status  status;
	Uint16      startStop;
	Uint16      write_buffer[2];
	volatile Uint16    looper;

	startStop = ((CSL_I2C_START) | (CSL_I2C_STOP));

	write_buffer[0] = regAddr;
	write_buffer[1] = regValue;

	/* Write data */
	status = I2C_write(write_buffer, 2,
                       CSL_I2C_CODEC_ADDR, TRUE, startStop,
                       CSL_I2C_MAX_TIMEOUT);
    
    /* Give some delay */              	
	for(looper = 0; looper < CSL_I2C_MAX_TIMEOUT; looper++){;}
                      
	return status;
}
void init_ColorVision(void) {
	
	// initialize ov6620 cmos camera
	i2cdata[0] = 0x01;
	i2cdata[1] = 0x8F;  // Blue Gain control (default 0x80)
	i2cdata[2] = 0x8F;  // Red Gain Control
	i2cdata[3] = 0x80;  // Saturation
	i2cdata[4] = 0x00;  // Reserved
	i2cdata[5] = 0x4f;  // Contrast
	i2cdata[6] = 0x9f; // Brightness
	i2cdata[7] = 0xCF; // Sharpness  (default 0xC6) 			
	i2cdata[8] = 0x00; // Reserved			
	i2cdata[9] = 0x00; // Reserved   		
	i2cdata[10] = 0x00; // Reserved   		
	i2cdata[11] = 0x00; // Reserved   	
	i2cdata[12] = 0x20; // AWB - Blue   		
	i2cdata[13] = 0x20; // AWB - Red   		
	i2cdata[14] = 0x0D; // COMR   		
	i2cdata[15] = 0x05; // COMS   		
	i2cdata[16] = 0x9A; // AEC
	i2cdata[17] = 0x01; // CLKRC   		
	i2cdata[18] = 0x28; // COMA  
	i2cdata[19] = 0x01; // 0x01; // COMB  
	I2C_write(I2C0, 0x60, i2cdata, 20, SET_STOP_BIT_AFTER_WRITE);
	
	i2cdata[0] = 0x20;
	i2cdata[1] = 0x01; // COME
	I2C_write(I2C0, 0x60, i2cdata, 2, SET_STOP_BIT_AFTER_WRITE);
	
	i2cdata[0] = 0x28;
	i2cdata[1] = 0x81; // COMH
	I2C_write(I2C0, 0x60, i2cdata, 2, SET_STOP_BIT_AFTER_WRITE);
	
	i2cdata[0] = 0x39;
	// changed to PCLK always on.  
	i2cdata[1] = 0x00; //0x40; // COML
	I2C_write(I2C0, 0x60, i2cdata, 2, SET_STOP_BIT_AFTER_WRITE);
	
		
    VPIF_initReceive(VIDEO_CONN_CAMERA);

	// PRU setup
	EVMOMAPL138_lpscTransition(PSC0, DOMAIN0, LPSC_DMAX, PSC_ENABLE);
	PRU_stop(PRU0);
	PRU_reset(PRU0);
	PRU_load(PRU0_PROG, PRUCode, sizeof(PRUCode)/sizeof(uint32_t));
	PRU_reset(PRU0);
	PRU_run(PRU0);

	// VPIF (95) interrupt serviced by INT4
	ICR = 0x010; // clear pending interrupts
	IER |= 0x010; // enable interrupt on line    

	// PRU (6) interrupt serviced by INT6
	ICR = 0x040; // clear pending interrupts
	IER |= 0x040; // enable interrupt on line    
	
	pic_data = (int *)ADDR_VIDEO_DATA_BASE;

    Image_data = (bgr *)(IMAGE_DATA_MEM);
    
	Thres_Image = (unsigned char *)(THRES_IMAGE_MEM); 
		
	Linux_Image = (bgr *)(ADDR_VIDEO_DATA_BASE+LINUX_IMAGE_OFFSET);
	
	LCD_Image = (bgr *)(ADDR_VIDEO_DATA_BASE+LCD_IMAGE_OFFSET);
	
	ptrshrdmem = (sharedmemstruct *)SHARED_MEM;	


	while (CHKBIT(VPIF->INTSTAT,INT_FRAME_CH1) == 0) {}
	SETBIT(VPIF->INTSTATCLR, INT_FRAME_CH1);
	
}
Exemplo n.º 26
0
    return data;
#if 0
	 I2C_start(I2C_CTRL_BASE,0x68>>1,0); //address the chip in write mode
	data =  I2C_write(I2C_CTRL_BASE,reg,0);  // set command to read input register.
	I2C_start(I2C_CTRL_BASE,0x68>>1,1); //send start again but this time in read mode
	data =  I2C_read(I2C_CTRL_BASE,1);  // read the input register and send stop

	return data;
#endif
}
//HDMI_RX_KSV_MAP
int i2c_hdmi_rx_ksv_map_w(alt_u8 reg, alt_u8 data1)
{
#if 0
	 I2C_start(I2C_CTRL_BASE,0x64>>1,0); //address the chip in write mode
	data =  I2C_write(I2C_CTRL_BASE,reg,0);  // write register.
	data =  I2C_write(I2C_CTRL_BASE,data1,1);  // write vial.

	return data;
#endif
    uint32_t data = data1;
    return pcie_i2c_write(0x64>>1,reg,&data,1);
}

alt_u8 i2c_hdmi_rx_ksv_map_r(alt_u8 reg)
{
    uint32_t offset = reg;
    uint32_t data;
    pcie_i2c_read(0x64>>1, offset, &data, 1);
    return data;
#if 0
Exemplo n.º 27
0
int main()
{
    CyGlobalIntEnable; 
    UART_Start();
    printf("Start\r\n");
    
    
     /*  //IR receiver//
    ----------------------------------------------------
    unsigned int IR_val; 
    
    for(;;)
    {
       IR_val = get_IR();
       printf("%x\r\n\n",IR_val);
    }
    
    ///---------------------------------------------------------- */
    
    /*
        //Ambient//
    ----------------------------------------------------
    I2C_Start();
    
    uint16 value =0;
    
    I2C_write(0x29,0x80,0x00);
    
    value = I2C_read(0x29,0x80);
    printf("%x ",value);
    
    I2C_write(0x29,0x80,0x03);
    value = I2C_read(0x29,0x80);
    printf("%x\r\n",value);
        
    value = I2C_read(0x29,0x81);
    printf("%x\r\n",value);
    for(;;)
    {
        
        uint8 Data0Low,Data0High,Data1Low,Data1High;
        Data0Low = I2C_read(0x29,CH0_L);
        Data0High = I2C_read(0x29,CH0_H);
        Data1Low = I2C_read(0x29,CH1_L);
        Data1High = I2C_read(0x29,CH1_H);
        
        uint8 CH0, CH1;
        CH0 = convert_raw(Data0Low,Data0High);
        CH1 = convert_raw(Data1Low,Data1High);

   //     printf("%d %d %d %d\r\n",Data0Low,Data0High, Data1Low,Data1High);
   //     printf("%d %d\r\n",CH0,CH1);
   //        printf("%f\r\n",(float)CH1/CH0);
        
   
        double Ch0 = CH0;
        double Ch1 = CH1;
        
        double data = 0;
        data = getLux(Ch0,Ch1);
        printf("%lf\r\n",data);    
    }
    ///---------------------------------------------------------- */
    
    
       /*  //nunchuk//
    ----------------------------------------------------
    nunchuk_start();
    nunchuk_init();
    
    for(;;)
    {    
        nunchuk_read();
    }
    //----------------------------------------------------*/
    
     //accelerometer//
    //--------------------------------------------------------------
    I2C_Start();
  
    uint8 X_L_A, X_H_A, Y_L_A, Y_H_A, Z_L_A, Z_H_A;
    int16 X_AXIS, Y_AXIS, Z_AXIS;
    
    I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL1_REG, 0x37);           // set accelerometer & magnetometer into active mode
    I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL7_REG, 0x22);
    
    
    for(;;)
    {
        //print out accelerometer output
        X_L_A = I2C_read(ACCEL_MAG_ADDR, OUT_X_L_A);
        X_H_A = I2C_read(ACCEL_MAG_ADDR, OUT_X_H_A);
        X_AXIS = convert_raw(X_L_A, X_H_A);
        
        Y_L_A = I2C_read(ACCEL_MAG_ADDR, OUT_Y_L_A);
        Y_H_A = I2C_read(ACCEL_MAG_ADDR, OUT_Y_H_A);
        Y_AXIS = convert_raw(Y_L_A, Y_H_A);
        
        Z_L_A = I2C_read(ACCEL_MAG_ADDR, OUT_Z_L_A);
        Z_H_A = I2C_read(ACCEL_MAG_ADDR, OUT_Z_H_A);
        Z_AXIS = convert_raw(Z_L_A, Z_H_A);
        
        //printf("ACCEL: %d %d %d %d %d %d \r\n", X_L_A, X_H_A, Y_L_A, Y_H_A, Z_L_A, Z_H_A);
        value_convert_accel(X_AXIS, Y_AXIS, Z_AXIS);
        printf("\n");
        
        CyDelay(50);
    }
    ///---------------------------------------------------------- 
     
     /* //ultra//
    ----------------------------------------------------
    ultra_isr_StartEx(ultra_isr_handler);   // Ultra Sonic Interrupt
    Ultra_Start();                          // Ultra Sonic Start function
   
    for(;;)
    {       
        CyDelay(100); 
        Trig_Write(1);           // Trigger High
        CyDelayUs(10);              // 10 micro seconds for trigger input signals
        Trig_Write(0);           // Trigger Low
    }
    //----------------------------------------------------*/
    
    
    
    /* //reflectance//
    ----------------------------------------------------
    sensor_isr_StartEx(sensor_isr_handler);
    
    Refelctance_Start();

    IR_led_Write(1);
    for(;;)
    {
        reflectance_period();      //print out each period of reflectance sensors
        reflectance_digital();      //print out 0 or 1 according to results of reflectance period
        
        CyDelay(500);
    }
    ///----------------------------------------------------*/
   
    
     /* //motor//
    ----------------------------------------------------
    motor_Start();              // motor start

    motor_forward(50,2000);     // moving forward
    motor_turn(10,50,2000);     // turn
    motor_turn(50,10,2000);     // turn
    motor_backward(50,2000);    // movinb backward
       
    motor_Stop();               // motor stop
    
    for(;;)
    {

    }
    ///----------------------------------------------------*/
    
    /*
    //gyroscope//
     //-----------------------------------------------------
    I2C_Start();
  
    uint8 X_AXIS_L, X_AXIS_H, Y_AXIS_L, Y_AXIS_H, Z_AXIS_L, Z_AXIS_H;
    int16 X_AXIS, Y_AXIS, Z_AXIS;
    
    I2C_write(GYRO_ADDR, GYRO_CTRL1_REG, 0x0F);             // set gyroscope into active mode
    I2C_write(GYRO_ADDR, GYRO_CTRL4_REG, 0x30);             // set full scale selection to 2000dps    
    
    for(;;)
    {
        //print out gyroscope output
        X_AXIS_L = I2C_read(GYRO_ADDR, OUT_X_AXIS_L);
        X_AXIS_H = I2C_read(GYRO_ADDR, OUT_X_AXIS_H);
        X_AXIS = convert_raw(X_AXIS_H, X_AXIS_L);
        
        
        Y_AXIS_L = I2C_read(GYRO_ADDR, OUT_Y_AXIS_L);
        Y_AXIS_H = I2C_read(GYRO_ADDR, OUT_Y_AXIS_H);
        Y_AXIS = convert_raw(Y_AXIS_H, Y_AXIS_L);
        
        
        Z_AXIS_L = I2C_read(GYRO_ADDR, OUT_Z_AXIS_L);
        Z_AXIS_H = I2C_read(GYRO_ADDR, OUT_Z_AXIS_H);
        Z_AXIS = convert_raw(Z_AXIS_H, Z_AXIS_L);
        
        
        //printf("X_AXIS_L: %d, X_AXIS_H: %d, average: %d \r\n", X_AXIS_L, X_AXIS_H, (X_AXIS_H+X_AXIS_L)/2);
        //printf("Y_AXIS_L: %d, Y_AXIS_H: %d, average: %d \r\n", Y_AXIS_L, Y_AXIS_H, (Y_AXIS_H+Y_AXIS_L)/2);
        //printf("Z_AXIS_L: %d, Z_AXIS_H: %d, average: %d \r\n", Z_AXIS_L, Z_AXIS_H, (Z_AXIS_H+Z_AXIS_L)/2);
        
        //printf("H L : %d %d %d %d %d %d \r\n", X_AXIS_L, X_AXIS_H, Y_AXIS_L, Y_AXIS_H, Z_AXIS_L, Z_AXIS_H);
        //printf("%d %d %d \r\n", X_AXIS, Y_AXIS, Z_AXIS);
        printf("%d %d %d \r\n", value_convert_gyro(X_AXIS), value_convert_gyro(Y_AXIS), value_convert_gyro(Z_AXIS));
        
       CyDelay(50);
    }
    ///-----------------------------------------------------------------*/
   
  
    /*
     //magnetometer//
     //--------------------------------------------------------------
    I2C_Start();
   
    uint8 X_L_M, X_H_M, Y_L_M, Y_H_M, Z_L_M, Z_H_M;
    int16 X_AXIS, Y_AXIS, Z_AXIS;
    
    I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL1_REG, 0x37);           // set accelerometer & magnetometer into active mode
    I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL5_REG, 0x10);           // set a data rate of 50Hz
    I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL6_REG, 0x60);           // set the full scale selection to +/- 12 Gauss
    I2C_write(ACCEL_MAG_ADDR, ACCEL_CTRL7_REG, 0x80);           // set to continuous-conversion mode
    
    
    for(;;)
    {
        X_L_M = I2C_read(ACCEL_MAG_ADDR, OUT_X_L_M);
        X_H_M = I2C_read(ACCEL_MAG_ADDR, OUT_X_H_M);
        X_AXIS = convert_raw(X_L_M, X_H_M);
        
        Y_L_M = I2C_read(ACCEL_MAG_ADDR, OUT_Y_L_M);
        Y_H_M = I2C_read(ACCEL_MAG_ADDR, OUT_Y_H_M);
        Y_AXIS = convert_raw(Y_L_M, Y_H_M);
        
        Z_L_M = I2C_read(ACCEL_MAG_ADDR, OUT_Z_L_M);
        Z_H_M = I2C_read(ACCEL_MAG_ADDR, OUT_Z_H_M);
        Z_AXIS = convert_raw(Z_L_M, Z_H_M);
        
        heading(X_AXIS, Y_AXIS);
       // printf("MAGNET: %d %d %d %d %d %d \r\n", X_L_M, X_H_M, Y_L_M, Y_H_M, Z_L_M, Z_H_M);
        //printf("%d %d %d \r\n", X_AXIS,Y_AXIS, Z_AXIS);
        CyDelay(50);
          
    }
    ///----------------------------------------------------------*/
}
Exemplo n.º 28
0
/**
 *  \brief  Tests I2C polled mode operation
 *
 *  \param  none
 *
 *  \return Test result
 */
CSL_Status  CSL_i2cPolledTest(void)
{
	CSL_Status         status;
	CSL_Status         result;
	Uint16             startStop;
	volatile Uint16    looper;

	result = CSL_I2C_TEST_FAILED;

	/* Assign the EEPROM page address */
	gI2cWrBuf[0] = 0x0;
	gI2cWrBuf[1] = 0x0;

	for(looper = 0; looper < CSL_I2C_DATA_SIZE; looper++)
	{
		gI2cWrBuf[looper + CSL_EEPROM_ADDR_SIZE] = looper;
		gI2cRdBuf[looper] = 0x0000;
	}

	/* Initialize I2C module */
	status = I2C_init(CSL_I2C0);
	if(status != CSL_SOK)
	{
		printf("I2C Init Failed!!\n");
		return(result);
	}

	/* Setup I2C module */
	i2cSetup.addrMode    = CSL_I2C_ADDR_7BIT;
	i2cSetup.bitCount    = CSL_I2C_BC_8BITS;
	i2cSetup.loopBack    = CSL_I2C_LOOPBACK_DISABLE;
	i2cSetup.freeMode    = CSL_I2C_FREEMODE_DISABLE;
	i2cSetup.repeatMode  = CSL_I2C_REPEATMODE_DISABLE;
	i2cSetup.ownAddr     = CSL_I2C_OWN_ADDR;
	i2cSetup.sysInputClk = CSL_I2C_SYS_CLK;
	i2cSetup.i2cBusFreq  = CSL_I2C_BUS_FREQ;
	startStop            = ((CSL_I2C_START) | (CSL_I2C_STOP));

	status = I2C_setup(&i2cSetup);
	if(status != CSL_SOK)
	{
		printf("I2C Setup Failed!!\n");
		return(result);
	}

	/* Write data */
	status = I2C_write(gI2cWrBuf, (CSL_I2C_DATA_SIZE + CSL_EEPROM_ADDR_SIZE),
                       CSL_I2C_EEPROM_ADDR, TRUE, startStop,
                       CSL_I2C_MAX_TIMEOUT);
	if(status != CSL_SOK)
	{
		printf("I2C Write Failed!!\n");
		return(result);
	}

	printf("I2C Write Complete\n");

	/* Give some delay */
	for(looper = 0; looper < CSL_I2C_MAX_TIMEOUT; looper++){;}

	/* Write data EEPROM page address for read operation */
	status = I2C_write(gI2cWrBuf, CSL_EEPROM_ADDR_SIZE, CSL_I2C_EEPROM_ADDR,
	                   TRUE, startStop, CSL_I2C_MAX_TIMEOUT);
	if(status != CSL_SOK)
	{
		printf("I2C Write Failed!!\n");
		return(result);
	}

	/* Give some delay */
	for(looper = 0; looper < CSL_I2C_MAX_TIMEOUT; looper++){;}

	/* Read data */
	status = I2C_read(gI2cRdBuf, CSL_I2C_DATA_SIZE, CSL_I2C_EEPROM_ADDR,
	                   TRUE, startStop, CSL_I2C_MAX_TIMEOUT, FALSE);
	if(status != CSL_SOK)
	{
		printf("I2C Read Failed!!\n");
		return(result);
	}

	printf("I2C Read Complete\n");

	/* Compare the buffers */
	for(looper = 0; looper < CSL_I2C_DATA_SIZE; looper++)
	{
		if(gI2cWrBuf[looper + CSL_EEPROM_ADDR_SIZE] != gI2cRdBuf[looper])
		{
			printf("Read Write Buffers Does not Match!!\n");
			return(result);
		}
	}

	if(looper == CSL_I2C_DATA_SIZE)
	{
		printf("Read Write Buffers Match!!\n");
	}

	result = CSL_I2C_TEST_PASSED;
	return(result);
}
Exemplo n.º 29
0
/**
 *  \brief  Tests I2C polled mode operation
 *
 *  \param  none
 *
 *  \return Test result
 */
CSL_Status  CSL_i2cPolledTest(void)
{
	CSL_Status         status;
	CSL_Status         result;
	Uint16             startStop;
	volatile Uint16    looper;
    volatile int i;

	result = CSL_I2C_TEST_FAILED;

    /* Initialize I2C module */
	status = I2C_init(CSL_I2C0);
	if(status != CSL_SOK)
	{
		LOG_printf(&trace, "I2C Init Failed!!");
		return(result);
	}

	/* Setup I2C module */
	i2cSetup.addrMode    = CSL_I2C_ADDR_7BIT;				// EEPROM I2C device address is 7-bit (101.0xxx)
	i2cSetup.bitCount    = CSL_I2C_BC_8BITS;				// I2C bit count is 8-bit
	i2cSetup.loopBack    = CSL_I2C_LOOPBACK_DISABLE;
	i2cSetup.freeMode    = CSL_I2C_FREEMODE_DISABLE;
	i2cSetup.repeatMode  = CSL_I2C_REPEATMODE_DISABLE;
	i2cSetup.ownAddr     = CSL_I2C_OWN_ADDR;
	i2cSetup.sysInputClk = CSL_I2C_SYS_CLK;
	i2cSetup.i2cBusFreq  = CSL_I2C_BUS_FREQ;
	startStop            = ((CSL_I2C_START) | (CSL_I2C_STOP));

	status = I2C_setup(&i2cSetup);
	if(status != CSL_SOK)
	{
		LOG_printf(&trace, "I2C Setup Failed!!");
		return(result);
	}
	for(i = 0; i < CSL_I2C_PAGES; i++){
		LOG_printf(&trace, "Page %d", i);

		/* Assign the EEPROM page address */
		gI2cWrBuf[0] = (CSL_I2C_PAGE_SIZE*i)>>8;
		gI2cWrBuf[1] = (CSL_I2C_PAGE_SIZE*i)&0xFF;

		for(looper = 0; looper < CSL_I2C_PAGE_SIZE; looper++)
		{
			gI2cWrBuf[looper + CSL_EEPROM_ADDR_SIZE] = i*CSL_I2C_PAGE_SIZE + looper;
			gI2cRdBuf[looper] = 0x0000;
		}


		/* Write data */
		status = I2C_write(gI2cWrBuf, (CSL_I2C_PAGE_SIZE + CSL_EEPROM_ADDR_SIZE),
									   CSL_I2C_EEPROM_ADDR, TRUE, startStop,
									   CSL_I2C_MAX_TIMEOUT);
		if(status != CSL_SOK)
		{
			LOG_printf(&trace, "\tI2C Write Failed!!");
			return(result);
		}

		LOG_printf(&trace, "\tI2C Write Complete");

		/* Give some delay */
		for(looper = 0; looper < CSL_I2C_MAX_TIMEOUT; looper++){;}

		/* Read data */
		status = I2C_read(gI2cRdBuf, CSL_I2C_PAGE_SIZE, CSL_I2C_EEPROM_ADDR,
						  gI2cWrBuf, CSL_EEPROM_ADDR_SIZE, TRUE,
						  startStop, CSL_I2C_MAX_TIMEOUT, FALSE);
		if(status != CSL_SOK)
		{
			LOG_printf(&trace, "\tI2C Read Failed!!");
			return(result);
		}
		LOG_printf(&trace, "\tI2C Read Complete");

		/* Compare the buffers */
		for(looper = 0; looper < CSL_I2C_PAGE_SIZE; looper++)
		{
			if(gI2cWrBuf[looper + CSL_EEPROM_ADDR_SIZE] != gI2cRdBuf[looper])
			{
				LOG_printf(&trace, "\tRead Write Buffers Does not Match!!");
				return(result);
			}
		}
		if(looper == CSL_I2C_PAGE_SIZE)
		{
			LOG_printf(&trace, "\tRead Write Buffers Match!!");
		}
	}

	result = CSL_I2C_TEST_PASSED;
	return(result);
}
Exemplo n.º 30
0
int main(void)
{

	SystemInit();

	STM32F4_Discovery_LEDInit(LED3); //Orange
	STM32F4_Discovery_LEDInit(LED4); //Green
	STM32F4_Discovery_LEDInit(LED5); //Red
	STM32F4_Discovery_LEDInit(LED6); //Blue

	STM32F4_Discovery_PBInit(BUTTON_USER, BUTTON_MODE_GPIO);

	USBD_Init(&USB_OTG_dev,USB_OTG_FS_CORE_ID,&USR_desc,&USBD_CDC_cb,&USR_cb);
	SystemCoreClockUpdate(); // inicjalizacja dystrybucji czasu procesora
		init_I2C1(); // na podstawie: http://eliaselectronics.com/stm32f4-tutorials/stm32f4-i2c-mastertutorial/

		//acc
			I2C_start(I2C1, LSM303DL_A_ADDRESS, I2C_Direction_Transmitter);
			I2C_write(I2C1,0x20);   // LSM303_CTRL_REG1_A  0x20
			I2C_write(I2C1,0x27);   // Enable Accelerometer
			  	  	  	  	  	  	// 0x27 = 0b00100111
									// Normal power mode, all axes enabled
			I2C_stop(I2C1); // stop the transmission
		//acc
		//mag
				I2C_start(I2C1, LSM303DL_M_ADDRESS, I2C_Direction_Transmitter);
				I2C_write(I2C1,0x02);	  //LSM303_MR_REG_M   0x02
				I2C_write(I2C1,0x00);     // Enable Magnetometer
										  // 0x00 = 0b00000000
				  	  	  	  	  	  	  // Continuous conversion mode
				I2C_stop(I2C1);
		//mag
		//gyro
				I2C_start(I2C1, LSM303DL_G_ADDRESS, I2C_Direction_Transmitter);
				I2C_write(I2C1, 0x20);   //L3G_CTRL_REG1 0x20
				I2C_write(I2C1, 0x0F);   // 0x0F = 0b00001111
					  	  	  	  	     // Normal power mode, all axes enabled
				I2C_stop(I2C1);
		//gyro
	char start='0';
	while(1)
	{
					Delay(5);
					read_acc();
					read_mag();
					read_gyro();
					start='0';

					while(1)
					{
						start = usb_cdc_getc();
						if(start=='1')
						{
							break;
						}
					}

	}
	/*while (1){

		if(usb_cdc_kbhit()){
			char c, buffer_out[15];
			c = usb_cdc_getc();
			switch(c){
				case '3':
					STM32F4_Discovery_LEDToggle(LED3);
					sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED3_PIN));
					usb_cdc_printf(buffer_out);
					break;
				case '4':
					STM32F4_Discovery_LEDToggle(LED4);
					sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED4_PIN));
					usb_cdc_printf(buffer_out);
					break;
				case '5':
					STM32F4_Discovery_LEDToggle(LED5);
					sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED5_PIN));
					usb_cdc_printf(buffer_out);
					break;
				case '6':
					STM32F4_Discovery_LEDToggle(LED6);
					sprintf(buffer_out,"LED%c = %u\r\n",c,GPIO_ReadInputDataBit(GPIOD,LED6_PIN));
					usb_cdc_printf(buffer_out);
					break;
			}
		}

		button_sts = STM32F4_Discovery_PBGetState(BUTTON_USER);

		if(button_sts){
			STM32F4_Discovery_LEDOff(LED3);
			STM32F4_Discovery_LEDOff(LED5);
			STM32F4_Discovery_LEDOff(LED3);
			STM32F4_Discovery_LEDOff(LED5);
		}
	}*/
}