pim/mgos_i2c_mock
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add flags and usage() to main. Uncrustify

Browse Source
This commit is contained in:
Pim van Pelt
2019-01-03 21:28:32 +01:00
parent cb48b78265
commit cafecbb897
3 changed files with 167 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

78
src/main.c
View File

@ -4,12 +4,19 @@
#include <math.h> #include <math.h>
#include <sys/ioctl.h> #include <sys/ioctl.h>
#define I2CBUSNR 7 static bool i2c_dumpregs(struct mgos_i2c *i2c, uint8_t i2caddr);
static void i2c_scanner(struct mgos_i2c *i2c, bool dumpregs);
static int usage(void);
bool i2c_dumpregs(struct mgos_i2c *i2c, uint8_t i2caddr); static int usage(void) {
void i2c_scanner(struct mgos_i2c *i2c, bool dumpregs); printf("Flags: [-i <i2cnusnr>] [-s] [-d]\n");
printf(" -i: Select the I2C bus number, ie '7' for /dev/i2c-7\n");
printf(" -s: Scan the I2C bus upon startup\n");
printf(" -d: Dump byte-registers on each found I2C device\n");
return -1;
}
void i2c_scanner(struct mgos_i2c *i2c, bool dumpregs) { static void i2c_scanner(struct mgos_i2c *i2c, bool dumpregs) {
int i; int i;
if (!i2c) { if (!i2c) {
@ -17,17 +24,19 @@ void i2c_scanner(struct mgos_i2c *i2c, bool dumpregs) {
return; return;
} }
for (i = 0x3; i < 0x77; i++) { for (i = 0x3; i < 0x78; i++) {
bool ret; bool ret;
ret = mgos_i2c_read(i2c, i, NULL, 0, true); ret = mgos_i2c_read(i2c, i, NULL, 0, true);
if (ret) { if (ret) {
LOG(LL_INFO, ("I2C Address 0x%02x %s", i, ret ? "true" : "false")); LOG(LL_INFO, ("Found device at I2C address 0x%02x", i));
if (dumpregs) i2c_dumpregs(i2c, i); if (dumpregs) {
i2c_dumpregs(i2c, i);
}
} }
} }
} }
bool i2c_dumpregs(struct mgos_i2c *i2c, uint8_t i2caddr) { static bool i2c_dumpregs(struct mgos_i2c *i2c, uint8_t i2caddr) {
uint16_t reg; uint16_t reg;
int value; int value;
@ -47,24 +56,69 @@ bool i2c_dumpregs(struct mgos_i2c *i2c, uint8_t i2caddr) {
} }
int main(int argc, char **argv, char **environ) { int main(int argc, char **argv, char **environ) {
struct mgos_i2c * i2c = NULL; int scan = 0;
int dump = 0;
int i2cbus = 1;
int index;
int c;
if (!mgos_i2c_open(I2CBUSNR)) { opterr = 0;
LOG(LL_ERROR, ("Cannot open I2C bus %u", I2CBUSNR));
while ((c = getopt(argc, argv, "i:sdh")) != -1) {
switch (c) {
case 's':
scan = 1;
break;
case 'd':
dump = 1;
break;
case 'i':
i2cbus = atoi(optarg);
break;
case '?':
if (optopt == 'i') {
LOG(LL_ERROR, ("Option -%c requires an argument", optopt));
} else if (isprint(optopt)) {
LOG(LL_ERROR, ("Unknown option `-%c'", optopt));
} else{
LOG(LL_ERROR, ("Unknown option character `\\x%x'", optopt));
}
return usage();
default:
return usage();
}
}
for (index = optind; index < argc; index++) {
LOG(LL_WARN, ("Non-option argument %s, skipping", argv[index]));
}
struct mgos_i2c *i2c = NULL;
if (!mgos_i2c_open(i2cbus)) {
LOG(LL_ERROR, ("Cannot open I2C bus %u", i2cbus));
return -1; return -1;
} }
if (!(i2c = mgos_i2c_get_global())) { if (!(i2c = mgos_i2c_get_global())) {
LOG(LL_ERROR, ("Cannot open I2C bus")); LOG(LL_ERROR, ("Cannot open I2C bus"));
return -2; return -2;
} }
i2c_scanner(i2c, true); if (scan) {
i2c_scanner(i2c, dump);
}
tests_create(); tests_create();
tests_run(); tests_run();
tests_destroy(); tests_destroy();
return 0; return 0;
(void)argc; (void)argc;
(void)argv; (void)argv;
(void)environ; (void)environ;

112
src/mgos_i2c.c
View File

@ -28,35 +28,35 @@
#include <unistd.h> #include <unistd.h>
#include <errno.h> #include <errno.h>
struct mgos_i2c struct mgos_i2c {
{ int fd;
int fd;
uint16_t read_timeout_ms; // in msec uint16_t read_timeout_ms; // in msec
char *filename; char * filename;
}; };
static struct mgos_i2c *s_global_i2c_bus = NULL; static struct mgos_i2c *s_global_i2c_bus = NULL;
static size_t i2c_read_timeout(struct mgos_i2c *i2c, void *data, size_t len) { static size_t i2c_read_timeout(struct mgos_i2c *i2c, void *data, size_t len) {
uint16_t tries; uint16_t tries;
size_t ret=-1; size_t ret = -1;
if (!i2c) return -1; if (!i2c) {
return -1;
}
ret = read(i2c->fd, data, len); ret = read(i2c->fd, data, len);
for(tries=i2c->read_timeout_ms; tries && ret!=len && len>0; tries--) { for (tries = i2c->read_timeout_ms; tries && ret != len && len > 0; tries--) {
usleep(1000); usleep(1000);
ret = read(i2c->fd, data, len); ret = read(i2c->fd, data, len);
} }
if (ret!=len) { if (ret != len) {
// LOG(LL_ERROR, ("Read timeout on I2C")); // LOG(LL_ERROR, ("Read timeout on I2C"));
return -1; return -1;
} }
return len; return len;
} }
bool mgos_i2c_read(struct mgos_i2c *i2c, uint16_t addr, void *data, size_t len, bool stop) { bool mgos_i2c_read(struct mgos_i2c *i2c, uint16_t addr, void *data, size_t len, bool stop) {
size_t ret; size_t ret;
@ -65,7 +65,7 @@ bool mgos_i2c_read(struct mgos_i2c *i2c, uint16_t addr, void *data, size_t len,
return false; return false;
} }
if (ioctl(i2c->fd,I2C_SLAVE,addr) < 0) { if (ioctl(i2c->fd, I2C_SLAVE, addr) < 0) {
LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus", addr)); LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus", addr));
return false; return false;
} }
@ -75,10 +75,10 @@ bool mgos_i2c_read(struct mgos_i2c *i2c, uint16_t addr, void *data, size_t len,
return false; return false;
} }
return true; return true;
(void)stop; (void)stop;
} }
bool mgos_i2c_write(struct mgos_i2c *i2c, uint16_t addr, const void *data, size_t len, bool stop) { bool mgos_i2c_write(struct mgos_i2c *i2c, uint16_t addr, const void *data, size_t len, bool stop) {
size_t ret; size_t ret;
@ -87,7 +87,7 @@ bool mgos_i2c_write(struct mgos_i2c *i2c, uint16_t addr, const void *data, size_
return false; return false;
} }
if (ioctl(i2c->fd,I2C_SLAVE,addr) < 0) { if (ioctl(i2c->fd, I2C_SLAVE, addr) < 0) {
LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus", addr)); LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus", addr));
return false; return false;
} }
@ -97,69 +97,72 @@ bool mgos_i2c_write(struct mgos_i2c *i2c, uint16_t addr, const void *data, size_
return false; return false;
} }
return true; return true;
(void)stop; (void)stop;
} }
void mgos_i2c_stop(struct mgos_i2c *i2c) { void mgos_i2c_stop(struct mgos_i2c *i2c) {
return; return;
(void)i2c; (void)i2c;
} }
int mgos_i2c_get_freq(struct mgos_i2c *i2c) { int mgos_i2c_get_freq(struct mgos_i2c *i2c) {
return MGOS_I2C_FREQ_100KHZ; return MGOS_I2C_FREQ_100KHZ;
(void)i2c; (void)i2c;
} }
bool mgos_i2c_set_freq(struct mgos_i2c *i2c, int freq) { bool mgos_i2c_set_freq(struct mgos_i2c *i2c, int freq) {
if (freq==MGOS_I2C_FREQ_100KHZ) return true; if (freq == MGOS_I2C_FREQ_100KHZ) {
return true;
}
return false; return false;
(void)i2c; (void)i2c;
} }
int mgos_i2c_read_reg_b(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg) { int mgos_i2c_read_reg_b(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg) {
uint8_t value; uint8_t value;
if (!mgos_i2c_read_reg_n(i2c, addr, reg, 1, &value)) if (!mgos_i2c_read_reg_n(i2c, addr, reg, 1, &value)) {
return -1; return -1;
}
return value; return value;
} }
int mgos_i2c_read_reg_w(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg) { int mgos_i2c_read_reg_w(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg) {
uint16_t value; uint16_t value;
uint8_t data[2]; uint8_t data[2];
if (!mgos_i2c_read_reg_n(i2c, addr, reg, 2, data)) if (!mgos_i2c_read_reg_n(i2c, addr, reg, 2, data)) {
return -1; return -1;
value=(data[0]<<8)+data[1]; }
value = (data[0] << 8) + data[1];
return value; return value;
} }
bool mgos_i2c_read_reg_n(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, size_t n, uint8_t *buf) { bool mgos_i2c_read_reg_n(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, size_t n, uint8_t *buf) {
uint8_t outbuf; uint8_t outbuf;
struct i2c_rdwr_ioctl_data packets; struct i2c_rdwr_ioctl_data packets;
struct i2c_msg messages[2]; struct i2c_msg messages[2];
if (!i2c) { if (!i2c) {
LOG(LL_ERROR, ("No I2C bus")); LOG(LL_ERROR, ("No I2C bus"));
return -1; return -1;
} }
if (ioctl(i2c->fd,I2C_SLAVE,addr) < 0) { if (ioctl(i2c->fd, I2C_SLAVE, addr) < 0) {
LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus: %s", addr, strerror(errno))); LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus: %s", addr, strerror(errno)));
return -1; return -1;
} }
/* /*
* In order to read a register, we first do a "dummy write" by writing * In order to read a register, we first do a "dummy write" by writing
* 0 bytes to the register we want to read from. This is similar to * 0 bytes to the register we want to read from. This is similar to
* the packet in set_i2c_register, except it's 1 byte rather than 2. * the packet in set_i2c_register, except it's 1 byte rather than 2.
*/ */
outbuf = reg; outbuf = reg;
messages[0].addr = addr; messages[0].addr = addr;
messages[0].flags = 0; messages[0].flags = 0;
messages[0].len = sizeof(outbuf); messages[0].len = sizeof(outbuf);
@ -167,85 +170,82 @@ bool mgos_i2c_read_reg_n(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, size_
/* The data will get returned in this structure */ /* The data will get returned in this structure */
messages[1].addr = addr; messages[1].addr = addr;
messages[1].flags = I2C_M_RD/* | I2C_M_NOSTART*/; messages[1].flags = I2C_M_RD /* | I2C_M_NOSTART*/;
messages[1].len = n; messages[1].len = n;
messages[1].buf = buf; messages[1].buf = buf;
/* Send the request to the kernel and get the result back */ /* Send the request to the kernel and get the result back */
packets.msgs = messages; packets.msgs = messages;
packets.nmsgs = 2; packets.nmsgs = 2;
if(ioctl(i2c->fd, I2C_RDWR, &packets) < 0) if (ioctl(i2c->fd, I2C_RDWR, &packets) < 0) {
return false; return false;
}
return true; return true;
} }
bool mgos_i2c_write_reg_w(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, uint16_t value) { bool mgos_i2c_write_reg_w(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, uint16_t value) {
uint8_t data[2]; uint8_t data[2];
data[0]=value>>8;
data[1]=value&0xFF; data[0] = value >> 8;
data[1] = value & 0xFF;
return mgos_i2c_write_reg_n(i2c, addr, reg, 2, data); return mgos_i2c_write_reg_n(i2c, addr, reg, 2, data);
} }
bool mgos_i2c_write_reg_b(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, uint8_t value) { bool mgos_i2c_write_reg_b(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, uint8_t value) {
return mgos_i2c_write_reg_n(i2c, addr, reg, 1, &value); return mgos_i2c_write_reg_n(i2c, addr, reg, 1, &value);
} }
bool mgos_i2c_write_reg_n(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, size_t n, const uint8_t *buf) { bool mgos_i2c_write_reg_n(struct mgos_i2c *i2c, uint16_t addr, uint8_t reg, size_t n, const uint8_t *buf) {
unsigned char outbuf[n+1]; unsigned char outbuf[n + 1];
struct i2c_rdwr_ioctl_data packets; struct i2c_rdwr_ioctl_data packets;
struct i2c_msg messages[1]; struct i2c_msg messages[1];
if (!i2c) { if (!i2c) {
LOG(LL_ERROR, ("No I2C bus")); LOG(LL_ERROR, ("No I2C bus"));
return false; return false;
} }
if (ioctl(i2c->fd,I2C_SLAVE,addr) < 0) { if (ioctl(i2c->fd, I2C_SLAVE, addr) < 0) {
LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus: %s", addr, strerror(errno))); LOG(LL_ERROR, ("Cannot select slave 0x%04x on I2C bus: %s", addr, strerror(errno)));
return false; return false;
} }
messages[0].addr=addr; messages[0].addr = addr;
messages[0].flags=0; messages[0].flags = 0;
messages[0].len=sizeof(outbuf); messages[0].len = sizeof(outbuf);
messages[0].buf=outbuf; messages[0].buf = outbuf;
outbuf[0]=reg; outbuf[0] = reg;
memcpy(outbuf+1, buf, n); memcpy(outbuf + 1, buf, n);
packets.msgs = messages; packets.msgs = messages;
packets.nmsgs = 1; packets.nmsgs = 1;
if(ioctl(i2c->fd, I2C_RDWR, &packets) < 0) { if (ioctl(i2c->fd, I2C_RDWR, &packets) < 0) {
return false; return false;
} }
return true; return true;
} }
void mgos_i2c_close(struct mgos_i2c *i2c) { void mgos_i2c_close(struct mgos_i2c *i2c) {
return; return;
(void)i2c; (void)i2c;
} }
struct mgos_i2c *mgos_i2c_get_global(void) { struct mgos_i2c *mgos_i2c_get_global(void) {
return s_global_i2c_bus; return s_global_i2c_bus;
} }
// User provided function to interface with Linux I2C driver // User provided function to interface with Linux I2C driver
bool mgos_i2c_open(int busnr) { bool mgos_i2c_open(int busnr) {
int fd; int fd;
char filename[20]; char filename[20];
struct mgos_i2c *i2c; struct mgos_i2c *i2c;
sprintf(filename,"/dev/i2c-%d",busnr); sprintf(filename, "/dev/i2c-%d", busnr);
if ((fd = open(filename,O_RDWR)) < 0) { if ((fd = open(filename, O_RDWR)) < 0) {
LOG(LL_ERROR, ("Could not open %s", filename)); LOG(LL_ERROR, ("Could not open %s", filename));
return false; return false;
} }
@ -254,10 +254,10 @@ bool mgos_i2c_open(int busnr) {
LOG(LL_ERROR, ("Could not allocate mgos_i2c handle for %s", filename)); LOG(LL_ERROR, ("Could not allocate mgos_i2c handle for %s", filename));
return false; return false;
} }
i2c->fd=fd; i2c->fd = fd;
i2c->filename=strdup(filename); i2c->filename = strdup(filename);
i2c->read_timeout_ms=1000; i2c->read_timeout_ms = 1000;
s_global_i2c_bus=i2c; s_global_i2c_bus = i2c;
LOG(LL_INFO, ("Opened I2C bus on %s", filename)); LOG(LL_INFO, ("Opened I2C bus on %s", filename));
return true; return true;

84
src/mgos_mock.c
View File

@ -23,91 +23,97 @@
int _mgos_timers = 0; int _mgos_timers = 0;
int log_print_prefix(enum cs_log_level l, const char *func, const char *file) { int log_print_prefix(enum cs_log_level l, const char *func, const char *file) {
char ll_str[6]; char ll_str[6];
char ll_file[31]; char ll_file[31];
char ll_func[41]; char ll_func[41];
size_t offset=0; size_t offset = 0;
switch(l) { switch (l) {
case LL_ERROR: case LL_ERROR:
strncpy(ll_str, "ERROR", sizeof(ll_str)); strncpy(ll_str, "ERROR", sizeof(ll_str));
break; break;
case LL_WARN:
strncpy(ll_str, "WARN", sizeof(ll_str)); case LL_WARN:
break; strncpy(ll_str, "WARN", sizeof(ll_str));
case LL_INFO: break;
strncpy(ll_str, "INFO", sizeof(ll_str));
break; case LL_INFO:
case LL_DEBUG: strncpy(ll_str, "INFO", sizeof(ll_str));
strncpy(ll_str, "DEBUG", sizeof(ll_str)); break;
break;
case LL_VERBOSE_DEBUG: case LL_DEBUG:
strncpy(ll_str, "VERB", sizeof(ll_str)); strncpy(ll_str, "DEBUG", sizeof(ll_str));
break; break;
default: // LL_NONE
return 0; case LL_VERBOSE_DEBUG:
strncpy(ll_str, "VERB", sizeof(ll_str));
break;
default: // LL_NONE
return 0;
} }
offset=0; offset = 0;
memset(ll_file, 0, sizeof(ll_file)); memset(ll_file, 0, sizeof(ll_file));
if (strlen(file) >= sizeof(ll_file)) if (strlen(file) >= sizeof(ll_file)) {
offset=strlen(file)-sizeof(ll_file)+1; offset = strlen(file) - sizeof(ll_file) + 1;
strncpy(ll_file, file+offset, sizeof(ll_file)-1); }
strncpy(ll_file, file + offset, sizeof(ll_file) - 1);
offset=0; offset = 0;
memset(ll_func, 0, sizeof(ll_func)); memset(ll_func, 0, sizeof(ll_func));
if (strlen(func) >= sizeof(ll_func)) if (strlen(func) >= sizeof(ll_func)) {
offset=strlen(func)-sizeof(ll_func)+1; offset = strlen(func) - sizeof(ll_func) + 1;
strncpy(ll_func, func+offset, sizeof(ll_func)-1); }
strncpy(ll_func, func + offset, sizeof(ll_func) - 1);
printf ("%-5s %-30s %-40s| ", ll_str, ll_file, ll_func); printf("%-5s %-30s %-40s| ", ll_str, ll_file, ll_func);
return 1; return 1;
} }
double mg_time(void) { double mg_time(void) {
struct timespec ts; struct timespec ts;
double ret; double ret;
clock_gettime(CLOCK_REALTIME_COARSE, &ts); clock_gettime(CLOCK_REALTIME_COARSE, &ts);
ret = (double) ts.tv_sec; ret = (double)ts.tv_sec;
ret += ((double)ts.tv_nsec)/1000000000; ret += ((double)ts.tv_nsec) / 1000000000;
return ret; return ret;
} }
void mgos_usleep(uint32_t usecs) { void mgos_usleep(uint32_t usecs) {
usleep(usecs); usleep(usecs);
} }
bool mgos_gpio_set_int_handler(int pin, enum mgos_gpio_int_mode mode, mgos_gpio_int_handler_f cb, void *arg) { bool mgos_gpio_set_int_handler(int pin, enum mgos_gpio_int_mode mode, mgos_gpio_int_handler_f cb, void *arg) {
LOG(LL_INFO, ("Not implemented.")); LOG(LL_INFO, ("Not implemented."));
return true; return true;
(void)pin; (void)pin;
(void)mode; (void)mode;
(void)cb; (void)cb;
(void)arg; (void)arg;
} }
bool mgos_gpio_enable_int(int pin) { bool mgos_gpio_enable_int(int pin) {
LOG(LL_INFO, ("Not implemented.")); LOG(LL_INFO, ("Not implemented."));
return true; return true;
(void)pin; (void)pin;
} }
bool mgos_gpio_disable_int(int pin) { bool mgos_gpio_disable_int(int pin) {
LOG(LL_INFO, ("Not implemented.")); LOG(LL_INFO, ("Not implemented."));
return true; return true;
(void)pin; (void)pin;
} }
void mgos_gpio_clear_int(int pin) { void mgos_gpio_clear_int(int pin) {
LOG(LL_INFO, ("Not implemented.")); LOG(LL_INFO, ("Not implemented."));
return; return;
(void)pin; (void)pin;
} }