int main(int argc, char **argv)
{
unsigned char buf[6];
unsigned char i,reg;
double temp=0,calc=0, skytemp,atemp;
FILE *flog;
flog=fopen("mlxlog.csv", "a");
bcm2835_init();
bcm2835_i2c_begin();
bcm2835_i2c_set_baudrate(25000);
// set address...........................................................................................
bcm2835_i2c_setSlaveAddress(0x5a);
printf("\nOk, your device is working!!\n");
while(1) {
time_t t = time(NULL);
struct tm tm = *localtime(&t);
calc=0;
reg=7;
for(i=0;i<AVG;i++){
bcm2835_i2c_begin();
bcm2835_i2c_write (®, 1);
bcm2835_i2c_read_register_rs(®,&buf[0],3);
temp = (double) (((buf[1]) << 8) + buf[0]);
temp = (temp * 0.02)-0.01;
temp = temp - 273.15;
calc+=temp;
sleep(1);
}
skytemp=calc/AVG;
calc=0;
reg=6;
for(i=0;i<AVG;i++){
bcm2835_i2c_begin();
bcm2835_i2c_write (®, 1);
bcm2835_i2c_read_register_rs(®,&buf[0],3);
temp = (double) (((buf[1]) << 8) + buf[0]);
temp = (temp * 0.02)-0.01;
temp = temp - 273.15;
calc+=temp;
sleep(1);
}
atemp=calc/AVG;
printf("%02d-%02d %02d:%02d:%02d\n Tambi=%04.2f C, Tobj=%04.2f C\n", tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec,atemp,skytemp);
fprintf(flog,"%04d-%02d-%02d %02d:%02d:%02d,%04.2f,%04.02f\n",tm.tm_year+1900, tm.tm_mon +1, tm.tm_mday,tm.tm_hour, tm.tm_min, tm.tm_sec,atemp,skytemp);
fflush(flog);
sleep(LOGTIME-(2*AVG));
}
printf("[done]\n");
}
/**
*@brief Initializes the I2C peripheral
*@param reg Address of sensor register, address autoincrements
*@param *buffer Pointer to byte data buffer array
*@param length length of buffer array
*@return none
*/
void I2C_ReadByteArray(unsigned char address,char reg,char *buffer,unsigned int length)
{
bcm2835_i2c_setSlaveAddress(address);
bcm2835_i2c_read_register_rs(®,buffer,length);
}
/**
*@brief Reads a byte from a register
*@param reg Address of sensor register.
*@return val Byte value of register.
*/
unsigned char I2C_ReadByteRegister(char reg)
{
char val = 0;
bcm2835_i2c_read_register_rs(®,&val,1);
return val;
}
char read_acc(char _addr)
{
//read data from the address register
char addr = _addr;
char buf = 0x00;
bcm2835_i2c_read_register_rs(&addr, &buf, 1);
return buf;
}
uint8_t MAG3110_READ_REGISTER(char reg)
{
char *buf = malloc(sizeof(char));
bcm2835_i2c_setSlaveAddress(MAG3110_I2C_ADDRESS);
bcm2835_i2c_read_register_rs(®, buf, 1);
return *buf;
}
// Read bytesToRead sequentially, starting at addressToRead into the dest byte array
void readRegisters(char addressToRead, int bytesToRead, char* dest)
{
//Set Address to read
bcm2835_i2c_write(&addressToRead, 1);
//Get reading
bcm2835_i2c_read_register_rs(&addressToRead,dest,bytesToRead);
}
/**
*@brief Reads a byte from a register
*@param reg Address of sensor register.
*@return val Byte value of register.
*/
unsigned char I2C_ReadByteRegister(unsigned char address, char reg)
{
bcm2835_i2c_setSlaveAddress(address);
char val = 0;
bcm2835_i2c_read_register_rs(®,&val,1);
return val;
}
int PCA9685::getPWM(uint8_t led) {
int ledval = 0;
bcm2835_i2c_set_baudrate(400000);
bcm2835_i2c_setSlaveAddress(addr);
char regH = LED0_OFF_H + LED_MULTIPLYER * (led-1);
char regL = LED0_OFF_L + LED_MULTIPLYER * (led-1);
bcm2835_i2c_read_register_rs(®H,&pca_recvBuf[0],1);
//std::cout << (int)pca_recvBuf[0] << std::endl;
//ledval = i2c->read_byte(LED0_OFF_H + LED_MULTIPLYER * (led-1));
ledval = pca_recvBuf[0] & 0xf;
ledval <<= 8;
bcm2835_i2c_read_register_rs(®L,&pca_recvBuf[0],1);
//std::cout << (int)pca_recvBuf[0] << std::endl;
//ledval += i2c->read_byte(LED0_OFF_L + LED_MULTIPLYER * (led-1));
ledval += pca_recvBuf[0];
return ledval;
}
// Sets the MMA8452 to active mode. Needs to be in this mode to output data
void MMA8452Active()
{
char buf[2];
bcm2835_i2c_read_register_rs(&CTRL_REG1,buf,2);
writeRegister(CTRL_REG1, 0x01); //Set the active bit to begin detection
char buff[2];
bcm2835_i2c_read_register_rs(&CTRL_REG1,buff,2);
if (*buff == 1) // WHO_AM_I should always be 0x2A
{
printf("MMA8452Q is Active \n");
}
else
{
printf("MMA8452Q is Inactive \n");
while(1) ; // Loop forever if communication doesn't happen
}
}
static PyObject *
PyBCM2835_i2c_read_register_rs(PyObject *self, PyObject *args)
{
char *tbuf;
char *rbuf;
int tbuf_len;
int rbuf_len;
uint32_t len;
if (!PyArg_ParseTuple(args,"s#s#i",&tbuf, &tbuf_len, &rbuf, &rbuf_len,&len)) {
return NULL;
}
uint8_t rtn = bcm2835_i2c_read_register_rs(tbuf, rbuf, len);
return Py_BuildValue("i",rtn);
}
//uint8_t bcm2835_i2c_read_register_rs(char* regaddr, char* buf, uint32_t len);
/// Call bcm2835_i2c_read_register_rs with 3 parameter
/// \par Refer
/// \par Modify
void ope_i2c_read_register_rs(void)
{
uint8_t ret;
char* buf;
uint32_t len;
get_byte_code();
get_int_code();
get_int_code();
buf = *(char **)(buff+2);
len = *(uint32_t *)(buff+6);
ret = bcm2835_i2c_read_register_rs( (char *)(buff+1), bi_rec_buff, len );
set_ope_code( OPE_I2C_READ_REGISTER_RS );
set_byte_code( ret );
set_int_code( (int)buf );
set_int_code( len );
put_reply();
}
uint8_t I2C_Bus::read_register_rs(char reg, char *buf, const uint32_t len) const
{
return bcm2835_i2c_read_register_rs(®, buf, len);
}
/**
*@brief Initializes the I2C peripheral
*@param reg Address of sensor register, address autoincrements
*@param data Pointer to byte data buffer array
*@param length length of buffer array
*@return none
*/
void I2C_ReadByteArray(char reg,char *buffer,unsigned int length)
{
bcm2835_i2c_read_register_rs(®,buffer,length);
}
int MAG3110_BULK_READ(char reg, char count, char* data) {
bcm2835_i2c_setSlaveAddress(14);
bcm2835_i2c_read_register_rs(®, data, count);
return *data;
}
char MAG3110_READ_REGISTER(char reg) {
char* ch = malloc(1);
bcm2835_i2c_setSlaveAddress(14);
bcm2835_i2c_read_register_rs(®, ch, 1);
return ch[0];
}
// Initialize the MMA8452 registers
// See the many application notes for more info on setting all of these registers:
// http://www.freescale.com/webapp/sps/site/prod_summary.jsp?code=MMA8452Q
void initMMA8452()
{
char buf[1];
bcm2835_i2c_read_register_rs(&WHO_AM_I,buf,1);
if (*buf == CTRL_REG1) // WHO_AM_I should always be 0x2A
{
printf("MMA8452Q is online...\n");
}
else
{
printf("WHOAMI not as expected: %X\n",*buf);
while(1) ; // Loop forever if communication doesn't happen
}
MMA8452Standby(); // Must be in standby to change registers
// Set up the full scale range to 2, 4, or 8g.
char fsr = GSCALE;
if(fsr > 8) fsr = 8; //Easy error check
fsr >>= 2; // Neat trick, see page 22. 00 = 2G, 01 = 4A, 10 = 8G
writeRegister(XYZ_DATA_CFG, fsr);
// Setup the 3 data rate bits, from 0 to 7
writeRegister(0x2A, readRegister(0x2A) & ~(0x38));
if (dataRate <= 7)
writeRegister(0x2A, readRegister(0x2A) | (dataRate << 3));
// Set up portrait/landscap registers - 4 steps:
// 1. Enable P/L
// 2. Set the back/front angle trigger points (z-lock)
// 3. Set the threshold/hysteresis angle
// 4. Set the debouce rate
// For more info check out this app note: http://cache.freescale.com/files/sensors/doc/app_note/AN4068.pdf
writeRegister(0x11, 0x40); // 1. Enable P/L
writeRegister(0x13, 0x44); // 2. 29deg z-lock (don't think this register is actually writable)
writeRegister(0x14, 0x84); // 3. 45deg thresh, 14deg hyst (don't think this register is writable either)
writeRegister(0x12, 0x50); // 4. debounce counter at 100ms (at 800 hz)
/* Set up single and double tap - 5 steps:
1. Set up single and/or double tap detection on each axis individually.
2. Set the threshold - minimum required acceleration to cause a tap.
3. Set the time limit - the maximum time that a tap can be above the threshold
4. Set the pulse latency - the minimum required time between one pulse and the next
5. Set the second pulse window - maximum allowed time between end of latency and start of second pulse
for more info check out this app note: http://cache.freescale.com/files/sensors/doc/app_note/AN4072.pdf */
writeRegister(0x21, 0x7F); // 1. enable single/double taps on all axes
// writeRegister(0x21, 0x55); // 1. single taps only on all axes
// writeRegister(0x21, 0x6A); // 1. double taps only on all axes
writeRegister(0x23, 0x20); // 2. x thresh at 2g, multiply the value by 0.0625g/LSB to get the threshold
writeRegister(0x24, 0x20); // 2. y thresh at 2g, multiply the value by 0.0625g/LSB to get the threshold
writeRegister(0x25, 0x08); // 2. z thresh at .5g, multiply the value by 0.0625g/LSB to get the threshold
writeRegister(0x26, 0x30); // 3. 30ms time limit at 800Hz odr, this is very dependent on data rate, see the app note
writeRegister(0x27, 0xA0); // 4. 200ms (at 800Hz odr) between taps min, this also depends on the data rate
writeRegister(0x28, 0xFF); // 5. 318ms (max value) between taps max
// Set up interrupt 1 and 2
writeRegister(0x2C, 0x02); // Active high, push-pull interrupts
writeRegister(0x2D, 0x19); // DRDY, P/L and tap ints enabled
writeRegister(0x2E, 0x01); // DRDY on INT1, P/L and taps on INT2
//The default data rate is 800Hz and we don't modify it in this example code
MMA8452Active(); // Set to active to start reading
}
uint8_t MAG3110_BULK_READ(char startReg, char length, char *buf)
{
bcm2835_i2c_setSlaveAddress(MAG3110_I2C_ADDRESS);
bcm2835_i2c_read_register_rs(&startReg, buf, length);
return *buf;
}
// Sets the MMA8452 to standby mode. It must be in standby to change most register settings
void MMA8452Standby()
{
char buf[2];
bcm2835_i2c_read_register_rs(&CTRL_REG1,buf,2);
writeRegister(CTRL_REG1, *buf ^ 0x01); //Clear the active bit to go into standby
}
