int CI2C::InitI2C () {
////Log_file->WriteTopic ("Init I2C bus", 1);
m_bError = false;
m_nCompassAdress = wiringPiI2CSetup (0x60); //initialisation of the cmps10
if (m_nCompassAdress == -1) {
g_pTracer->Trace (ERROR, "Failed to initialise the compass!");
m_bError = true;
}
m_nLidarAdress = wiringPiI2CSetup (0x62); //initialisation of the LiDAR
if (m_nLidarAdress == -1) {
g_pTracer->Trace (ERROR, "Failed to initialise the LiDAR!");
m_bError = true;
}else{
I2CWrite (m_nLidarAdress, 0, 0); //set LiDAR acquisition count (128 = default)
}
if (m_bError == false) {
g_pTracer->Trace (NOTE, "I2C bus initialised.");
return 1;
}else{
return -1;
}
}
SHT3x::SHT3x(const uint8_t& i2cAddr) {
_fd = wiringPiI2CSetup(i2cAddr);
_header = i2cAddr << 1;
if (_fd < 0) {
throw std::runtime_error("Unable to connect");
}
}
int main(void) {
unsigned int nextTime;
short flip;
if (wiringPiSetup () == -1)
{
fprintf (stdout, "Unable to start wiringPi: %s\n", strerror (errno)) ;
fflush(stdout);
return 1;
}
i2c = wiringPiI2CSetup (0x39);
if (i2c == -1)
{
fprintf (stdout, "Unable to start I2C wiringPi: %s\n", strerror (errno)) ;
fflush(stdout);
return 1;
}
wiringPiI2CWriteReg8(i2c, 0x80, 0x03);
nextTime = millis() + TIME_DELAY+400;
int x = 0;
for (;x<500;x++){
//startReading();
flip = !flip;
flipper(flip);
while (millis() < nextTime) {
}
readSensor();
nextTime+=TIME_DELAY;
}
}
int main()
{
wiringPiSetup();
int fd = wiringPiI2CSetup(HTU21D_I2C_ADDR);
if ( 0 > fd )
{
fprintf(stderr, "ERROR: Unable to access RabbitMax humidity sensor: %s\n", strerror (errno));
exit (-1);
}
// Retrieve temperature and humidity
double temperature = 0;
double humidity = 0;
if ( (0 > getHumidity(fd, &humidity)) || (0 > getTemperature(fd, &temperature)) )
{
fprintf(stderr, "ERROR: RabbitMax humidity sensor not found\n");
exit(-1);
}
// Print temperature and humidity on the screen
printf("RabbitMax Humidity and Temperature Sensor\n");
printf("%5.2fC\n", temperature);
printf("%5.2f%%rh\n", humidity);
return 0;
}
static int get_fd(duda_request_t *dr)
{
int devid;
char *devid_str;
devid_str = qs->get(dr, "address");
if (devid_str == NULL) {
return -1;
}
// convert hex or decimal
if (strncmp(devid_str, "0x", 2) == 0) {
devid = strtol(devid_str + 2, NULL, 16);
} else {
devid = atoi(devid_str);
}
// check range
if (devid < 3 || devid > NI2C) {
return -1;
}
// init if not yet
if (i2cfd[devid] == -1) {
i2cfd[devid] = wiringPiI2CSetup(devid);
}
return i2cfd[devid];
}
void main() {
char *df = "/dev/input/js0";
struct ps3ctls ps3dat;
wiringPiSetup();
softPwmCreate( 5,0,20); // start-0 10ms
softPwmCreate( 6,0,20); // start-0 10ms
softPwmCreate(26,0,20); // start-0 10ms
softPwmCreate(27,0,20); // start-0 10ms
softPwmCreate(28,0,20); // start-0 10ms
softPwmCreate(29,0,20); // start-0 10ms
softPwmCreate(14,0,20); // start-0 10ms
softPwmCreate(23,0,20); // start-0 10ms
softPwmCreate(24,0,20); // start-0 10ms
softPwmCreate(25,0,20); // start-0 10ms
pinMode(15,OUTPUT);
digitalWrite(15,0);
fds = wiringPiI2CSetup(0x40); // PCA9685
resetPCA9685(fds);
setPCA9685Freq(fds,50);
while(1) {
if(!(ps3c_init(&ps3dat, df))) {
do {
if (ps3c_test(&ps3dat) < 0) break;
} while (!(ps3c_input(&ps3dat)));
ps3c_exit(&ps3dat);
};
};
}
void initMagneto(void){
int i;
printf("Magnetometer Initializing..........\n");
if(first_boot){
pinMode(MAG_LED, OUTPUT);
if( (mag.fd = wiringPiI2CSetup(HMC5883L_I2C)) < 0 )
printf ("I2C connection failed: %s\n", strerror(errno));
if( (wiringPiI2CWriteReg8(mag.fd, HMC5883L_REG_A, HIGH_FREQ8)) < 0 )
printf("Write to HMC5883L_REG_A failed: %s/n", strerror(errno));
if( (wiringPiI2CWriteReg8(mag.fd, HMC5883L_REG_B, SENSOR_GAIN)) < 0 )
printf("Write to HMC5883L_REG_B failed: %s/n", strerror(errno));
if( (wiringPiI2CWriteReg8(mag.fd, HMC5883L_MODE_REG, CONTINUOUS)) < 0)
printf ("Write to HMC5883L_MODE_REG failed: %s/n", strerror(errno));
first_boot=0;
}
mag_starting_up = 1;
mag.reading = 0;
mag.average = 0;
mag.deviation = 0;
mag.magnitude = 0;
mag.oldest_sample = 0;
for(i = 0 ; i < MAX_SAMPLES ; i++){
readMagneto();
}
updateMagneto();
printf("Magnetometer Initialized...........\n");
mag_starting_up = 0;
}
int htu21dSetup (const int pinBase)
{
int fd ;
struct wiringPiNodeStruct *node ;
uint8_t data ;
int status ;
if ((fd = wiringPiI2CSetup (I2C_ADDRESS)) < 0)
return FALSE ;
node = wiringPiNewNode (pinBase, 2) ;
node->fd = fd ;
node->analogRead = myAnalogRead ;
// Send a reset code to it:
data = 0xFE ;
if (write (fd, &data, 1) != 1)
return FALSE ;
delay (15) ;
// Read the status register to check it's really there
status = wiringPiI2CReadReg8 (fd, 0xE7) ;
return (status == 0x02) ? TRUE : FALSE ;
}
int main(int argc, char **argv)
{
int devieAddress = 0x55;
int fd = wiringPiI2CSetup(devieAddress);
if (fd == -1)
{
printf("I2C Bus file could not be opened\n");
}
else
{
printf("I2C Bus opened on FD: %d\n", fd);
while (1)
{
unsigned char byte[2];
int res = read(fd, byte, 2);
if (res == -1)
{
printf("I2C Device with address %d was not available\n", devieAddress);
}
else
{
int distanceInCM = (byte[0] << 8) | byte[1];
printf("Distance: %dcm\n", distanceInCM);
}
delay(250);
}
}
return 0;
}
void main(int argc,char* argv[])
{
int fd,i2cAddress,j,k;
if(argc<2)
{
printf("No address entered\n");
return;
}
i2cAddress=atoi(argv[1]);
if((fd = wiringPiI2CSetup(i2cAddress))<0)
{
printf("could not connect to slave address\n");
return;
}
printf("setup done\n");
while(1)
{
for(j=0;j<16;j++)
{
printf("Sending %d\t",j);
wiringPiI2CWriteReg8(fd,0,j);
k=wiringPiI2CReadReg8(fd,2);
printf("data read %d\n",k);
delay(1000);
}
}
}
bool I2C_Interface::attach_fd(uint8_t i2c_address) {
if ((0 <= i2c_address) & (i2c_address < 128)) {
//Lock mutex for address acquire
pthread_mutex_lock(&aMutex);
//Grab fd from wiringPi
fd[i2c_address] = wiringPiI2CSetup(i2c_address);
//Unlock mutex for address acquire
pthread_mutex_unlock(&aMutex);
if (fd[i2c_address] == -1) {
if (MLogger::is_error_enabled()) {
printf("Couldn't get device %u fd.\n", i2c_address);
}
return true;
} else {
if (MLogger::is_info_enabled()) {
printf("Got device %u fd.\n", i2c_address);
}
return false;
}
}
else {
if (MLogger::is_error_enabled()) {
printf("Address %u is out of I2C range.\n", i2c_address);
}
return false;
}
}
void HDC1000::Init()
{
// デバイスアドレス
// i2cdetect -y 1 で調べられる
DevAddr=0x40;
// 温度取得ポインタとConfigポインタのアドレス指定。
// 基本的にこのままでOK。今回は温度と湿度を同時取得するので
// 温度側だけでOK
tempp=0x00;
confp=0x02;
// デバイスの設定
// 2バイトの設定データを1バイトに分けて設定。
// 1＝上位ビット側 2＝下位ビット側
// 0x1234という設定データなら 1＝0x12 2＝0x34と設定
devconf1=0x10;
devconf2=0x00;
unsigned char ConfData[3];
ConfData[0]= confp;
ConfData[1]= devconf1;
ConfData[2]= devconf2;
fd=wiringPiI2CSetup(DevAddr);
/*
wiringPiSetupGpio();
pinMode(RDPin,INPUT);
*/
if(write(fd,ConfData,sizeof(ConfData))<0)
{
std::cerr <<"センサー設定エラー"<<std::endl;
}
// return fd;
}
/**
* Initialize an I2C channel to the specified address. Exits with an error
* message if the initialization fails,
*
* @param addr The target address.
* @return File Descriptor for the I2C channel
*/
int I2C_setup_fd(const int addr) {
const int fd = wiringPiI2CSetup(addr);
if (!fd) {
syslog(LOG_EMERG, "Error %d on I2C initialization!", errno);
exit(-1);
}
return fd;
}
int main(int argc, char** argv) {
fd = wiringPiI2CSetup(I2C_ADDRESS);
init();
init();
set_backlight(true);
print("Please wait...",0);
printf("Done\n");
}
void main(){
fd = wiringPiI2CSetup(LCDAddr);
init();
write(0, 0, "Greetings!");
write(1, 1, "From SunFounder");
delay(2000);
clear();
}
int main(){
int fd = wiringPiI2CSetup(0x68);
int secs = wiringPiI2CReadReg8(fd, 0x00);
int mins = wiringPiI2CReadReg8(fd, 0x01);
int hours = wiringPiI2CReadReg8(fd, 0x02);
printf("The RTC time is %2d:%02d:%02d\n", hours, mins, secs);
return 0;
}
int changeEncoderAddress(int fd, int newAddress)
{
wiringPiI2CWriteReg8(fd, 0x4D, (2*newAddress));
int newFd = wiringPiI2CSetup(newAddress);
wiringPiI2CWrite(newFd, 0x4B);
usleep(100000);
wiringPiI2CWrite(newFd, 0x4A);
usleep(100000);
return newFd;
}
//Initialise la communication I2C avec l'appareil en AddrId
int I2C_Init(int AddrId)
{
int fd;
if( fd = wiringPiI2CSetup(0x12) )
printf("I2C communication initialisé avec succés.\n");
else
fprintf(stderr,"I2C Init Error. Errno is: ",strerror(errno));
return fd; //Linux file handler, used by other function.
}
// Initialize wiring I2C interface to LidarLite
int lidarLite::lidar_init(bool dbg) {
int fd;
m_dbg=dbg;
if (m_dbg) printf("LidarLite V0.1\n\n");
fd = wiringPiI2CSetup(m_addr);
if (fd != -1) {
lidar_status(fd); // Dummy request to wake up device
usleep (100000);
}
return(fd);
}
void main()
{
int GYRO_X, GYRO_Y, GYRO_Z, ACCEL_X, ACCEL_Y, ACCEL_Z;
double G_RE_X, G_RE_Y, G_RE_Z, A_RE_X, A_RE_Y, A_RE_Z, ACCX, ACCY, ACCZ, GYROX, GYROY, GYROZ, XANGLE, YANGLE, ZANGLE;
int sensor;
sensor = wiringPiI2CSetup(ADDRESS);
wiringPiI2CWriteReg8(sensor, 0x6B, 0);
wiringPiI2CWriteReg8(sensor, 27, 0x00);
while(1) {
GYRO_X = wiringPiI2CReadReg8(sensor, 0x43);
GYRO_X = GYRO_X << 8 | wiringPiI2CReadReg8(sensor, 0x44); // GYRO X
G_RE_X = GYRO_Change(GYRO_X);
GYRO_Y = wiringPiI2CReadReg8(sensor, 0x45);
GYRO_Y = GYRO_Y << 8 | wiringPiI2CReadReg8(sensor, 0x46); // GYRO Y
G_RE_Y = GYRO_Change(GYRO_Y);
GYRO_Z = wiringPiI2CReadReg8(sensor, 0x47);
GYRO_Z = GYRO_Z << 8 | wiringPiI2CReadReg8(sensor, 0x48); // GYRO Z
G_RE_Z = GYRO_Change(GYRO_Z);
ACCEL_X = wiringPiI2CReadReg8(sensor, 0x3B);
ACCEL_X = ACCEL_X << 8 | wiringPiI2CReadReg8(sensor, 0x3C); // ACC X
A_RE_X = ACCEL_Change(ACCEL_X);
ACCEL_Y = wiringPiI2CReadReg8(sensor, 0x3D);
ACCEL_Y = ACCEL_Y << 8 | wiringPiI2CReadReg8(sensor, 0x3E); // ACC Y
A_RE_Y = ACCEL_Change(ACCEL_Y);
ACCEL_Z = wiringPiI2CReadReg8(sensor, 0x3F);
ACCEL_Z = ACCEL_Z << 8 | wiringPiI2CReadReg8(sensor, 0x40); // ACC Z
A_RE_Z = ACCEL_Change(ACCEL_Z);
ACCY = atan2(A_RE_Z, A_RE_X) * 180 / PI;
ACCX = atan2(A_RE_Z, A_RE_Y) * 180 / PI;
ACCZ = atan2(A_RE_Y, A_RE_X) * 180 / PI;
GYROX = (double)G_RE_X / 131.0;
GYROY = (double)G_RE_Y / 131.0;
GYROZ = (double)G_RE_Z / 131.0;
XANGLE = (0.93 * (XANGLE + (GYROX * DT)) + (0.07 * ACCX));
YANGLE = (0.93 * (YANGLE + (GYROY * DT)) + (0.07 * ACCY));
ZANGLE = (0.93 * (ZANGLE + (GYROZ * DT)) + (0.07 * ACCZ)); //NOT CORRECT
printf("XANGLE : %10lf\t YANGLE : %10lf\tZANGLE : %10lf\n", XANGLE, YANGLE, ZANGLE);
delay(5);
}
}
int motorDrive(int motorNo, enum DriveMode driveSet,float vSetF){
int fd,ret;
unsigned char setValue[3];
unsigned char vSet,drive,motorHex;
if(motorNo==0){
motorHex=DRV8830_0;
}else if(motorNo==1){
motorHex=DRV8830_1;
}else{
motorHex=DRV8830_0;
}
switch(driveSet){
case Stanby:
drive=STANBY;
break;
case NegativeDrive:
drive=NEG_ROT;
break;
case PositiveDrive:
drive=POS_ROT;
break;
case Break:
drive=BREAK;
break;
default :
printf("Operand Error!!\n");
return 1;
}
if(vSetF < 0.48 || vSetF > 5.06){
printf("vSet=%lf Error!!\n",vSetF);
return 1;
}
//printf("vSetF= %lf\n",vSetF);
vSet=((int)(vSetF * 100)) / 8;
//printf("vSet= %x\n",vSet);
setValue[0]=CONTROL_REG;
setValue[1] = ( vSet << 2 ) | drive;
fd = wiringPiI2CSetup(motorHex);
ret = write(fd, setValue, 2);
if (ret < 0) {
printf("error: set configuration value\n");
return 1;
}
printf("OK!\n");
return 0;
}
// Initialize wiring I2C interface to LidarLite
int lidar_init(bool dbg) {
int fd;
_dbg = dbg;
if (_dbg) printf("LidarLite V0.1\n\n");
fd = wiringPiI2CSetup(LIDAR_LITE_ADRS);
if (fd != -1) {
lidar_status(fd); // Dummy request to wake up device
delay (100);
}
return(fd);
}
bool ofApp::setupOrient3d() {
pullUpDnControl(8, PUD_UP);
pullUpDnControl(9, PUD_UP);
if ( (myOrient3d = wiringPiI2CSetup(0x60)) == -1) {
printf("error initializing i2c for orient3d!\n");
return false;
}
else {
printf("orient3d: i2c init successful\n");
return true;
}
}
static void writeCommand(byte reg, byte value) {
// Wire.beginTransmission((uint8_t)BMP085_ADDRESS);
//#if ARDUINO >= 100
// Wire.write((uint8_t)reg);
// Wire.write((uint8_t)value);
//#else
// Wire.send(reg);
// Wire.send(value);
//#endif
// Wire.endTransmission();
int fd = wiringPiI2CSetup(BMP085_ADDRESS);
wiringPiI2CWriteReg8(fd, reg, value);
}
int main(int argc , char **argv) {
if((fd=wiringPiI2CSetup(dID))<0)
printf("error opening i2c channel\n");
int e = wiringPiI2CWrite(fd, 0x51);
usleep(100000);
int r = wiringPiI2CReadReg16(fd, 0xe1);
int val = (r >> 8) & 0xff | (r << 8) & 0x1;
printf("%d\n", val);
}
void ScanI2CBus() {
int i;
char buff[200];
// najpierw szukamy expanderów i2c na pcf8574
for (i = 0; i < 4; i++) { // zakładamy 4 ekspandery max
hardware.i2c_PCF8574[i].fd = wiringPiI2CSetup (PCF8574_BASE_ADDR+i);
// nie ma innego (?) sposobu na potwierdzenie czy urządzenie istnieje niż próba zapisu
hardware.i2c_PCF8574[i].state = wiringPiI2CWrite (hardware.i2c_PCF8574[i].fd, wiringPiI2CRead(hardware.i2c_PCF8574[i].fd));
if (hardware.i2c_PCF8574[i].state != -1) {
sprintf(buff,"Wykryty osprzęt: Expander pcf8574 o adresie %#x",PCF8574_BASE_ADDR+i);
Log(buff,E_DEV);
// dodatkowe porty trzeba zarejestrować
pcf8574Setup (PCF8574_BASE_PIN+i*8,PCF8574_BASE_ADDR+i) ;
}
}
//sprawdzamy czy jest obecne MinipH
hardware.i2c_MinipH.fd = wiringPiI2CSetup(MINIPH_ADDR);
hardware.i2c_MinipH.state = wiringPiI2CReadReg16(hardware.i2c_MinipH.fd, 0 );
if (hardware.i2c_MinipH.state != -1) {
Log("Wykryty osprzęt: Mostek pomiarowy MinipH",E_DEV);
}
}
void Controller::i2cComm() {
int fd = wiringPiI2CSetup(3);
if(fd > -1) {
int reg, data, op, resp;
while(1) {
cout << "read (0) / write(1): ";
cin >> op;
if(op == 1) {
cout << "write register: ";
cin >> reg;
cout << "write data: ";
cin >> data;
resp = wiringPiI2CWriteReg8(fd, reg, data);
dlog << "response status: " << resp;
} else if (op==2) {
int main(void)
{
int device = wiringPiI2CSetup(address);
if (device < 0)
{
return 1;
}
int data = wiringPiI2CReadReg8(device, 0x01);
printf("%d\n", data);
return 0;
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
std::cerr << "Usage: TCP_echo_server <port>\n";
return -1;
}
wiringPiSetup();
wiringPiI2CSetup(I2C_TEMP_ADDRESS);
boost::thread workerThread(listener_loop, std::atoi(argv[1])); // Creates a thread that loops to accept sockets
workerThread.join();
return 0;
}
int mychecksum(unsigned char start_byte, unsigned char end_byte)
{
int sum = 0;
int counter;
int cc_base;
for (counter = start_byte; counter <end_byte; counter++)
sum = (A50[counter] + sum);
sum = sum & 0x0ff;
cc_base = A50[end_byte]; //sum stored in address 63 or 95.
if (start_byte == 0x0) printf("\ncc_base = %x, sum = %x",cc_base,sum);
else printf("\nextended cc_base = %x and sum = %x\n",cc_base,sum);
if (cc_base != sum && write_checksum){
printf("\nCheck Sum failed, Do you want to write the"
" checksum value %x to address byte \"%x\" ?"
" (Y/N)", sum, end_byte);
int ch = 0;
ch = getchar();
getchar();
if ((ch == 'Y') || (ch == 'y')) {
#ifndef BEAGLEBONE
xio = wiringPiI2CSetup (0x50);
if (xio < 0){
fprintf (stderr, "xio: Unable to initialise I2C: %s\n",
strerror (errno));
return 1;
}
#else
xio = open(filenm, O_RDWR);
if (xio < 0) {
fprintf (stderr, "Unable to open device: %s\n", filenm);
return(1);
}
if (ioctl(xio, I2C_SLAVE, 0x50) < 0) {
fprintf (stderr, "xio: Unable to initialise I2C: %s\n", strerror (errno));
return(1);
}
#endif
printf("end_byte = %x and sum = %x - yes\n",end_byte, sum);
#ifndef BEAGLEBONE
wiringPiI2CWriteReg8(xio, end_byte, sum);
#else
i2c_smbus_write_byte_data(xio, end_byte, sum);
#endif
} else printf("nothing written\n");
}
return 0;
}
