uint8_t cy8c20180_read(uint8_t address) {
// request data like described in the datasheet page 9 - one byte of data
// BUG: data only reads from chip #0 when both chips are sampled, and turns
// up in the space for chip #1 - maybe it takes too long?
uint8_t ret = 0x00;
// request Register 00h: INPUT_PORT0
i2c_start_wait(address);
i2c_write(INPUT_PORT0);
i2c_stop();
i2c_start_wait(address);
ret = i2c_readNak() << 4;
i2c_stop();
// if (address == 0) { ret |= 1 << 4; }
// request Register 01h: INPUT_PORT1
i2c_start_wait(address);
i2c_write(INPUT_PORT1);
i2c_stop();
i2c_start_wait(address);
ret |= i2c_readNak();
i2c_stop();
return ret;
}
void _rtc_get_date_dev(Date* tm, uint8_t year_offset, uint8_t addr)
{
uint8_t c;
i2c_start_wait(addr+RTC_DEV_WRITE_ADDRESS); // set device address and write mode
i2c_write(0x02); // write memory address = 0x02
i2c_rep_start(addr+RTC_DEV_READ_ADDRESS); // set device address and read mode
c = i2c_readAck(); // 0x02
tm->seconds = rtc_bcd_to_binary(c);
c = i2c_readAck(); // 0x03
tm->minutes = rtc_bcd_to_binary(c);
// Throw away AMPM information
i2c_readAck(); // 0x04
c = i2c_readAck(); // 0x05
tm->day = rtc_bcd_to_binary(c & 0x3F);
tm->year = ((rtc_bcd_to_binary(c) >> 6) & 0x3) + 1970 + year_offset;
c = i2c_readNak(); // 0x06: don't acknowledge the last byte
// Throw away day of week information
//tm->dayOfWeek = ((c >> 5) & 0x7);
tm->month = (c & 0x1F);
i2c_stop(); // stop i2c bus
}
// Free returned memory!
uint8_t *memGetBytes(uint32_t address, uint8_t length) {
// We could use the High-Speed Mode of the FM24V10 here, but we don't, right now...
uint8_t addA, addB, memAddress = MEMTWIADDRESS, i, *ret;
if (address >= 65536) {
// Address needs more than 16 bits, we have to set the PAGE bit in i2c address
memAddress |= 2;
}
addA = (address & 0xFF00) >> 8;
addB = address & 0xFF;
ret = (uint8_t *)malloc(length); // Allocate memory for values read
if (ret == NULL) {
serialWriteString(getString(24));
return NULL;
}
if (i2c_start(memAddress | I2C_WRITE) == 0) {
i2c_write(addA);
i2c_write(addB);
i2c_rep_start(memAddress | I2C_READ);
for (i = 0; i < (length - 1); i++) {
ret[i] = i2c_readAck();
}
ret[length - 1] = i2c_readNak();
i2c_stop();
return ret;
} else {
return NULL;
}
}
static matrix_row_t read_cols(uint8_t mcp23018_status, uint8_t row)
{
if (row < 7) {
if (mcp23018_status) { // if there was an error
return 0;
} else {
uint8_t data = 0;
uint8_t err = 0x20;
err = i2c_start(I2C_ADDR_WRITE); if (err) goto out;
err = i2c_write(GPIOB); if (err) goto out;
err = i2c_start(I2C_ADDR_READ); if (err) goto out;
data = i2c_readNak();
data = ~data;
out:
i2c_stop();
return data;
}
} else {
// read from teensy
return
(PINF&(1<<0) ? 0 : (1<<0)) |
(PINF&(1<<1) ? 0 : (1<<1)) |
(PINF&(1<<4) ? 0 : (1<<2)) |
(PINF&(1<<5) ? 0 : (1<<3)) |
(PINF&(1<<6) ? 0 : (1<<4)) |
(PINF&(1<<7) ? 0 : (1<<5)) ;
}
}
// Lese MD49 Daten (Encodervalues, Mode, Acceleration, etc..)
// von Slave_Drivecontrol und speichere sie in Array MD49data
void readMD49data(void){
uint8_t i;
// Daten von I2C- Slave lesen im Master-Receiver-Mode
if(!(i2c_start(SLAVE_ADRESSE+I2C_WRITE))) // Slave bereit zum lesen?
{
i2c_write(15); // Buffer Startadresse zum Auslesen
i2c_rep_start(SLAVE_ADRESSE+I2C_READ); // Lesen beginnen
for (i=0;i<18;i++) // Empfangene Daten in Array schreiben
{
if ((i) < 17)
{
MD49data[i]=i2c_readAck(); // Bytes lesen...
}
else
{
MD49data[i]=i2c_readNak(); // letztes Byte lesen...
}
}
i2c_stop(); // Zugriff beenden
}
else
{
// /* Fehlerbehandlung... */
}
}
uint8_t getIR(void)
{
uint16_t tempdata = 0;
uint8_t returnvar = 0;
for(uint8_t i = 0; i < NUMBER_OF_MLX; i++)
{
if((i2c_start(pgm_read_byte(&mlx90614_i2c_addresses[i])) == 0) &&
(i2c_write(I2C_REG_MLX90614) == 0) &&
(i2c_rep_start(pgm_read_byte(&mlx90614_i2c_addresses[i]) + I2C_READ) == 0))
{
for(uint8_t i = 0; i<2; i++)
i2cbuf[i] = i2c_readAck();
i2cbuf[2] = i2c_readNak();
if(i2c_stop() != 0)
returnvar |= (1<<i);
else
returnvar &= ~(1<<i);
// This masks off the error bit of the high byte, then moves it left 8 bits and adds the low byte.
tempdata = (((i2cbuf[1] & 0x007F) << 8) + i2cbuf[0]);
tempdata = ((tempdata * 2)-1);
mlx90614[i].is = (tempdata - 27315);
}
else returnvar |= (1<<i);
}
return returnvar;
}
int main (void)
{
uint16_t heading;
int16_t pitch, roll;
uint16_t headingIntegerPart, headingFractionPart;
int16_t pitchIntegerPart, pitchFractionPart;
int16_t rollIntegerPart, rollFractionPart;
// initialize the hardware stuff we use
InitTimer ();
InitUART ();
i2c_init ();
fdevopen (UART0_PutCharStdio, UART0_GetCharStdio);
// set the LED port for output
LED_DDR |= LED_MASK;
printf ("\nHoneywell HMC6343 I2C Compass Test\n\n");
// Flash the LED for 1/2 a second...
turnOnLED ();
ms_spin (500);
turnOffLED ();
while (1) // outer loop is once every 250 ms (more or less)
{
// send the HEADING command to the compass
i2c_start_wait (COMPASS_ADDRESS_WRITE);
i2c_write (COMPASS_HEADING_COMMAND);
// now read the response
i2c_rep_start (COMPASS_ADDRESS_READ);
heading = (i2c_readAck () * 256) + i2c_readAck ();
pitch = (i2c_readAck () * 256) + i2c_readAck ();
roll = (i2c_readAck () * 256) + i2c_readNak ();
i2c_stop ();
headingIntegerPart = heading / 10;
headingFractionPart = heading - (headingIntegerPart * 10);
pitchIntegerPart = pitch / 10;
pitchFractionPart = pitch - (pitchIntegerPart * 10);
if (pitchFractionPart < 0)
pitchFractionPart *= -1;
rollIntegerPart = roll / 10;
rollFractionPart = roll - (rollIntegerPart * 10);
if (rollFractionPart < 0)
rollFractionPart *= -1;
printf ("Heading: %3d.%1d Pitch: %3d.%1d Roll: %3d.%1d\n", headingIntegerPart, headingFractionPart, pitchIntegerPart, pitchFractionPart, rollIntegerPart, rollFractionPart);
turnOnLED ();
ms_spin (100);
turnOffLED ();
ms_spin (150);
}
// we'll never get here...
return 0;
}
//Read 8bit data from register with 8bit address
void Gyroscope::cmr_read(byte address) {
i2c_start_wait( (ADDR << 1) | I2C_WRITE ); // Start / Device address and Write (0)
i2c_write(address); // 8bit register address
i2c_rep_start( (ADDR << 1) | I2C_READ ); // Repeated Start / Device address and Read (1)
res = i2c_readNak(); // Read the result to res
i2c_stop(); // End condition
}
uint8_t Clicker_readOverflow(uint8_t *p) {
int ret;
ret = i2c_start((clicker_address<<1) + I2C_WRITE);
if (ret == 1) {
i2c_stop();
return ret;
}
i2c_write(0x42);
i2c_stop();
i2c_start((clicker_address<<1) + I2C_READ);
if (ret == 1) {
i2c_stop();
return ret;
}
*p = i2c_readNak();
i2c_stop();
return 0;
}
static matrix_row_t read_cols(uint8_t row)
{
if (row < 9) {
if (mcp23018_status) { // if there was an error
return 0;
} else {
uint8_t data = 0;
mcp23018_status = i2c_start(I2C_ADDR_WRITE); if (mcp23018_status) goto out;
mcp23018_status = i2c_write(GPIOB); if (mcp23018_status) goto out;
mcp23018_status = i2c_start(I2C_ADDR_READ); if (mcp23018_status) goto out;
data = i2c_readNak();
data = ~data;
out:
i2c_stop();
return data;
}
} else {
_delay_us(30); // without this wait read unstable value.
// read from teensy
return
(PINF&(1<<0) ? 0 : (1<<0)) |
(PINF&(1<<1) ? 0 : (1<<1)) |
(PINF&(1<<4) ? 0 : (1<<2)) |
(PINF&(1<<5) ? 0 : (1<<3)) |
(PINF&(1<<6) ? 0 : (1<<4)) |
(PINF&(1<<7) ? 0 : (1<<5)) ;
}
}
/*
get temperature (16 bit) from thermometer and stores in array
input: none
output: none
*/
void therm_getTemp16bit(void)
{
// send read temperature command
if(i2c_start(THERM_ADDR+I2C_WRITE))
{
// start condition failed
i2c_stop();
error(1);
}
else
{
// start condition ok, device accessible
i2c_write(THERM_READ_TEMP);
}
//send repeated start to begin reading temperature
if(i2c_rep_start(THERM_ADDR+I2C_READ))
{
// start condition failed
i2c_stop();
error(1);
}
else
{
// start condition ok, device accessible
// read MSB
temp_reading[TEMP_MSB] = i2c_readAck();
// read LSB
temp_reading[TEMP_LSB] = i2c_readNak();
i2c_stop();
}
}
void classic_maj_data(CLASSIC * classic) {
u8 i;
u8 data[6];
//reset le pointeur de lecture
i2c_start(0xa4);//adresse classic en écriture
i2c_write(0);
i2c_stop();
_delay_us(200);//minimum observé fonctionnel : _delay_us(150);
i2c_start_wait(0xa5);//adresse en lecture
for(i=0; i<5; i++) {
data[i]=i2c_readAck();
}
data[5]=i2c_readNak();//le dernier caractère lu ne doit pas avoir d'acknowledge
i2c_stop();
/*for(i=0;i<6;i++){
phex(data[i]);
print(" ");
}*/
classic->bouton1=~data[4];
classic->bouton2=~data[5];
classic->rx=(data[2]>>7)+(data[1]>>(6-1))+(data[0]>>(6-3));
classic->ry=data[2]&0x1f;
classic->lx=data[0]&0x3f;
classic->ly=data[1]&0x3f;
classic->lt=(data[3]>>5)+((data[2]&0x60)>>(5-3));
classic->rt=data[1]&0x3f;
}
uint8_t ds3231_get_time(struct DS3231_Time *p)
{
uint8_t ack = 0;
ack |= i2c_start(DS3231_ADDRESS | I2C_WRITE);
ack |= i2c_write(DS3231_SECONDS);
ack |= i2c_rep_start(DS3231_ADDRESS | I2C_READ);
if (ack != 0)
{
i2c_stop();
return ack;
}
p->seconds_bcd = i2c_readAck();
p->minutes_bcd = i2c_readAck();
p->hours_bcd = i2c_readAck();
p->day_of_week = i2c_readAck();
p->day_of_month_bcd = i2c_readAck();
p->month_bcd = i2c_readAck();
p->year_bcd = i2c_readNak() + DS3231_YEAR_ZERO;
i2c_stop();
if ((p->month_bcd & DS3231_CENTURY) != 0)
{
p->year_bcd |= 0x0100;
p->month_bcd &= ~DS3231_CENTURY;
}
p->ampm = 0;
if ((p->hours_bcd & DS3231_12_24) != 0)
{
p->ampm = ((p->hours_bcd & DS3231_AM_PM) >> 5) + 1;
p->hours_bcd &= 0x1F;
}
unsigned char getTemp() {
i2c_init();
i2c_start_wait(TC74Address + I2C_WRITE);
i2c_write(0x00);
i2c_rep_start(TC74Address + I2C_READ);
char temp = i2c_readNak();
i2c_stop();
return temp;
}
uint8_t I2C_ReadRegister(uint8_t busAddr, uint8_t deviceRegister) {
uint8_t data = 0;
i2c_start_wait(busAddr+I2C_WRITE);
i2c_write(deviceRegister);
i2c_start_wait(busAddr+I2C_READ);
data = i2c_readNak();
i2c_stop();
return data;
}
uint8_t adxl345_read(uint8_t register_name) {
uint8_t ret;
i2c_start(ADXL345_ADDR + I2C_WRITE);
i2c_write(register_name);
i2c_rep_start(ADXL345_ADDR + I2C_READ);
ret = i2c_readNak();
i2c_stop();
return ret;
}
uint8_t rtc_read(unsigned char addr) {
uint8_t ret;
i2c_start_wait(DevRTC); // set device address and write mode
i2c_write(addr); // write address = 0
i2c_rep_start(DevRTC+1); // set device address and read mode
ret = i2c_readNak(); // read one byte form address 0
i2c_stop(); // set stop condition = release bus
return ret;
}
void IR_MESSUNG(void)
{
uint8_t Anzahl=0;
uint16_t Durchschnitt=0;
INTERRUPTS_OFF
i2c_start(0x10 + I2C_WRITE);
i2c_write(0x49);
i2c_stop();
i2c_start(0x10 + I2C_READ);
IR_DIRECTION = i2c_readAck();
IR_S1 = i2c_readAck();
IR_S2 = i2c_readAck();
IR_S3 = i2c_readAck();
IR_S4 = i2c_readAck();
IR_S5 = i2c_readNak();
i2c_stop();
INTERRUPTS_ON
if(IR_S1>10)
{
Anzahl++;
Durchschnitt=Durchschnitt+IR_S1;
}
if(IR_S2>10)
{
Anzahl++;
Durchschnitt=Durchschnitt+IR_S2;
}
if(IR_S3>10)
{
Anzahl++;
Durchschnitt=Durchschnitt+IR_S3;
}
if(IR_S4>10)
{
Anzahl++;
Durchschnitt=Durchschnitt+IR_S4;
}
if(IR_S5>10)
{
Anzahl++;
Durchschnitt=Durchschnitt+IR_S5;
}
BALL_ENTFERNUNG=Durchschnitt/Anzahl;
}
int16_t MPU6050_signed_readreg(uint8_t accel, uint8_t reg)//read signed 16 bits
{
i2c_start_wait(accel+I2C_WRITE); // set device address and write mode
i2c_write(reg); // ACCEL_OUT
i2c_rep_start(accel+I2C_READ); // set device address and read mode
char raw1 = i2c_readAck(); // read one intermediate byte
int16_t raw2 = (raw1<<8) | i2c_readNak(); // read last byte
i2c_stop();
return raw2;
}
int main () {
uint8_t reg0_value;
i2c_init();
i2c_start(0xE0);
i2c_write(0x00);
i2c_rep_start(0xE0);
reg0_value = i2c_readNak();
i2c_stop();
return 0;
}
uint8_t
lis302_read_register(uint8_t register_address)
{
uint8_t result = -1;
i2c_start_wait(I2C_7BIT_WRITE(LIS302_I2C_ADDRESS));
i2c_write(register_address);
i2c_rep_start(I2C_7BIT_READ(LIS302_I2C_ADDRESS));
result = i2c_readNak();
i2c_stop();
return result;
}
/*=================================================================================
Reads the GY-26 digital compass and returns the degrees value in integer format.
Example:
unsigned int degrees;
degrees = pthRead();
The value in 'degrees' variable could be from 0 to 3650.
If the 'degrees' variable has the value 2568 that means 256.8 degrees.
=================================================================================*/
int pthRead (void)
{
unsigned int data;
i2c_start(I2C_GY26 + I2C_READ); // Set device address and read mode
data = (i2c_readAck() << 8); // Read the Most Significant Byte (MSB) from the GY-26 compass.
data += i2c_readNak(); // Read the Low Significant Byte (LSB) from the GY-26 compass.
i2c_stop();
return (data); //Return the degrees value (16-bit integer from 0-3650).
}
int twi_read_byte(uint8_t addr, uint8_t reg, uint8_t* target){
i2c_start_wait(addr << 1);
if(i2c_write(reg)){
return 1;
}
if(i2c_rep_start((addr << 1) + 1)){
return 1;
}
*target = i2c_readNak();
i2c_stop();
return 0;
}
void ADXL345_clearInt(void)
{
uint8_t dummy;
/* Read the interupt source and do nothing with it (clears bit)*/
//i2c_start(ADXL345+I2C_WRITE); // Set device address and write mode
i2c_start_wait(ADXL345+I2C_WRITE); // Set device address and write mode
i2c_write(INT_SOURCE); // Reading here
i2c_rep_start(ADXL345+I2C_READ); // Set device address and read mode
dummy = i2c_readNak();
i2c_stop();
}
uint8_t ADXL345_devID(void)
{
uint8_t deviceID;
/* Read back the device ID */
//i2c_start(ADXL345+I2C_WRITE); // Set device address and write mode
i2c_start_wait(ADXL345+I2C_WRITE); // Set device address and write mode
i2c_write(ADXL345_IDREG); // Reading here
i2c_rep_start(ADXL345+I2C_READ); // Set device address and read mode
deviceID = i2c_readNak();
i2c_stop();
return deviceID;
}
// i2c read
void VZ89::readmem(uint8_t reg, uint8_t buff[], uint8_t bytes) {
uint8_t i =0;
i2c_start_wait(VZ89_ADDR | I2C_WRITE);
i2c_write(reg);
i2c_rep_start(VZ89_ADDR | I2C_READ);
for(i=0; i<bytes; i++) {
if(i==bytes-1)
buff[i] = i2c_readNak();
else
buff[i] = i2c_readAck();
}
i2c_stop();
}
/*******************************************************************************
* Function: nunchuck_get_data()
* Description: Fills the nunchuck_buf array with data from the nunchuck's
* registers. The data from this array may be accessed using the get functions
******************************************************************************/
void nunchuck_get_data(void)
{
i2c_start_wait(NUNCHUCK_ADDR+I2C_WRITE);
i2c_write(0x00);
i2c_stop();
_delay_ms(10);
i2c_start_wait(NUNCHUCK_ADDR+I2C_READ);
for (uint8_t i = 0 ; i < 5 ; i++)
{
nunchuck_buf[i] = nunchuck_decode_byte(i2c_readAck());
}
nunchuck_buf[5] = nunchuck_decode_byte(i2c_readNak());
i2c_stop();
}
int16_t lm75_gettemp(uint8_t device){
device = LM75_BASE + (device << 1);
if(i2c_start(device + 1)){
return 100;
}else{
int16_t a = i2c_readAck() << 1;
uint8_t b = i2c_readNak() >> 7;
i2c_stop();
if(a & 256)
a |= 0xfe00;
return a+b;
//return 50*2+1;
}
}
void twi_transfer(struct twi_transfer *xfer)
{
#ifdef TWI_SYNC
twi_size_t i;
uint8_t *buffer = xfer->buffer;
if (xfer->write_size) {
i2c_start(xfer->address << 1);
for (i = 0; i < xfer->write_size; i++)
i2c_write(buffer[i]);
if (!xfer->read_size)
i2c_stop();
}
if (xfer->read_size) {
i2c_start((xfer->address << 1) | 1);
for (i = 0; i < xfer->read_size; i++) {
if (i + 1 == xfer->read_size)
buffer[i] = i2c_readNak();
else
buffer[i] = i2c_readAck();
}
i2c_stop();
}
if (xfer->callback)
xfer->callback(xfer, TWI_STAT_FINISHED);
#else /* TWI_SYNC */
uint8_t sreg;
xfer->offset = 0;
xfer->next = NULL;
xfer->status = 0;
if (!xfer->write_size)
xfer->status |= TWI_XFER_READ;
transfer_set_status(xfer, TWI_STAT_INPROGRESS);
sreg = irq_disable_save();
if (twi.last_xfer)
twi.last_xfer->next = xfer;
twi.last_xfer = xfer;
if (!twi.first_xfer) {
twi.first_xfer = xfer;
send_start_condition();
}
irq_restore(sreg);
#endif
}
/// I2C read from camera
unsigned char cameraRead(unsigned char regNum)
{
unsigned char write;
unsigned char read;
///Check these if they start to cause trouble
write = i2c_start(CAMADDR+I2C_WRITE);
write = i2c_write(regNum);
i2c_stop();
read = i2c_start(CAMADDR+I2C_READ); ;
read = i2c_readNak();
i2c_stop();
return read;
}
