static int hmc5883HWInit(int devFD) { int ret = 0; if (I2CWriteByte(devFD, WriteAddress, 6) == -1) { ret = -1; } if (I2CWriteByteTo(devFD, 0x00, 0x70, 6) == -1) { ret = -1; } if (I2CWriteByte(devFD, WriteAddress, 6) == -1) { ret = -1; } // continued reading mode if (I2CWriteByteTo(devFD, 0x02, 0x00, 6) == -1) { ret = -1; } // read command to check the mode if (I2CWriteByte(devFD, ReadAddress, 6) == -1) { ret = -1; } // printf("A=%d\n",I2CReadByteFrom(devFD, 0x00, 6)); // printf("B=%d\n",I2CReadByteFrom(devFD, 0x02, 6)); usleep(1000*100); return ret; }
/****************************************************************************\ //****************************************************************************\ * Function: Gainmanual * * Detailed Description: * Sets Gain control to serial interface control. * \****************************************************************************/ int Gainmanual(TUNER_MODULE *pTuner) { unsigned char writearray[5]; int status; writearray[0]=0; status=I2CWriteByte(pTuner, 200,26,writearray[0]); //printf("\nRegister 1a=%d", writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 0; status=I2CWriteByte (pTuner, 200,9,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 0; status=I2CWriteByte (pTuner, 200,5,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } return E4000_1_SUCCESS; }
void tda731xSetSpeakers(void) { int8_t spFrontLeft = 0; int8_t spFrontRight = 0; int8_t spRearLeft = 0; int8_t spRearRight = 0; if (sndPar[MODE_SND_BALANCE].value > 0) { spFrontLeft -= sndPar[MODE_SND_BALANCE].value; spRearLeft -= sndPar[MODE_SND_BALANCE].value; } else { spFrontRight += sndPar[MODE_SND_BALANCE].value; spRearRight += sndPar[MODE_SND_BALANCE].value; } if (sndPar[MODE_SND_FRONTREAR].value > 0) { spRearLeft -= sndPar[MODE_SND_FRONTREAR].value; spRearRight -= sndPar[MODE_SND_FRONTREAR].value; } else { spFrontLeft += sndPar[MODE_SND_FRONTREAR].value; spFrontRight += sndPar[MODE_SND_FRONTREAR].value; } I2CStart(TDA731X_I2C_ADDR); I2CWriteByte(TDA731X_SP_REAR_LEFT | -spRearLeft); I2CWriteByte(TDA731X_SP_REAR_RIGHT | -spRearRight); I2CWriteByte(TDA731X_SP_FRONT_LEFT | -spFrontLeft); I2CWriteByte(TDA731X_SP_FRONT_RIGHT | -spFrontRight); I2CStop(); return; }
static void ks0066WriteStrob() { I2CWriteByte(i2cData | PCF8574_E_LINE); I2CWriteByte(i2cData); return; }
uint8_t DS1307Write(uint8_t address,uint8_t data) { uint8_t res; //result //Start I2CStart(); //SLA+W res=I2CWriteByte(0b11010000); //DS1307 address + W //Error if(!res) return FALSE; //Now send the address of required register res=I2CWriteByte(address); //Error if(!res) return FALSE; //Now write the value res=I2CWriteByte(data); //Error if(!res) return FALSE; //STOP I2CStop(); return TRUE; }
void tea63x0SetInputMute(void) { I2CStart(TEA63X0_I2C_ADDR); I2CWriteByte(TEA63X0_AUDIO_SW); I2CWriteByte((aproc.mute ? TEA63X0_GMU : 0) | (1 << aproc.input)); I2CStop(); return; }
void tea63x0SetBT() { I2CStart(TEA63X0_I2C_ADDR); I2CWriteByte(TEA63X0_BASS); I2CWriteByte(sndPar[MODE_SND_BASS].value + 7); // -4..5 grid => 3..12 raw I2CWriteByte(sndPar[MODE_SND_TREBLE].value + 7); // -4..4 grid => 3..11 raw I2CStop(); return; }
uint8_t AT24_format(void) { /* * Declare a pointer for 1-byte write over i2c bus. * It will point to an address of our structure and * we will shift it to one byte until we reach the * endpoint of our structure. */ uint8_t *p; uint8_t counter = 0; uint8_t at24_waddress = 0; uint16_t at24_paddress = 0; /* * If any error during write - we will return error * number, otherwise - 0. */ uint8_t ret = ESUCCESS; memset(&eepd, 0, EEPROM_MU_WR_SIZE); eepd.counter = 1; eepd.last_sync = 2; eepd.next_sync = 3; eepd.next_page = 4; // Set AT24C32 i2c address and raise write flag at24_waddress = (at24_addr | TW_WRITE); for (uint8_t i = 0; i < EEPROM_PAGE_CNT; i++) { p = (uint8_t *)&eepd; // We set start addres if (p != NULL) { // Start transmission. Connect to the device ret = I2CStart(at24_waddress); if (ret > 0) return ret; ret = I2CWriteByte(at24_paddress >> 8); if (ret > 0) return EEEPADDRMSB; ret = I2CWriteByte(at24_paddress & 0xFF); if (ret > 0) return EEEPADDRLSB; for (uint8_t k = 0; k < sizeof(eepd); k++) { ret = I2CWriteByte(*p); if (ret > 0) return ret; p++; } // Stop transmission I2CStop(); at24_paddress += EEPROM_MU_ADDR_STEP; } else return ENULLPOINTER;
static int pulseEnable(int devFD, unsigned char data) { clearLastError(); if (I2CWriteByte(devFD, (data | En), 0) == -1) { return -1; } usleep(1); if (I2CWriteByte(devFD, (data & ~En), 0) == -1) { return -1; } return 0; }
static void writeAlarm(void) { uint8_t i; I2CStart(DS1307_ADDR); I2CWriteByte(DS1307_A0_HOUR); for (i = DS1307_A0_HOUR; i <= DS1307_A0_WDAY; i++) I2CWriteByte(alarm[i - DS1307_A0_HOUR]); I2CStop(); return; }
void tda731xSetBT(void) { int8_t val; I2CStart(TDA731X_I2C_ADDR); val = sndPar[MODE_SND_BASS].value; I2CWriteByte(TDA731X_BASS | (val > 0 ? 15 - val : 7 + val)); val = sndPar[MODE_SND_TREBLE].value; I2CWriteByte(TDA731X_TREBLE | (val > 0 ? 15 - val : 7 + val)); I2CStop(); return; }
/****************************************************************************\ * Function: freqband * * Detailed Description: * Configures the E4000 frequency band. (Registers 0x07, 0x78). * \****************************************************************************/ int freqband(TUNER_MODULE *pTuner, int Freq) { unsigned char writearray[5]; int status; if (Freq<=140000) { writearray[0] = 3; status=I2CWriteByte(pTuner, 200,120,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } } else if (Freq<=350000) { writearray[0] = 3; status=I2CWriteByte(pTuner, 200,120,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } } else if (Freq<=1000000) { writearray[0] = 3; status=I2CWriteByte(pTuner, 200,120,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } } else { writearray[0] = 7; status=I2CWriteByte(pTuner, 200,7,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 0; status=I2CWriteByte(pTuner, 200,120,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } } return E4000_1_SUCCESS; }
void tda731xSetMute(void) { I2CStart(TDA731X_I2C_ADDR); if (aproc.mute) { I2CWriteByte(TDA731X_SP_REAR_LEFT | TDA731X_MUTE); I2CWriteByte(TDA731X_SP_REAR_RIGHT | TDA731X_MUTE); I2CWriteByte(TDA731X_SP_FRONT_LEFT | TDA731X_MUTE); I2CWriteByte(TDA731X_SP_FRONT_RIGHT | TDA731X_MUTE); } else { tda731xSetSpeakers(); } I2CStop(); return; }
/****************************************************************************\ * Function: DCoffloop * * Detailed Description: * Populates DC offset LUT. (Registers 0x2d, 0x70, 0x71). * Turns on DC offset LUT and time varying DC offset. \****************************************************************************/ int DCoffloop(TUNER_MODULE *pTuner) { unsigned char writearray[5]; int status; //writearray[0]=0; //I2CWriteByte(pTuner, 200,115,writearray[0]); //printf("\nRegister 73=%d", writearray[0]); writearray[0] = 31; status=I2CWriteByte(pTuner, 200,45,writearray[0]); //printf("\nRegister 2d=%d", writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 1; writearray[1] = 1; status=I2CWriteArray(pTuner, 200,112,2,writearray); //printf("\nRegister 70=%d", writearray[0]); //printf("\nRegister 71=%d", writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } return E4000_1_SUCCESS; }
EXPORT double hmc5883Read(int devFD) { int x,x1,x2,y,y1,y2,z,z1,z2; double angle; I2CWriteByte(devFD, ReadAddress, 6); // read command x1 = I2CReadByteFrom(devFD, 0x03, 6); x2 = I2CReadByteFrom(devFD, 0x04, 6); x = x1 << 8 | x2; // Combine MSB and LSB of X Data output register z1 = I2CReadByteFrom(devFD, 0x05, 6); z2 = I2CReadByteFrom(devFD, 0x06, 6); z = z1 << 8 | z2; // Combine MSB and LSB of Z Data output register y1 = I2CReadByteFrom(devFD, 0x07, 6); y2 = I2CReadByteFrom(devFD, 0x08, 6); y = y1 << 8 | y2; // Combine MSB and LSB of Y Data output register if (x > 32768) x = -(0xFFFF - x + 1); if (z > 32768) z = -(0xFFFF - z + 1); if (y>32768) y = -(0xFFFF - y + 1); // printf("x=%d,y=%d,z=%d\n",x,y,z); angle = atan2((double)y,(double)x) * (180 / PI) + 180; // angle in degrees if(angle >=0 && angle <=360) { return angle; } else { return -1; } }
void tda731xSetInput(void) { I2CStart(TDA731X_I2C_ADDR); I2CWriteByte(TDA731X_SW | (3 - sndPar[MODE_SND_GAIN0 + aproc.input].value) << 3 | !(aproc.extra & APROC_EXTRA_LOUDNESS) << 2 | aproc.input); I2CStop(); return; }
void tda731xSetVolume(void) { I2CStart(TDA731X_I2C_ADDR); I2CWriteByte(TDA731X_VOLUME | -sndPar[MODE_SND_VOLUME].value); I2CStop(); return; }
void tea63x0SetSpeakers() { int8_t spFR = sndPar[MODE_SND_FRONTREAR].value; // Front channels I2CStart(TEA63X0_I2C_ADDR); I2CWriteByte(TEA63X0_FADER); I2CWriteByte(TEA63X0_MFN | TEA63X0_FCH | (spFR < 0 ? 15 + spFR : 15)); I2CStop(); // Rear channels I2CStart(TEA63X0_I2C_ADDR); I2CWriteByte(TEA63X0_FADER); I2CWriteByte(TEA63X0_MFN | (spFR < 0 ? 15 : 15 - spFR)); I2CStop(); return; }
void I2CWriteBits(uint8_t devAddr, uint8_t regAddr, uint8_t bitStart, uint8_t length, uint8_t value) { uint8_t b; uint8_t mask = ((1 << length) - 1) << (bitStart - length + 1); I2CReadByte(devAddr, regAddr, &b); value <<= (bitStart - length + 1); value &= mask; b &= ~(mask); b |= value; I2CWriteByte(devAddr, regAddr, b); }
/** @brief I2CWriteBytes: Write one Byte to the PCA9685 * @param data:The frist byte must be the address of the 'CHIP', then the data to the chip. * @param len : data size */ void I2CWriteBytes(uint8_t *data, uint8_t len){ uint8_t i = 0; I2CStart(); for (; i < len; ++i){ I2CWriteByte(*data++); } I2CStop(); delay(3); }
// 写四位数据 EXPORT int pcf8574WriteData4(int devFD, unsigned char data) { clearLastError(); if (I2CWriteByte(devFD, (data | RS | BL), 0) == -1) { return -1; } if (pulseEnable(devFD, (data | RS | BL)) == -1) { return -1; } return 0; }
static int write_regs(unsigned char* pdevdata, unsigned long datalen) { int i = 0; while (i < datalen) { I2CWriteByte(I2C_ADV7179, pdevdata[i], pdevdata[i + 1]); i += 2; } return 0; }
int Qpeak(TUNER_MODULE *pTuner) { unsigned char writearray[5]; int status; writearray[0] = 1; writearray[1] = 254; status=I2CWriteArray(pTuner, 200,126,2,writearray); //printf("\nRegister 7e=%d", writearray[0]); //printf("\nRegister 7f=%d", writearray[1]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } status=I2CWriteByte (pTuner, 200,130,0); //printf("\nRegister 82=0"); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } status=I2CWriteByte (pTuner, 200,36,5); //printf("\nRegister 24=5"); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 32; writearray[1] = 1; status=I2CWriteArray(pTuner, 200,135,2,writearray); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } //printf("\nRegister 87=%d", writearray[0]); //printf("\nRegister 88=%d", writearray[1]); return E4000_1_SUCCESS; }
// 写四位指令 EXPORT int pcf8574WriteCmd4(int devFD, unsigned char command) { clearLastError(); if (I2CWriteByte(devFD, command | BL, 0) == -1) { return -1; } if (pulseEnable(devFD, command | BL) == -1) { setLastError("Fail to pulseEnable"); return -1; } return 0; }
int tunerreset(TUNER_MODULE *pTuner) { unsigned char writearray[5]; int status; writearray[0] = 64; // For dummy I2C command, don't check executing status. status=I2CWriteByte (pTuner, 200,2,writearray[0]); status=I2CWriteByte (pTuner, 200,2,writearray[0]); //printf("\nRegister 0=%d", writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 0; status=I2CWriteByte (pTuner, 200,9,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 0; status=I2CWriteByte (pTuner, 200,5,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } writearray[0] = 7; status=I2CWriteByte (pTuner, 200,0,writearray[0]); //printf("\nRegister 0=%d", writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } return E4000_1_SUCCESS; }
uint8_t DS1307Read(uint8_t address,uint8_t *data) { uint8_t res; //result //Start I2CStart(); //SLA+W (for dummy write to set register pointer) res=I2CWriteByte(0b11010000); //DS1307 address + W //Error if(!res) return FALSE; //Now send the address of required register res=I2CWriteByte(address); //Error if(!res) return FALSE; //Repeat Start I2CStart(); //SLA + R res=I2CWriteByte(0b11010001); //DS1307 Address + R //Error if(!res) return FALSE; //Now read the value with NACK res=I2CReadByte(data,0); //Error if(!res) return FALSE; //STOP I2CStop(); return TRUE; }
/****************************************************************************\ * Function: GainControlinit * * Detailed Description: * Configures gain control mode. (Registers 0x1a) * \****************************************************************************/ int GainControlauto(TUNER_MODULE *pTuner) { unsigned char writearray[5]; int status; writearray[0] = 23; status=I2CWriteByte(pTuner, 200,26,writearray[0]); if(status != E4000_I2C_SUCCESS) { return E4000_1_FAIL; } return E4000_1_SUCCESS; }
boolean_t writeToCompass( boolean_t sendStart, boolean_t sendStop, Byte data ) { Byte numberOfFailedAttempts = 0; while ( I2CWriteByte( sendStart, sendStop, data ) == 0 ) { numberOfFailedAttempts++; if ( numberOfFailedAttempts == MaxNumberOfFailedAttempts ) { TurnOnErrorLight(); return False; } } return True; }
static int adv7179_device_init(void) { unsigned char regvalue1, regvalue2; regvalue1 = I2CReadByte(I2C_ADV7179, 0x07); I2CWriteByte(I2C_ADV7179, 0x07, 0xa5); regvalue2 = I2CReadByte(I2C_ADV7179, 0x07); if (regvalue2 != 0xa5) { printk("read adv7179 register is %x\n", regvalue2); printk("check adv7179 error.\n"); return -EFAULT; } I2CWriteByte(I2C_ADV7179, 0x07, regvalue1); if (norm_mode == VIDEO_NORM_NTSC) { if (init_vda(VIDEO_MODE_CCIR656, VIDEO_NORM_NTSC, VIDEO_MODE_MASTER) == 0) { return 0; } else { return -EFAULT; } } else { if (init_vda(VIDEO_MODE_CCIR656, VIDEO_NORM_PAL, VIDEO_MODE_MASTER) == 0) { return 0; } else { return -EFAULT; } } }
void tea63x0SetVolume() { int8_t spLeft = sndPar[MODE_SND_VOLUME].value; int8_t spRight = sndPar[MODE_SND_VOLUME].value; int8_t volMin = pgm_read_byte(&sndPar[MODE_SND_VOLUME].grid->min); if (sndPar[MODE_SND_BALANCE].value > 0) { spLeft -= sndPar[MODE_SND_BALANCE].value; if (spLeft < volMin) spLeft = volMin; } else { spRight += sndPar[MODE_SND_BALANCE].value; if (spRight < volMin) spRight = volMin; } I2CStart(TEA63X0_I2C_ADDR); I2CWriteByte(TEA63X0_VOLUME_LEFT); I2CWriteByte(spRight + 53); // -66dB..20dB => -33..10 grid => 20..53 raw I2CWriteByte(spLeft + 53); I2CStop(); return; }