int TWI_READBYTE(unsigned char address)
{
signed int data = 0x00;
TWI_Start();
TWI_Write(MPU6050_ADR);
TWI_Write(address);
TWI_Start();
TWI_Write(MPU6050_ADR | 0x01);
data = TWI_Read_NACK();
TWI_Stop();
return data;
}
unsigned char Read24C64_Byte(unsigned char devAddr, unsigned int regAddr) {
unsigned char val;
TWI_Start();
TWI_Write(0b10100000);//_WRITE_MODE(devAddr));
TWI_Write(regAddr>>8); // MSB Byte first
TWI_Write(regAddr); // LSB Byte afterward
TWI_Start(); // Repeated start
TWI_Write(0b10100001);//_READ_MODE(devAddr));
val = TWI_Read(0u);
TWI_Stop();
return val;
}
void PCA9634_Init()
{
// Enable internal oscillator.
TWI_Start();
TWI_Write(PCA9634_ADDRESS);
TWI_Write(PCA9634_REG_MODE1);
TWI_Write(0b00001);
TWI_Stop();
TWI_Start();
TWI_Write(PCA9634_ADDRESS);
TWI_Write(PCA9634_REG_LEDOUT0 | PCA9634_AI_ALL);
TWI_Write(0b10101010); // Enable PWM mode for PWM0 to PWM3.
TWI_Write(0b10101010); // Enable PWM mode for PWM4 to PWM7.
TWI_Stop();
}
unsigned char Write24C64_Byte(unsigned char devAddr, unsigned int regAddr, unsigned char value) {
TWI_Start();
TWI_Write(_WRITE_MODE(devAddr));
TWI_Write(regAddr>>8);
TWI_Write(regAddr);
TWI_Write(value);
TWI_Stop();
}
//--------------------------------------------------------------------------------------------------------------------
void TWI_wr(unsigned char Saddress,unsigned char SRegSet, unsigned char data)
{
TWI_Start();
TWI_SendSLAW(Saddress);
TWI_TransmitData(SRegSet);
TWI_TransmitData(data);
TWI_Stop();
}
/**
* @ Brief Starts illuminance measurement.
* @ Parameter mode: measurement mode.
* @ Retval None
*/
void BH1750_Start(uint8_t mode)
{
mode_ = mode;
TWI_Start();
TWI_Write_SLA(BH1750_SLA);
TWI_WriteByte(mode_);
TWI_Stop();
}
void TWI_WriteBytes(uint8_t SLA, uint8_t address ,uint8_t size, uint8_t* buffer)
{
TWI_Start();
TWI_Write_SLA(SLA);
TWI_WriteByte(address);
while (size--) TWI_WriteByte(*buffer++);
TWI_Stop();
}
void TWI_WRITEBYTE(unsigned char address, unsigned char data)
{
TWI_Start();
TWI_Write(MPU6050_ADR);
TWI_Write(address);
TWI_Write(data);
TWI_Stop();
}
/**
* @ Brief Switches the sensor to power down mode.
* @ Parameter None.
* @ Retval None
*/
void BH1750_PowerDown()
{
//BH1750_DVI_PORT &= ~(BH1750_Power_OFF << BH1750_DVI_PIN);
state_ = BH1750_Power_OFF;
TWI_Start();
TWI_Write_SLA(BH1750_SLA);
TWI_WriteByte(BH1750_Power_OFF);
TWI_Stop();
}
/**
* @ Brief Switches the sensor to power on mode.
* @ Parameter None.
* @ Retval None
*/
void BH1750_PowerOn()
{
_delay_us(5);
//BH1750_DVI_PORT |= BH1750_Power_ON << BH1750_DVI_PIN;
state_ = BH1750_Power_ON;
TWI_Start();
TWI_Write_SLA(BH1750_SLA);
TWI_WriteByte(BH1750_Power_ON);
TWI_Stop();
}
/**
* @ Brief Resets the BH1750 data register. After that, switches
* sensor to power down mode.
* @ Parameter None.
* @ Retval None.
*/
void BH1750_ResetDR()
{
if(state_ == BH1750_Power_OFF) BH1750_PowerOn();
TWI_Start();
TWI_Write_SLA(BH1750_SLA);
TWI_WriteByte(BH1750_RESET);
TWI_Stop();
BH1750_PowerDown();
}
/*
* Liest "1" Register
*/
char TWI_readRegister(uint8_t i2cAdr, uint8_t regAdr) {
uint8_t reply[3];
uint8_t n_Byte = 1;
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_WRITE) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Write");
uart_writeAbsatz();
}
if (TWI_Write_Func(regAdr) == 0) {
//Error
uart_writeString("TWI Error regAdr Write");
uart_writeAbsatz();
}
TWI_Stop();
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_READ) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Read");
uart_writeAbsatz();
}
if (TWI_Read(reply, n_Byte) == 0) {
//Error
uart_writeString("TWI Error Read Byte");
uart_writeAbsatz();
}
TWI_Stop();
return reply[0];
}
//--------------------------------------------------------------------------------------------------------------------
unsigned char TWI_rd(unsigned char Saddress,unsigned char SRegSet)
{
unsigned char data;
TWI_Start();
TWI_SendSLAW(Saddress);
TWI_TransmitData(SRegSet);
TWI_ReStart();
TWI_SendSLAR(Saddress);
data = TWI_ReceiveData();
TWI_SendNoAck();
TWI_Stop();
return data;
}
/*
* Liest "2" Register (aufeinander folgende Register e.g.: 0x01, 0x02)
*/
short TWI_readRegister2(uint8_t i2cAdr, uint8_t regAdr) {
uint8_t reply[4];
uint8_t n_Byte = 2;
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_WRITE) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Write");
uart_writeAbsatz();
}
if (TWI_Write_Func(regAdr) == 0) {
//Error
uart_writeString("TWI Error regAdr Write");
uart_writeAbsatz();
}
TWI_Stop();
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_READ) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Write");
uart_writeAbsatz();
}
if (TWI_Read(reply, n_Byte) == 0) {
//Error
uart_writeString("TWI Error Read Int");
uart_writeAbsatz();
}
TWI_Stop();
return (short) reply[0] << 8 | reply[1];
}
void PCF_Read(uint8_t addr, uint8_t *data, uint8_t count) {
TWI_Start();
TWI_Write(PCF8563_WRITE_ADDR);
TWI_Write(addr);
TWI_Stop();
TWI_Start();
TWI_Write(PCF8563_READ_ADDR);
while (count)
{
count--;
*data = TWI_Read(count);
data++;
}
TWI_Stop();
}
tStatus TWI_RegisterWrite(uint8_t u8addr, uint8_t u8data, uint8_t slaveAddress)
{
TWI_Start(); // send a start code to begin the write
uint8_t status = TWI_GetStatus();
if (status != START && status != REP_START) // start not sent/acknowledged
{
//Serial.print("TWI Write failed, start not sent.");
//Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write( (slaveAddress<<1) ); // write the address shifted so that last bit is 0, meaning write request
status = TWI_GetStatus();
if (status != MT_SLA_ACK) // SLA+W was not acknowledged
{
TWI_Stop(); // send a stop to end failed transmission
//Serial.print("TWI Write failed, sla address not sent.");
//Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write(u8addr); // send the address to write to
status = TWI_GetStatus();
if (status != MT_DATA_ACK) // the address was not sent
{
// Serial.print("TWI Write failed, register address not sent");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write(u8data); // send the data to write
status = TWI_GetStatus();
if (status != MT_DATA_ACK)
{
// Serial.print("TWI Write failed, data not sent");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Stop();
return SUCCESS;
}
void TWI_readRegisterN(uint8_t i2cAdr, uint8_t regAdr,uint8_t reply[], uint8_t n_Byte) {
// uint8_t n_Byte = 6;
// uint8_t reply[8];
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_WRITE) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Write");
uart_writeAbsatz();
}
if (TWI_Write_Func(regAdr) == 0) {
//Error
uart_writeString("TWI Error regAdr Write");
uart_writeAbsatz();
}
TWI_Stop();
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_READ) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Write");
uart_writeAbsatz();
}
if (TWI_Read(reply, n_Byte) == 0) {
//Error
uart_writeString("TWI Error Read Int");
uart_writeAbsatz();
}
TWI_Stop();
}
void PCF_Write(uint8_t addr, uint8_t *data, uint8_t count) {
TWI_Start();
TWI_Write(PCF8563_WRITE_ADDR);
TWI_Write(addr);
while (count) {
count--;
TWI_Write(*data);
data++;
}
TWI_Stop();
}
/* extra use */
char TWI_Write(char address, char *data, char n)
{
unsigned int SLA_W = (address<<1) & 0XFE;
char chk;
chk=TWI_Start();
if(chk==1)
return chk;
//---------------------------
TWDR = SLA_W;
TWCR = (1<<TWINT)|(1<<TWEN);
while (!(TWCR & (1<<TWINT)));
if (TWI_STATUS != TWI_MT_SLA_ACK)
{
TWI_ERROR();
return 3;
}
//---------------------------
for(char i=0;i<n;i++)
{
TWDR = *(data+i);
TWCR = (1<<TWINT)|(1<<TWEN);
while (!(TWCR & (1<<TWINT)));
if (TWI_STATUS != TWI_MT_DATA_ACK)
{
TWI_ERROR();
return 4;
}
}
if(n>1)
{
TWI_Stop();
}
else
write_to_read=1;
return 0;
}
void TWI_ReadBytes(uint8_t SLA, uint8_t address ,uint8_t size, uint8_t* buffer)
{
TWI_Start();
TWI_Write_SLA(SLA);
TWI_WriteByte(address);
TWI_RStart();
TWI_Write_SLA(SLA+1);
//while (size--) *buffer++ = size ? TWI_ReadByte_ACK() : ( len ? ACK : NACK );
while(size--)
{
*buffer++ = size ? TWI_ReadByte_ACK() : TWI_ReadByte_NACK();
}
/*
for (uint8_t i=0; i<size-1; i++) {
buffer[i] = TWI_ReadByte_ACK();
}
buffer[size-1]=TWI_ReadByte_NACK();
*/
}
/**
* @ Brief Reads measurement result (illuminance).
* @ Parameter None.
* @ Retval Illuminance in lux (lx) units. The highest resolution is 1lx.
*/
uint16_t BH1750_Read()
{
uint32_t result;
uint8_t msb, lsb;
uint16_t lux = 0;
TWI_Start();
TWI_Write_SLA(BH1750_SLA + 1);
msb = TWI_ReadByte_ACK();
lsb = TWI_ReadByte_NACK();
TWI_Stop();
result = ((msb << 8) | lsb) * 10; //Lux = Register / 1,2 == reg*10 / 12
lux = (uint16_t)(result / 12);
if(((mode_ == BH1750_CHR_MODE2) || (mode_ == BH1750_OTHR_MODE2)) && ((result % 12 ) >= 6))
{
lux++;
}
return lux;
}
/*
* High Level
* *************************************************************
*/
void TWI_writeRegister(uint8_t i2cAdr, uint8_t regAdr, uint8_t val) {
if (TWI_Start() == 0) {
//Error
uart_writeString("TWI Error Start");
uart_writeAbsatz();
}
if (TWI_Write_Addr(i2cAdr, TW_WRITE) == 0) {
//Error
uart_writeString("TWI Error i2cAdr Write");
uart_writeAbsatz();
}
if (TWI_Write_Func(regAdr) == 0) {
//Error
uart_writeString("TWI Error regAdr Write");
uart_writeAbsatz();
}
if (TWI_Write_Func(val) == 0) {
//Error
uart_writeString("TWI Error val Write");
uart_writeAbsatz();
}
TWI_Stop();
}
tStatus TWI_RegisterRead(uint8_t u8addr, uint8_t* u8data, uint8_t slaveAddress)
{
TWI_Start(); // send a start code to begin the write
uint8_t status = TWI_GetStatus();
if (status != START && status != REP_START) // start not sent/acknowledged
{
// Serial.print("TWI Read failed. Start not sent");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write( (slaveAddress<<1) ); // write the address shifted so that last bit is 0, meaning write request
status = TWI_GetStatus();
if (status != MT_SLA_ACK) // SLA+W was not acknowledged
{
// Serial.print("TWI Read failed. address not sent");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write(u8addr); // send the address to read from
status = TWI_GetStatus();
if (status != MT_DATA_ACK) // the address was not sent
{
// Serial.print("TWI Read failed. address of register not sent");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Start(); // send a repeated start
status = TWI_GetStatus();
if (status != REP_START) // start not sent
{
// Serial.print("TWI Read failed. Repeated Start not sent");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write( ( (slaveAddress<<1) | 1) ); // write the address shifted so that last bit is 1, meaning read request
status = TWI_GetStatus();
if (status != MR_SLA_ACK) // SLA+R was not acknowledged
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
*u8data = TWI_ReadNACK(); // read the data
status = TWI_GetStatus();
if (status != MR_DATA_NACK)
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Stop();
return SUCCESS;
}
uint8_t print_sequence(const uint8_t *buf, uint8_t i2c_addr)
{
uint8_t value;
uint8_t size;
uint8_t addr_msb = SEQ_END;
uint8_t addr_lsb;
uint8_t stat;
size = 2;
//printf(PSTR("INIT SIZE: %u\n"), init_size);
while(1)
{
addr_msb = pgm_read_byte(buf++); //read address or command, then set buf to point to the data
if(debug_output) printf("%02X ",addr_msb);
if(addr_msb == SEQ_SIZE) {
size = pgm_read_byte(buf++); //read the size from buf, then set buf to next register address or command
if(debug_output) printf_P(PSTR("SEQ_SIZE %u\n"), size);
continue;
}
else if(addr_msb == SEQ_END) {
break;
}
else if(addr_msb == SEQ_DELAY) {
//value = pgm_read_byte(buf++);
_delay_ms(100);
if(debug_output) printf_P(PSTR("SEQ_DELAY\n"));
continue;
}
else if(addr_msb == SEQ_RESET) {
if(debug_output) printf_P(PSTR("SEQ_RESET\n"), value);
//Eval SharpLCD Reset Pin
PORTB |= RESET_PIN; //Set High
DDRB |= RESET_PIN; //Set Output
//Drude SharpLCD Reset Pin
PORTB |= RESETN_PIN; //Set High
DDRB |= RESETN_PIN; //Set Output
_delay_us(10); //Wait 10 microseconds
PORTB &= ~(RESETN_PIN); //Drude Reset Pin Set Low
PORTB &= ~(RESET_PIN); //Eval Reset Pin Set Low
_delay_us(10); //Wait 10 microseconds
PORTB |= RESET_PIN; //Eval Reset Pin Set High
PORTB |= RESETN_PIN; //Drude Toshina Reset Pin Set High
_delay_ms(10);
//DDRB &= ~(RESET_PIN); //Set Input
continue;
}
else if(addr_msb == SEQ_READ) {
value = pgm_read_byte(buf++);
addr_lsb = pgm_read_byte(buf++);
if(debug_output) printf_P(PSTR("SEQ_READ %02X %02X\n"), value,addr_lsb);
continue;
};
TWI_Start(); // First start condition
stat = TWI_GetStatus();
if (stat != 0x08) { if(debug_output) printf_P(PSTR("\nTWI_Start()\n")); return stat; }
TWI_Write((i2c_addr<<1)); // Chip address + write
stat = TWI_GetStatus();
if (stat != 0x18) { if(debug_output) printf_P(PSTR("\nTWI_Write(HDMICONV_ADDR)\n")); return stat; }
/*
if( ! i2c_start(HDMICONV_ADDR) ) {
printf_P(PSTR("i2c_start failed.\n"));
} */
TWI_Write(addr_msb); // Address high byte
stat = TWI_GetStatus();
if (stat != 0x28) { if(debug_output) printf_P(PSTR("\nTWI_Write(addr_msb)\n")); return stat; }
for(uint8_t i=0; i<=size && i<10 ; i++)
{
value = pgm_read_byte(buf++);
if(debug_output) printf("%02X ",value);
TWI_Write(value);
stat = TWI_GetStatus();
if (stat != 0x28) return stat;
}
TWI_Stop(); // Send stop condition
_delay_us(5);
if(debug_output) printf("\n");
}
}
char TWI_Read(char address, char *data, char n)
{
unsigned int SLA_R = (address<<1) | 0X01;
char chk;
if(write_to_read==1)
{
chk=TWI_ReStart();
if(chk==2)
return chk;
write_to_read=0;
}
else
chk=TWI_Start();
if(chk==1)
return chk;
//---------------------------
TWDR = SLA_R;
TWCR = (1<<TWINT)|(1<<TWEN);
while (!(TWCR & (1<<TWINT)));
if (TWI_STATUS != TWI_MR_SLA_ACK)
{
TWI_ERROR();
return 5;
}
//---------------------------
if(n>1)
{
for(char i=0;i<(n-1);i++)
{
TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
while (!(TWCR & (1<<TWINT)));
if (TWI_STATUS != TWI_MR_DATA_ACK)
{
TWI_ERROR();
return 6;
}
*(data+i) = TWDR;
}
TWCR = (1<<TWINT)|(1<<TWEN);
while (!(TWCR & (1<<TWINT)));
if (TWI_STATUS != TWI_MR_DATA_NACK)
{
TWI_ERROR();
return 7;
}
*(data+(n-1)) = TWDR; //burst read �� data�̫��@���O�SACK��
}
else
{
TWCR = (1<<TWINT)|(1<<TWEN);
while (!(TWCR & (1<<TWINT)));
if (TWI_STATUS != TWI_MR_DATA_NACK) {
TWI_ERROR();
return 8;
}
*(data) = TWDR; //data�̫��@���O�SACK��
}
TWI_Stop();
return 0;
}
tStatus TWI_RegisterRead_Multiple(uint8_t u8addr, uint8_t* u8data, uint8_t numBytes, uint8_t slaveAddress)
{
TWI_Start(); // send a start code to begin the write
uint8_t status = TWI_GetStatus();
if (status != START && status != REP_START) // start not sent/acknowledged
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write( (slaveAddress<<1) ); // write the address shifted so that last bit is 0, meaning write request
status = TWI_GetStatus();
if (status != MT_SLA_ACK) // SLA+W was not acknowledged
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write(u8addr); // send the address to read from
status = TWI_GetStatus();
if (status != MT_DATA_ACK) // the address was not sent
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Start(); // send a repeated start
status = TWI_GetStatus();
if (status != REP_START) // start not sent
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Write( ( (slaveAddress<<1) | 1) ); // write the address shifted so that last bit is 1, meaning read request
status = TWI_GetStatus();
if (status != MR_SLA_ACK) // SLA+R was not acknowledged
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
for (int i=0; i<numBytes-1; i++)
{
u8data[i] = TWI_ReadACK(); // read the data
status = TWI_GetStatus();
if (status != MR_DATA_ACK)
{
// Serial.print("TWI Read failed. Byte #"); Serial.print(i);
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
}
u8data[numBytes-1] = TWI_ReadNACK(); // read the last byte, and respond with a NACK to let the slave know its the last one
status = TWI_GetStatus();
if (status != MR_DATA_NACK)
{
// Serial.print("TWI Read failed");
// Serial.print(" Status code is: 0x"); Serial.println(status,HEX);
return ERROR;
}
TWI_Stop();
return SUCCESS;
}
