vector<uint8_t> ModCom::comunicate(vector<uint8_t> buffer, bool readdata, int sizeread) {
uint8_t *buffer_out = &(buffer[0]);
uint8_t buffer_in[255];
serialport_flush(fd);
serialport_write(fd, (char*)buffer_out);
if (!readdata) {
vector<uint8_t> toreturn;
return toreturn;
} // if only send
//serial_read(fd, buffer_in, 1, DEF_TIMEOUT);
serialport_read(fd, buffer_in, sizeread, DEF_TIMEOUT);
if (buffer_in[0] != 0xFF) {
vector<uint8_t> toreturn;
return toreturn;
}
vector<uint8_t> vr(buffer_in, buffer_in + sizeread);
return vr;
}
static void *callback(enum mg_event event,
struct mg_connection *conn,
const struct mg_request_info *request_info)
{
const int buf_max = 1000;
char result[buf_max] = "none";
if (event == MG_NEW_REQUEST) {
//const char* uri = request_info->uri;
// get query args
char cmd[32];
char timeoutStr[5];
int timeout;
char str[256];
get_qsvar(request_info, "cmd", cmd, sizeof(cmd));
get_qsvar(request_info, "str", str, sizeof(str));
get_qsvar(request_info, "timeout", timeoutStr, sizeof(timeoutStr));
timeout = timeoutStr[0] == '\0' ? 5000 : atoi(timeoutStr);
if( ! cmd[0] ) { // cmd is empty
/// do something useful here
}
else {
if( strcasecmp(cmd, "read")==0 ) {
serialport_flush(fd);
serialport_read_until(fd, str, '\n', buf_max, timeout);
sprintf(result, "read:\n%s\n",str); // debug
}
else if( strcasecmp(cmd, "send")==0 ) {
serialport_write(fd, str);
sprintf(result, "send:\n%s\n",str);
}
else if( strcasecmp(cmd, "sendline")==0 ) {
sprintf(str, "%s\r\n ", str);
serialport_write(fd, str);
sprintf(result, "sendline:\n%s",str);
}
else {
sprintf(result, "uknown cmd '%s'",cmd);
}
}
printf("result:%s\n",result);
// Echo requested URI back to the client
mg_printf(conn, "HTTP/1.1 200 OK\r\n"
"Content-Type: text/plain\r\n\r\n"
"%s"
"\n",
result
);
return ""; // Mark as processed
} else {
return NULL;
}
}
int setupSerial(char* port) {
fd = -1;
fd = serialport_init(port, DEFAULT_BAUDRATE);
if( fd==-1 ){
errorPrint("couldn't open port");
return fd;
}
serialport_flush(fd);
return fd;
}
int serialport_close(void)
{
if(!sPort)
return 0;
serialport_drain();
serialport_flush();
CloseHandle(sPort);
sPort = NULL;
return 1;
}
int main(int argc, char *argv[] ){
int i, j;
printf("samples: %d\n", SAMPLES);
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGBA | GLUT_DEPTH );
glutInitWindowSize( 512, 512 );
glutCreateWindow( "OpenGL example" );
// setup serial comms
//USB = serialport_init("/dev/serial/by-id/usb-Arduino__www.arduino.cc__0043_85231363236351810222-if00", 9600);
USB = serialport_init("/dev/serial/by-id/usb-Arduino__www.arduino.cc__Arduino_Uno_6493832333135180F002-if00", 9600);
if(USB){
printf("Connected!\n");
serialport_flush(USB);
// serialport_write(USB, "0");
// serialport_write(USB, "20");
}
else
return;
// allocate sample space
for(i = SERVOS; i--;){
Servos[i] = fbGenServo(
impactResponse,
30, // angle
3.00f // variance coefficent
);
}
pthread_create(
&RXthread,
NULL,
serialRX,
NULL
);
pthread_create(
&TXthread,
NULL,
serialTX,
NULL
);
// initialize glew:
int glew_err = glewInit();
if(glew_err != GLEW_OK)
fprintf(stderr, "GLEW Error: %s\n", glewGetErrorString(glew_err));
glutDisplayFunc( display );
glutKeyboardFunc( keyboard );
glutMainLoop();
return 0;
}
int setupSerial(const char *port, int baudrate) {
int fd = -1;
DBG("%s\n", port);
fd = serialport_init(port, baudrate);
if( fd==-1 ) {
ERR("couldn't open port %s @ %d bauds\n", port, baudrate);
return -1;
}
DBG("opened port %s @ %d bps\n",port, baudrate);
serialport_flush(fd);
return fd;
};
int open_port(void){
if( fd!=-1 ) {
serialport_close(fd);
printf("closed port %s\n",serialport);
}
strcpy(serialport,optarg);
fd = serialport_init(optarg, baudrate);
if( fd==-1 ){
printf("couldn't open port");
return -1;
}
printf("opened port %s\n",serialport);
serialport_flush(fd);
return 0;
}
void main(void)
{
int fd, Error;
int baud = 9600;
char serialport[] = "/dev/ttyACM0";
union uuFreq {
char fBytes[4];
float fFloat;
} uFreq;
uFreq.fFloat = 50.00;
union uuTime {
char tBytes[4];
unsigned long tLong;
} uTime;
uTime.tLong = 5000;
union uuChannel {
char cBytes[2];
unsigned int cInt;
} uChannel;
uChannel.cInt = 1;
fd = serialport_init(serialport, baud);
Error = serialport_flush(fd);
// Loop through several times then send song over
for (int i = 0; i < 71; i++)
{
if (i == 70)
{
uFreq.fFloat = 0xFFFFFFFF;
uTime.tLong = 0xFFFF;
uChannel.cInt = 0xFF;
}
// Send Frequency - incremented by 20
uFreq.fFloat = uFreq.fFloat + 20.0;
Error = serialport_writebyte(fd, uFreq.fBytes[0]);
tcdrain(fd);
Error = serialport_writebyte(fd, uFreq.fBytes[1]);
tcdrain(fd);
Error = serialport_writebyte(fd, uFreq.fBytes[2]);
tcdrain(fd);
Error = serialport_writebyte(fd, uFreq.fBytes[3]);
tcdrain(fd);
// Send Time - incremented by 500 ms
uTime.tLong = uTime.tLong + 500;
Error = serialport_writebyte(fd, uTime.tBytes[0]);
tcdrain(fd);
Error = serialport_writebyte(fd, uTime.tBytes[1]);
tcdrain(fd);
Error = serialport_writebyte(fd, uTime.tBytes[2]);
tcdrain(fd);
Error = serialport_writebyte(fd, uTime.tBytes[3]);
tcdrain(fd);
// Send Channel
Error = serialport_writebyte(fd, uChannel.cBytes[0]);
tcdrain(fd);
Error = serialport_writebyte(fd, uChannel.cBytes[1]);
tcdrain(fd);
// Send \0
Error = serialport_writebyte(fd, '\0');
usleep(50000);
tcdrain(fd);
}
serialport_close(fd);
//return 0;
}
/*---------------------------------------------------------------------------*/
int main(int argc, char**argv)
{
int i;
int fd = 0;
uint16_t trial = 0;
char* portPath = NULL;
char* rx_addressString = NULL;
char* tx_addressString = NULL;
printf("> Simple message listener for tea-bootloader compatible nodes\n");
/*-----------------------------------------------------------------------*/
if(argc == 4)
{
portPath = argv[1];
rx_addressString = argv[2];
sscanf(rx_addressString,"%X:%X:%X:%X:%X",rx_addressBuffer,rx_addressBuffer+1,rx_addressBuffer+2,rx_addressBuffer+3,rx_addressBuffer+4);
tx_addressString = argv[3];
sscanf(tx_addressString,"%X:%X:%X:%X:%X",tx_addressBuffer,tx_addressBuffer+1,tx_addressBuffer+2,tx_addressBuffer+3,tx_addressBuffer+4);
}
else
{
printf("> Argument parsing error!\n");
printf("> Usage: [port path] [dongle RX address] [node RX address]\n");
printf("> Example: ./main /dev/tty.usbserial-A900cbrd 0xE7:0xE7:0xE7:0xE7:0x00 0xD7:0xD7:0xD7:0xD7:0xD7\n");
return 0;
}
/*-----------------------------------------------------------------------*/
fd = serialport_init(portPath,115200,'n');
if(fd < 0)
{
printf("[err]: Connection error.\n");
return 0;
}
else
{
printf("> Conection OK.\n");
serialport_flush(fd);
printf("> Serial port flush OK.\n");
if(loopbackTest(fd) != 0)
{
printf("> Loopback test failed!\r\n");
return 0;
}
else
{
uint8_t version = getVersion(fd);
printf("> Dongle version: %d.%d\r\n",(version>>4),(version&0x0F));
}
}
printf("> Setting the TX address ...\n");
setTXAddress(fd,tx_addressBuffer);
printf("> Setting the RX address ...\n");
setRXAddress(fd,rx_addressBuffer);
while(1)
{
uint8_t thisBuffer[1024];
char sendBuffer[256];
uint8_t len;
int temp;
float realval;
if(getRxFifoCount(fd))
{
len = getRxFifoCount(fd);
printf("> ---------------------------------------------------------------------------\n");
printf("> New message!\n");
printf("> Length: %d\n",len);
pullDataFromFifo(fd,len,thisBuffer);
hexDump("> Dump",thisBuffer,len);
temp = (thisBuffer[0]<<8)+thisBuffer[1];
realval = ((float)temp * 1100.0) / 1024.0;
realval -= 500;
realval /= 10.0;
printf("> Raw: %d\n",temp);
printf("> Readout: %f\n",realval);
sprintf(sendBuffer,"./phant_client.rb %f",realval);
system(sendBuffer);
printf("> Phant.io send process done.\n");
}
}
}
int main(int argc, char *argv[])
{
/*accelerometer related declarations*/
const int buf_max = 2048;
int fd = -1;
char serialport[buf_max];
int baudrate = 9600; // default
char quiet=0;
char eolchar = ' ';
int timeout = 5000;
char buf[buf_max];
int rc,n,p;
float xDat[103],yDat[103],zDat[103];
float sumX=0,sumY=0,sumZ=0;
float sum1=0,sum2=0,sum3=0;
float stdX=0,stdY=0,stdZ=0,avgX=0,avgY=0,avgZ=0,varX=0,varY=0,varZ=0,recal=0;
int total=1;
int calibrate=0;
/*---------------------------------*/
// char stdbuffer[10];
/*socket related declarations*/
int sockfd, portno, n2;
struct sockaddr_in serv_addr;
struct hostent *server;
char buffer[256];
int sendMessage=1;
/*----------------------------*/
if (argc==1) {
usage();
}
/* parse options */
int option_index = 0, opt;
static struct option loptions[] = {
{"help", no_argument, 0, 'h'},
{"port", required_argument, 0, 'p'},
{"baud", required_argument, 0, 'b'},
{"send", required_argument, 0, 's'},
{"setup", no_argument, 0, 'S'},
{"receive", no_argument, 0, 'r'},
{"flush", no_argument, 0, 'F'},
{"num", required_argument, 0, 'n'},
{"delay", required_argument, 0, 'd'},
{"eolchar", required_argument, 0, 'e'},
{"timeout", required_argument, 0, 't'},
{"quiet", no_argument, 0, 'q'},
{NULL, 0, 0, 0}
};
while(1) {
opt = getopt_long (argc, argv, "hp:b:s:rSFn:d:qe:t:",
loptions, &option_index);
if (opt==-1) break;
switch (opt) {
case '0': break;
case 'q':
quiet = 1;
break;
case 'e':
eolchar = optarg[0];
if(!quiet) printf("eolchar set to '%c'\n",eolchar);
break;
case 't':
timeout = strtol(optarg,NULL,10);
if( !quiet ) printf("timeout set to %d millisecs\n",timeout);
break;
case 'd':
n = strtol(optarg,NULL,10);
if( !quiet ) printf("sleep %d millisecs\n",n);
usleep(n * 1000 ); // sleep milliseconds
break;
case 'h':
usage();
break;
case 'b':
baudrate = strtol(optarg,NULL,10);
break;
case 'p':
if( fd!=-1 ) {
serialport_close(fd);
if(!quiet) printf("closed port %s\n",serialport);
}
strcpy(serialport,optarg);
fd = serialport_init(optarg, baudrate);
if( fd==-1 ) error("couldn't open port");
if(!quiet) printf("opened port %s\n",serialport);
serialport_flush(fd);
break;
case 'n':
if( fd == -1 ) error("serial port not opened");
n = strtol(optarg, NULL, 10); // convert string to number
rc = serialport_writebyte(fd, (uint8_t)n);
if(rc==-1) error("error writing");
break;
case 'S':
portno = 52002;//atoi(argv[2]);
/* Create a socket point*/
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
{
perror("ERROR opening socket");
exit(1);
}
server = gethostbyname("192.168.2.103");//gethostbyname(argv[1]);
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
/* Now connect to the server */
if (connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0)
{
perror("ERROR connecting");
exit(1);
}
while(1){
int r;
int a1, a2, a3;
char a4[sizeof(float)*3+3];
memset (buf, 0, 256);
r = serialport_read_until(fd, buf);
//fprintf (stderr, "VAL: %s -->", buf);
if (r >= 0)
{
sscanf (buf, "A1:%d\tA2:%d\tA3:%d", &a1, &a2, &a3);
// fprintf (stderr, "(%d)(%d)(%d)\n", a1, a2, a3);
if(calibrate==0){
sumX= sumX + a1; sumY= sumY + a2; sumZ= sumZ + a3;
xDat[total]=a1;yDat[total]=a2;zDat[total]=a3;
total++;
if (total==100){
calibrate=1;
avgX = sumX/(float)total; avgY = sumY/(float)total; avgZ = sumZ/(float)total;
for(p = 1; p<total;p++){
sum1 = sum1 + pow((xDat[p]-avgX),2); sum2 = sum2 + pow((yDat[p]-avgY),2); sum3 = sum3 + pow((zDat[p]-avgZ),2);
}
varX= sum1/(float)total; varY=sum2/(float)total; varZ=sum3/(float)total;
stdX=sqrt(varX); stdY=sqrt(varY); stdZ=sqrt(varZ);
}
}
if(calibrate==1){snprintf(a4, sizeof a4*7, "%f %f %f %f %f %f %f %f %f", (float)a1, (float)a2,(float)a3,avgX,avgY,avgZ,stdX,stdY,stdZ);}
while(sendMessage==1&&calibrate==1){
/* Send message to the server*/
//printf("here");
n2 = write(sockfd,a4,strlen(a4));
if (n2 < 0)
{
perror("ERROR writing to socket");
exit(1);
}
/* Now read server response */
bzero(buffer,256);
n2 = read(sockfd,buffer,255);
if (n2 < 0)
{
perror("ERROR reading from socket");
exit(1);
}
// printf("Received message: %s\n",buffer);
sendMessage=0;
}
sendMessage=1;
}
sendMessage=1;
fflush (0);
//sleep (5);
}
break;
case 's':
if( fd == -1 ) error("serial port not opened");
sprintf(buf, (opt=='S' ? "%s\n" : "%s"), optarg);
if( !quiet ) printf("send string:%s\n", buf);
rc = serialport_write(fd, buf);
if(rc==-1) error("error writing");
break;
case 'r':
while (1)
{
int r;
int a1, a2, a3;
memset (buf, 0, 256);
r = serialport_read_until(fd, buf);
fprintf (stderr, "VAL: %s -->", buf);
// printf("%d",r);
if (r >= 0)
{
sscanf (buf, "A1:%d\tA2:%d\tA3:%d", &a1, &a2, &a3);
fprintf (stderr, "(%d)(%d)(%d)\n", a1, a2, a3);
//fgets(stdbuffer,10,stdin);
//if(strcmp(stdbuffer,"getData")==0){
// printf("%d",a1);
// printf("%d",a2);
// printf("%d",a3);}
//}
/* while(sendMessage==1){
/* Send message to the server
n2 = write(sockfd,"measure",strlen("measure"));
if (n2 < 0)
{
perror("ERROR writing to socket");
exit(1);
}
/* Now read server response
bzero(buffer,256);
n2 = read(sockfd,buffer,255);
if (n2 < 0)
{
perror("ERROR reading from socket");
exit(1);
}
printf("Received message: %s\n",buffer);
sendMessage=0;
}*/
}
fflush (0);
usleep (10000);
}
break;
case 'F':
if( fd == -1 ) error("serial port not opened");
if( !quiet ) printf("flushing receive buffer\n");
serialport_flush(fd);
break;
}
}
exit(EXIT_SUCCESS);
} // end main
void HardwareSerial::flush()
{
//printf("HardwareSerial::flush()\n");
serialport_flush(_fd);
}
void* serialTX(void* params){
while(1){
int servo = -1, value = -1;
char buf0[128], buf1[128];
if(oscillating){
int i = 0;
oscTime += 0.016f;
int angle = 10 + (int)(50 * (cos(oscTime) + 1) / 2.0f);
for(i = 4; i--;){
//if(overloaded[i]){
// txState.Angle[i] = 10;
// continue;
//}
txState.Angle[i] = angle;
}
WriteTX(&txState);
usleep(35000);
continue;
}
printf("Servo: "); scanf("%d", &servo);
if(servo > 0 && servo <= SERVOS){
printf("Value: "); scanf("%d", &value);
if(value >= 0 && value <= 180){
// send
txState.Angle[servo - 1] = value;
if(WriteTX(&txState) < 0)
serialport_flush(USB);
}
}
else if(servo == -1){
ServoStates txState = {
{90,90,90,90 ,90,90,90,90}
};
WriteTX(&txState);
}
else if(servo == -2){
ServoStates txState = {
{50,50,50,50 ,50,50,50,50}
};
WriteTX(&txState);
}
else if(servo == -3){
char command[128];
int value;
printf("Value: "); scanf("%d", &value);
{
ServoStates txState = {
{value,value,value,value ,value,value,value,value}
};
WriteTX(&txState);
}
}
else if(servo == -4) oscillating = 1;
}
}
int main(int argc, char *argv[])
{
struct mg_context *ctx;
int baudrate = 9600; // default
char httpport[16] = "8080";
char serialport[256];
/* parse options */
int option_index = 0, opt;
static struct option loptions[] = {
{"help", no_argument, 0, 'h'},
{"httpport", required_argument, 0, 'P'},
{"serialport", required_argument, 0, 'p'},
{"baud", required_argument, 0, 'b'},
{"quiet", no_argument, 0, 'q'},
{NULL, 0, 0, 0}
};
while(1) {
opt = getopt_long (argc, argv, "hP:p:b:q",
loptions, &option_index);
if (opt==-1) break;
switch (opt) {
case '0': break;
case 'h':
usage();
break;
case 'b':
baudrate = strtol(optarg,NULL,10);
break;
case 'p':
strcpy(serialport,optarg);
fd = serialport_init(optarg, baudrate);
if( fd==-1 ) error("couldn't open port");
serialport_flush(fd);
break;
case 'P':
strcpy(httpport,optarg);
break;
}
}
char *options[] = {"listening_ports", httpport, NULL};
//fd = serialport_init("/dev/tty.usbserial-A800f8ib", 19200);
fd = serialport_init( serialport, baudrate );
if( fd==-1 ) fprintf(stderr, "couldn't open port");
printf("opened serialport %s @ %d bps\n", serialport, baudrate);
ctx = mg_start(&callback, NULL, (const char**) options);
printf("arduino-serial-server: running on port %s\n",
mg_get_option(ctx, "listening_ports"));
getchar(); // Wait until user hits "enter"
mg_stop(ctx);
return 0;
}
int main(int argc, char *argv[])
{
int sd = -1;
char *conf_file = NULL;
struct mosquitto *mosq;
struct module *md;
struct device *dev;
int rc;
int i;
gbuf[0] = 0;
if (!quiet) printf("Version: %s\n", version);
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
signal(SIGUSR1, handle_signal);
signal(SIGUSR2, handle_signal);
signal(SIGALRM, each_sec);
for (i=1; i<argc; i++) {
if(!strcmp(argv[i], "-c") || !strcmp(argv[i], "--config")){
if(i==argc-1){
fprintf(stderr, "Error: -c argument given but no file specified.\n\n");
print_usage(argv[0]);
return 1;
}else{
conf_file = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--quiet")){
quiet = true;
}else{
fprintf(stderr, "Error: Unknown option '%s'.\n",argv[i]);
print_usage(argv[0]);
return 1;
}
}
if (!conf_file) {
fprintf(stderr, "Error: No config file given.\n");
return 1;
}
memset(&config, 0, sizeof(struct bridge_config));
if (config_parse(conf_file, &config)) return 1;
if (quiet) config.debug = 0;
if (config.debug != 0) printf("Debug: %d\n", config.debug);
rc = bridge_init(&bridge, config.id, MODULES_BRIDGE_ID);
if (rc) {
if (config.debug) printf("Error: Failed to initialize bridge: %d\n", rc);
return 1;
}
mosquitto_lib_init();
mosq = mosquitto_new(config.id, true, NULL);
if(!mosq){
fprintf(stderr, "Error creating mqtt instance.\n");
switch(errno){
case ENOMEM:
fprintf(stderr, " out of memory.\n");
break;
case EINVAL:
fprintf(stderr, " invalid id.\n");
break;
}
return 1;
}
snprintf(gbuf, GBUF_SIZE, "%d", PROTOCOL_TIMEOUT);
mosquitto_will_set(mosq, bridge.bridge_dev->status_topic, strlen(gbuf), gbuf, config.mqtt_qos, MQTT_RETAIN);
mosquitto_connect_callback_set(mosq, on_mqtt_connect);
mosquitto_disconnect_callback_set(mosq, on_mqtt_disconnect);
mosquitto_message_callback_set(mosq, on_mqtt_message);
mosquitto_user_data_set(mosq, &sd);
md = bridge_add_module(bridge.bridge_dev, MODULES_MQTT_ID, true);
if (!md) {
fprintf(stderr, "Failed to add MQTT module.\n");
return 1;
}
if (config.scripts_folder) {
if (access(config.scripts_folder, R_OK )) {
fprintf(stderr, "Couldn't open scripts folder: %s\n", config.scripts_folder);
return 1;
}
md = bridge_add_module(bridge.bridge_dev, MODULES_SCRIPT_ID, true);
if (!md) {
fprintf(stderr, "Failed to add script module.\n");
return 1;
}
}
if (config.interface) {
//TODO: check if interface exists
if (access("/proc/net/dev", R_OK )) {
fprintf(stderr, "Couldn't open /proc/net/dev\n");
return 1;
}
md = bridge_add_module(bridge.bridge_dev, MODULES_BANDWIDTH_ID, true);
if (!md) {
fprintf(stderr, "Failed to add bandwidth module.\n");
return 1;
}
bandwidth = true;
}
if (config.serial.port) {
sd = serialport_init(config.serial.port, config.serial.baudrate);
if( sd == -1 ) {
fprintf(stderr, "Couldn't open serial port.\n");
return 1;
} else {
md = bridge_add_module(bridge.bridge_dev, MODULES_SERIAL_ID, true);
if (!md) {
fprintf(stderr, "Failed to add serial module.\n");
return 1;
}
serialport_flush(sd);
bridge.serial_ready = true;
if (config.debug) printf("Serial ready.\n");
}
}
if (config.debug > 2) bridge_print_modules(bridge.bridge_dev);
rc = mosquitto_connect(mosq, config.mqtt_host, config.mqtt_port, 60);
if (rc) {
fprintf(stderr, "ERROR: %s\n", mosquitto_strerror(rc));
return -1;
}
alarm(1);
while (run) {
if (bridge.serial_ready) {
rc = serial_in(sd, mosq, MODULES_SERIAL_ID);
if (rc == -1) {
serial_hang(mosq);
} else if (rc > 0) {
bridge.serial_alive = DEVICE_ALIVE_MAX;
}
}
if (user_signal) {
if (config.debug > 2) printf("Signal - SIGUSR: %d\n", user_signal);
signal_usr(sd, mosq);
}
rc = mosquitto_loop(mosq, 100, 1);
if (run && rc) {
if (config.debug > 2) printf("MQTT loop: %s\n", mosquitto_strerror(rc));
usleep(100000); // wait 100 msec
mosquitto_reconnect(mosq);
}
usleep(20);
if (every1s) {
every1s = false;
for (dev = bridge.dev_list; dev != NULL; dev = dev->next) {
if (dev->alive) {
dev->alive--;
if (!dev->alive) {
if (connected) {
snprintf(gbuf, GBUF_SIZE, "%d", PROTOCOL_TIMEOUT);
mqtt_publish(mosq, dev->status_topic, gbuf);
rc = mosquitto_unsubscribe(mosq, NULL, dev->config_topic);
if (rc)
fprintf(stderr, "Error: MQTT unsubscribe returned: %s\n", mosquitto_strerror(rc));
}
if (config.debug) printf("Device: %s - Timeout.\n", dev->id);
bridge_remove_device(&bridge, dev->id);
}
}
}
}
if (every30s) {
every30s = false;
if (connected) {
send_alive(mosq);
if (bandwidth) {
md = bridge_get_module(bridge.bridge_dev, MODULES_BANDWIDTH_ID);
if (md) {
snprintf(gbuf, GBUF_SIZE, "%.0f,%.0f", upspeed, downspeed);
mqtt_publish(mosq, md->topic, gbuf);
if (config.debug > 2) printf("down: %f - up: %f\n", downspeed, upspeed);
}
}
} else {
if (config.debug) printf("MQTT Offline.\n");
}
if (bridge.serial_alive) {
bridge.serial_alive--;
if (!bridge.serial_alive) {
if (config.debug > 1) printf("Serial timeout.\n");
serial_hang(mosq);
}
} else {
if (config.serial.port && !bridge.serial_ready) {
if (config.debug > 1) printf("Trying to reconnect serial port.\n");
serialport_close(sd);
sd = serialport_init(config.serial.port, config.serial.baudrate);
if( sd == -1 ) {
fprintf(stderr, "Couldn't open serial port.\n");
} else {
serialport_flush(sd);
bridge.serial_ready = true;
snprintf(gbuf, GBUF_SIZE, "%d", MODULES_SERIAL_OPEN);
mqtt_publish(mosq, md->topic, gbuf);
if (config.debug) printf("Serial reopened.\n");
}
}
}
}
}
if (bridge.serial_ready) {
serialport_close(sd);
}
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
config_cleanup(&config);
printf("Exiting..\n\n");
return 0;
}
int main(int argc, char *argv[])
{
int sd = -1;
char *conf_file = NULL;
struct mosquitto *mosq;
struct module *md;
struct device *dev;
int rc;
int i;
if (!quiet) printf("Version: %s\n", version);
signal(SIGINT, handle_signal);
signal(SIGTERM, handle_signal);
signal(SIGUSR1, handle_signal);
signal(SIGUSR2, handle_signal);
signal(SIGALRM, each_sec);
for (i=1; i<argc; i++) {
if(!strcmp(argv[i], "-c") || !strcmp(argv[i], "--config")){
if(i==argc-1){
fprintf(stderr, "Error: -c argument given but no file specified.\n\n");
print_usage(argv[0]);
return 1;
}else{
conf_file = argv[i+1];
}
i++;
}else if(!strcmp(argv[i], "--quiet")){
quiet = true;
}else{
fprintf(stderr, "Error: Unknown option '%s'.\n",argv[i]);
print_usage(argv[0]);
return 1;
}
}
if(!conf_file) {
fprintf(stderr, "Error: No config file given.\n");
return 1;
}
memset(&config, 0, sizeof(struct bridge_config));
if(config_parse(conf_file, &config)) return 1;
if (quiet) config.debug = 0;
if (config.debug != 0) printf("Debug: %d\n", config.debug);
if (!device_isValid_id(config.id)) {
fprintf(stderr, "Invalid id.\n");
return -1;
}
if (device_init(&bridge, config.id) == -1)
return 1;
mosquitto_lib_init();
mosq = mosquitto_new(config.id, true, NULL);
if(!mosq){
fprintf(stderr, "Error creating mqtt instance.\n");
switch(errno){
case ENOMEM:
fprintf(stderr, " out of memory.\n");
break;
case EINVAL:
fprintf(stderr, " invalid id.\n");
break;
}
return 1;
}
snprintf(gbuf, GBUF_SIZE, "%d", PROTO_ST_TIMEOUT);
mosquitto_will_set(mosq, bridge.status_topic, strlen(gbuf), gbuf, config.mqtt_qos, MQTT_RETAIN);
mosquitto_connect_callback_set(mosq, on_mqtt_connect);
mosquitto_disconnect_callback_set(mosq, on_mqtt_disconnect);
mosquitto_message_callback_set(mosq, on_mqtt_message);
mosquitto_user_data_set(mosq, &sd);
if (config.debug > 1) printf("Subscribe topic: %s\n", bridge.config_topic);
rc = device_add_module(&bridge, MODULE_MQTT_ID, bridge.id); //TODO: autogen id?
if (rc) {
fprintf(stderr, "Failed to add mqtt module.\n");
return 1;
}
if (config.scripts_folder) {
if (access(config.scripts_folder, R_OK )) {
fprintf(stderr, "Couldn't open scripts folder: %s\n", config.scripts_folder);
return 1;
}
rc = device_add_module(&bridge, MODULE_SCRIPT_ID, bridge.id); //TODO: autogen id?
if (rc) {
fprintf(stderr, "Failed to add script module.\n");
return 1;
}
}
if (config.interface) {
//TODO: check if interface exists
if (access("/proc/net/dev", R_OK )) {
fprintf(stderr, "Couldn't open /proc/net/dev\n");
return 1;
}
rc = device_add_module(&bridge, MODULE_BANDWIDTH_ID, bridge.id); //TODO: autogen id?
if (rc) {
fprintf(stderr, "Failed to add bandwidth module.\n");
return 1;
}
bandwidth = true;
}
if (config.serial.port) {
sd = serialport_init(config.serial.port, config.serial.baudrate);
if( sd == -1 ) {
fprintf(stderr, "Couldn't open serial port.\n");
return 1;
} else {
rc = device_add_module(&bridge, MODULE_SERIAL_ID, bridge.id); //TODO: autogen id?
if (rc) {
fprintf(stderr, "Failed to add serial module.\n");
return 1;
}
serialport_flush(sd);
bridge.serial_ready = true;
if (config.debug) printf("Serial ready.\n");
}
}
rc = device_add_module(&bridge, MODULE_SIGUSR1_ID, bridge.id); //TODO: autogen id?
if (rc) {
fprintf(stderr, "Failed to add sigusr1 module.\n");
return 1;
}
rc = device_add_module(&bridge, MODULE_SIGUSR2_ID, bridge.id); //TODO: autogen id?
if (rc) {
fprintf(stderr, "Failed to add sigusr2 module.\n");
return 1;
}
device_print_modules(&bridge);
rc = mosquitto_connect(mosq, config.mqtt_host, config.mqtt_port, 60);
if (rc) {
fprintf(stderr, "Wrong MQTT parameters. Check your config.\n");
return -1;
}
alarm(1);
while (run) {
if (bridge.serial_ready) {
rc = serial_in(sd, mosq, MODULE_SERIAL_ID);
if (rc == -1) {
serial_hang(mosq);
} else if (rc > 0) {
bridge.serial_alive = ALIVE_CNT;
}
}
if (user_signal) {
if (config.debug > 1) printf("Signal - SIGUSR: %d\n", user_signal);
signal_usr(sd, mosq);
}
rc = mosquitto_loop(mosq, -1, 1);
if (run && rc) {
if (config.debug > 2) printf("MQTT loop: %s\n", mosquitto_strerror(rc));
usleep(100000); // wait 100 msec
mosquitto_reconnect(mosq);
}
if (every30s) {
every30s = false;
bridge.controller = false;
for (i = 0; i < bridge.devices_len; i++) {
dev = &bridge.devices[i];
if (dev->alive) {
dev->alive--;
if (!dev->alive) {
snprintf(gbuf, GBUF_SIZE, "%d,%s", PROTO_ST_TIMEOUT, dev->id);
mqtt_publish(mosq, bridge.status_topic, gbuf);
if (dev->md_deps->type == MODULE_MQTT && dev->type == DEVICE_TYPE_NODE) {
snprintf(gbuf, GBUF_SIZE, "status/%s", dev->id);
rc = mosquitto_unsubscribe(mosq, NULL, gbuf);
if (rc)
fprintf(stderr, "Error: MQTT unsubscribe returned: %s\n", mosquitto_strerror(rc));
}
if (config.debug) printf("Device timeout - id: %s\n", dev->id);
} else {
if (dev->type == DEVICE_TYPE_CONTROLLER)
bridge.controller = true;
}
}
}
if (!bridge.controller)
bridge.modules_update = false;
if (connected) {
snprintf(gbuf, GBUF_SIZE, "%d,%d", PROTO_ST_ALIVE, bridge.modules_len);
mqtt_publish(mosq, bridge.status_topic, gbuf);
if (bridge.modules_update) {
snprintf(gbuf, GBUF_SIZE, "%d", PROTO_ST_MODULES_UP);
if (mqtt_publish(mosq, bridge.status_topic, gbuf))
bridge.modules_update = false;
}
if (bandwidth) {
md = device_get_module(&bridge, MODULE_BANDWIDTH_ID);
if (md) {
if (mqtt_publish_bandwidth(mosq, md->topic) == -1)
break;
}
}
} else {
if (config.debug != 0) printf("MQTT Offline.\n");
}
if (bridge.serial_alive) {
bridge.serial_alive--;
if (!bridge.serial_alive) {
if (config.debug > 1) printf("Serial timeout.\n");
serial_hang(mosq);
}
} else {
if (config.serial.port && !bridge.serial_ready) {
if (config.debug > 1) printf("Trying to reconnect serial port.\n");
serialport_close(sd);
sd = serialport_init(config.serial.port, config.serial.baudrate);
if( sd == -1 )
fprintf(stderr, "Couldn't open serial port.\n");
else {
serialport_flush(sd);
bridge.serial_ready = true;
if (config.debug) printf("Serial reopened.\n");
}
}
}
}
usleep(20);
}
if (bridge.serial_ready) {
serialport_close(sd);
}
mosquitto_destroy(mosq);
mosquitto_lib_cleanup();
config_cleanup(&config);
printf("Exiting..\n\n");
return 0;
}
