/*模块初始化*/
static int echodemo_init()
{
//char com_port[16];
//long baud=9600;
//rtdb_get_data_value_by_name("echodemo", "serialname", com_port);
//rtdb_get_data_value_by_name("echodemo", "baud", &baud);
//serial_id = serial_open(com_port, baud, SERIAL_PARITY_NO, 8, SERIAL_STOPBIT_ONE, 1000);
//打开串口，COM1，9600,无校验，8位，一个停止位，通讯超时 100
serial_id = serial_open("COM1", 9600, SERIAL_PARITY_NO, 8, SERIAL_STOPBIT_ONE, 100);
if (serial_id < 0)
{
return 0;
}
return 1;
}
int MOVETO_JOINTS(float j1, float j2, float j3, float j4, float j5, float j6) {
READ = 0;
if (!OPEN_COM) {
serial_close(hComm);
if ((hComm=serial_open(0, 1, 1)) < 0) {
cout<<"Error: cannot connect to Puma"<<endl;
return -1; }
else OPEN_COM = TRUE; }
writeBuffer("point #x\n\r");
char buffer[200];
sprintf(buffer, "%g, %g, %g, %g, %g, %g\n\r\n\r", j1, j2 ,j3, j4, j5, j6);
writeBuffer(buffer);
CheckError();
//Sleep(100);
READ = 0;
writeBuffer("do move #x\n\r");
return CheckError(); }
/*
* Class: ch_jodersky_flow_UnsafeSerial__
* Method: open
* Signature: (Ljava/lang/String;IIZI)J
*/
JNIEXPORT jlong JNICALL Java_ch_jodersky_flow_UnsafeSerial_00024_open
(JNIEnv *env, jobject instance, jstring port_name, jint baud, jint char_size, jboolean two_stop_bits, jint parity)
{
UNUSED_ARG(instance);
const char *dev = (*env)->GetStringUTFChars(env, port_name, 0);
struct serial_config* config;
int r = serial_open(dev, baud, char_size, two_stop_bits, parity, &config);
(*env)->ReleaseStringUTFChars(env, port_name, dev);
if (r < 0) {
check(env, r);
return -E_IO;
}
long jpointer = (long) config;
return (jlong) jpointer;
}
struct ols_t *OLS_Init(char *port, unsigned long speed)
{
int fd;
int ret;
struct ols_t *ols;
fd = serial_open(port);
if (fd < 0) {
fprintf(stderr, "Unable to open port '%s' \n", port);
return NULL;
}
ret = serial_setup(fd, speed);
if (ret) {
fprintf(stderr, "Unable to set serial port parameters \n");
return NULL;
}
ols = malloc(sizeof(struct ols_t));
if (ols == NULL) {
fprintf(stderr, "Error allocating memory \n");
return NULL;
}
ols->fd = fd;
ols->verbose = 0;
ols->flash = NULL;
ret = OLS_GetID(ols);
if (ret) {
fprintf(stderr, "Unable to read ID \n");
free(ols);
return NULL;
}
ret = OLS_GetFlashID(ols);
if (ret) {
fprintf(stderr, "Unable to read Flash ID \n");
free(ols);
return NULL;
}
return ols;
}
int main(void)
{
serial_open(19200, SERIAL_8N1);
ADMUX |= (1<<REFS0);
ADCSRA|=(1<<ADEN)|(1<<ADPS2)|(1<<ADPS1)|(1<<ADPS0);
pinMode(53, OUTPUT);
pinMode(13, OUTPUT);
x_init();
x_new(1, dimmer, 1);
x_new(2, setDelay, 1);
x_new(3, blinker, 1);
while (1)
{
x_delay(500);
}
}
// usage: serial <dev>
int
main(int argc, char *argv[])
{
struct sigaction act;
int r;
char buf[BUFSIZ];
if (argc < 2) {
fprintf(stderr, "usage: %s <device>\n", argv[0]);
return EXIT_FAILURE;
}
fd = serial_open(argv[1]);
act.sa_sigaction = sigint_action;
act.sa_flags = SA_SIGINFO;
if (sigaction(SIGINT, &act, NULL) < 0) {
perror("sigaction");
return EXIT_FAILURE;
}
static const char *msg = "SKINFO\r\n";
r = serial_write(fd, msg, strlen(msg));
r = serial_read(fd, buf, BUFSIZ);
printf("%s", buf);
memset(buf, 0, BUFSIZ);
static const char *msg2 = "SKTABLE 6\r\n";
r = serial_write(fd, msg2, strlen(msg2));
do {
memset(buf, 0, BUFSIZ);
r = serial_read(fd, buf, BUFSIZ);
printf("%s", buf);
} while (r > 0);
exit:
serial_close(fd);
return EXIT_SUCCESS;
}
int serialMonitor()
{
serial *s;
while(serial_open(&s, serialPort, 9600)){ //打开串口出错，2秒后重试
debug("open serial port error!\n");
sleep(2);
}
struct HCSR501 hcsr501;
while(1){
while(get_hcsr501(s,&hcsr501)){ //读取串口数据出错，1秒后重试
debug("hcsr501 error\n");
sleep(1);
}
if(0 == hcsr501.state){ //HCSR501 ：没反应
usleep(500000);
continue;
}
else if(1 == hcsr501.state){ //HCSR501:有反应
debug("检测到异常!\n");
while(get_switch(deviceId,sensorId,API_KEY,&sw)){
debug("获取开关状态出错\n");
}
if(sw.state){
debug("监控开关状态：开！\n");
//feixin_count+=MSGRepeat;
sign=1;
debug("sign=%d\n",sign);
sleep(30); //检测到异常后标记发送飞信，然后30内不再检测
}
else{
debug("监控开关状态：关！\n");
sleep(3);
}
}
}
return 0;
}
static bool serial_fpga_prepare(__maybe_unused struct thr_info *thr)
{
struct cgpu_info *serial_fpga = thr->cgpu;
struct FPGA_INFO *info = serial_fpga->device_data;
applog(LOG_DEBUG, "serial_fpga_prepare...");
if (info->device_fd == -1) {
applog(LOG_INFO, "Open Serial FPGA on %s", serial_fpga->device_path);
info->device_fd = serial_open(serial_fpga->device_path, SERIAL_IO_SPEED, SERIAL_READ_TIMEOUT, false);
if (unlikely(info->device_fd == -1)) {
applog(LOG_ERR, "Failed to open Serial FPGA on %s",
serial_fpga->device_path);
return false;
}
}
return true;
}
int main(int argc, char *argv[])
{
int serverfd = -1;
serial_control_t ttyctl;
printf("\n");
program_printf("version %s\n", VERSION);
parse_command_line(argc, argv);
forward_test_case(0);
ttyfd = serial_open(tty_name);
memset(&ttyctl, 0, sizeof(serial_control_t));
ttyctl.fd = ttyfd;
if (access(DEFAULT_TTY_CONFIG, F_OK) != 0) {
/* config file not exsit, just create it */
create_config_file(DEFAULT_TTY_CONFIG);
}
read_config_file(&ttyctl);
if (serial_setup(&ttyctl) != EXIT_SUCCESS) {
error_printf("serial_control error\n");
return EXIT_FAILURE;
}
forward_test_case(1);
if (forward_create_server(&serverfd) != 0) {
error_printf("forward_create_server error\n");
return EXIT_FAILURE;
}
if (forward_accept_client(serverfd, ttyfd) != 0) {
error_printf("forward_accept_client error\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main(void)
{
pinMode(LEDPIN,OUTPUT);
pinMode(LEDPIN2,OUTPUT);
cli();
timer1_init();
serial_open(19200, SERIAL_8N1);
init_yield_array();
//int t1 = kn_create_thread(tempHumidity);
int t2 = kn_create_thread(blink);
int t3 = kn_create_thread(blink_faster);
while(1)
{
//kn_run_thread(t1);
kn_run_thread(t2);
kn_run_thread(t3);
//init_yield_array();
// if (tot_overflow >= 10) {
// blink();
// tot_overflow = 0;
// }
// if (tot_overflow2 >= 15) {
// blink_faster();
// tot_overflow2 = 0;
// }
//kn_run_thread(t1);
//kn_run_thread(t2);
//kn_run_thread(t3);
//prints(" $$$$$$$$ ");
//_delay_ms(800);
//getTempHumidity();
//prints((uint8_t*)TOTAL_RAM_SIZE);
// char buffer[16];
// sprintf(buffer,"%d",(int)TOTAL_RAM_SIZE);
// prints(buffer);
//kn_create_thread(THREAD1, &threadB, false, NULL);
// get_temp();
// _delay_ms(800);
}
}
int serial_stdio(char *name)
{
unsigned int subdevice;
if (serial_open(name, &subdevice))
return -1;
// Nuke existing stdin, stdout, stderr
device_unregister(0);
device_unregister(1);
device_unregister(2);
// Register new stdin, stdout, stderr
device_register_char_fd(0, subdevice, NULL, serial_read, NULL, serial_rxready);
device_register_char_fd(1, subdevice, serial_write, NULL, serial_txready, NULL);
device_register_char_fd(2, subdevice, serial_write, NULL, serial_txready, NULL);
return 0;
}
static GSList *center_scan(const char *conn, const char *serialcomm, int idx)
{
int i;
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
GSList *devices;
serial = sr_serial_dev_inst_new(conn, serialcomm);
if (serial_open(serial, SERIAL_RDWR) != SR_OK)
return NULL;
drvc = center_devs[idx].di->priv;
devices = NULL;
serial_flush(serial);
sr_info("Found device on port %s.", conn);
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup(center_devs[idx].vendor);
sdi->model = g_strdup(center_devs[idx].device);
devc = g_malloc0(sizeof(struct dev_context));
sdi->inst_type = SR_INST_SERIAL;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = center_devs[idx].di;
for (i = 0; i < center_devs[idx].num_channels; i++)
sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_names[i]);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
serial_close(serial);
return devices;
}
int main(int argc, char * argv[])
{
int fd = -1;
int serial;
int ret;
/* Default device selection per platform */
#ifdef __linux__
char *device = "/dev/ttyUSB0";
#else
char *device = "/dev/cuaU0";
#endif
if (argv[1] != NULL)
device = argv[1];
else
printf ("no device specified, defaulting to %s\n", device);
serial = serial_open (device, &fd, MAK_BLOCKING, MAK_BAUD);
if (serial == -1) {
err(1, "Serial open of %s failed", device);
exit(1);
}
printf("Ready to populate MAKStripe buffer...\n");
ret = mak_successful_read(fd, MAKSTRIPE_TK_ALL);
if (ret != 0) {
printf("Unable to populate MAKStripe buffer!\n");
exit(ret);
}
printf("Ready to clone buffer onto blank card...\n");
ret = mak_successful_clone(fd);
if (ret != 0) {
printf("Unable to clone buffer onto blank card!\n");
exit(ret);
}
serial_close (fd);
exit(ret);
}
static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
struct dev_context *devc;
struct sr_config *src;
struct sr_serial_dev_inst *serial;
struct sr_dev_inst *sdi;
GSList *l;
const char *conn;
conn = NULL;
for (l = options; l; l = l->next) {
src = l->data;
if (src->key == SR_CONF_CONN)
conn = g_variant_get_string(src->data, NULL);
}
if (!conn)
return NULL;
serial = sr_serial_dev_inst_new(conn, SERIALCOMM);
if (serial_open(serial, SERIAL_RDONLY) != SR_OK)
return NULL;
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup("PCE");
sdi->model = g_strdup("PCE-322A");
devc = g_malloc0(sizeof(struct dev_context));
devc->cur_mqflags = SR_MQFLAG_SPL_TIME_WEIGHT_F | SR_MQFLAG_SPL_FREQ_WEIGHT_A;
sdi->conn = sr_serial_dev_inst_new(conn, SERIALCOMM);
sdi->inst_type = SR_INST_SERIAL;
sdi->priv = devc;
sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "SPL");
serial_close(serial);
return std_scan_complete(di, g_slist_append(NULL, sdi));
}
int
serial_posix_setup(const char *device, int baud, serial **serialobj)
{
/* open serial */
*serialobj = serial_create();
if (*serialobj == NULL) {
printf("Unable to instantiate object: serial\n");
goto fail;
}
if (serial_open(*serialobj, device) < 0) {
printf("Unable to open serial devicer\n");
goto fail;
}
if (serial_set_speed(*serialobj, baud) < 0) {
printf("Unable to set serial speedr\n");
goto fail;
}
if (serial_set_timeout(*serialobj, 10000) < 0) {
printf("Unable to set timeoutr\n");
goto fail;
}
if (serial_set_cts_flow(*serialobj, 1) < 0) {
printf("Unable to set flow controlr\n");
goto fail;
}
printf("%s is opened\n", device);
return (0);
fail:
serial_close(*serialobj);
serial_destroy(*serialobj);
return (1);
}
static int hw_dev_open(int dev_index)
{
struct sr_dev_inst *sdi;
struct context *ctx;
if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
sr_err("genericdmm: sdi was NULL.");
return SR_ERR_BUG;
}
if (!(ctx = sdi->priv)) {
sr_err("genericdmm: sdi->priv was NULL.");
return SR_ERR_BUG;
}
sr_dbg("genericdmm: Opening serial port '%s'.", ctx->serial->port);
switch (ctx->profile->transport) {
case DMM_TRANSPORT_USBHID:
/* TODO */
break;
case DMM_TRANSPORT_SERIAL:
/* TODO: O_NONBLOCK? */
ctx->serial->fd = serial_open(ctx->serial->port, O_RDWR | O_NONBLOCK);
if (ctx->serial->fd == -1) {
sr_err("genericdmm: Couldn't open serial port '%s'.",
ctx->serial->port);
return SR_ERR;
}
// serial_set_params(ctx->serial->fd, 2400, 8, 0, 1, 2);
break;
default:
sr_err("No transport set.");
}
return SR_OK;
}
int main(int argc, char **argv)
{
int rc;
int max_fd;
fd_set rfds;
int port;
if (argc != 3) {
printf("usage: %s <uart_dev> <uart_index>\n", argv[0]);
printf("exampel:\n");
printf(" uart_tgt_cfg /dev/ttyCm1Serial 2\n");
exit(0);
}
port = rmm_cfg_get_port(IPMIUARTTGTCFG_PORT);
if (libipmi_init(port) < 0)
return -1;
serial_index = atoi(argv[2]);
serial_open(argv[1]);
for (;;) {
max_fd = -1;
FD_ZERO(&rfds);
libipmi_callback_selectfds(&rfds, &max_fd);
rc = select(max_fd + 1, &rfds, NULL, NULL, NULL);
if (rc <= 0)
continue;
libipmi_callback_processfds(&rfds);
}
return 0;
}
void test_interactive(void) {
serial_t serial;
uint8_t buf[] = "Hello World";
ptest();
passert(serial_open(&serial, device, 4800) == 0);
printf("Starting interactive test. Get out your logic analyzer, buddy!\n");
printf("Press enter to continue...\n");
getc(stdin);
printf("Press enter to start transfer...");
getc(stdin);
passert(serial_write(&serial, buf, sizeof(buf)) == sizeof(buf));
printf("Serial transfer baudrate 4800, 8n1 occurred? y/n\n");
passert(getc_yes());
passert(serial_set_baudrate(&serial, 9600) == 0);
printf("Press enter to start transfer...");
getc(stdin);
passert(serial_write(&serial, buf, sizeof(buf)) == sizeof(buf));
printf("Serial transfer baudrate 9600, 8n1 occurred? y/n\n");
passert(getc_yes());
passert(serial_set_baudrate(&serial, 115200) == 0);
printf("Press enter to start transfer...");
getc(stdin);
passert(serial_write(&serial, buf, sizeof(buf)) == sizeof(buf));
printf("Serial transfer baudrate 115200, 8n1 occurred? y/n\n");
passert(getc_yes());
passert(serial_close(&serial) == 0);
}
static struct serial *
open_tty (char *name)
{
struct serial *desc;
desc = serial_open (name);
if (!desc)
perror_with_name (name);
if (baud_rate != -1)
{
if (serial_setbaudrate (desc, baud_rate))
{
serial_close (desc);
perror_with_name (name);
}
}
serial_raw (desc);
serial_flush_input (desc);
return desc;
}
int main(int argc, char **argv)
{
serial_handle_t handle = INVALID_HANDLE_VALUE;
SerialOption opt;
opt.port = COMPORT;
opt.speed = 115200;
if (serial_open(&opt, &handle)) {
esp_run_command(handle, "AT+GMR", true);
mac_address_t stmac;
esp_get_st_mac_address(handle, &stmac);
mac_address_t apmac;
esp_get_ap_mac_address(handle, &apmac);
puts("---");
puts(("ST " + to_s(stmac)).c_str());
puts(("AP " + to_s(apmac)).c_str());
serial_close(handle, &opt);
}
return 0;
}
int main(int argc, char** argv)
{
int opt;
char buffer[256] = {0}, i;
int fd;
int res,c;
int flag=0,firsttime=0;
char *param_port = NULL;
char *param_speed = NULL;
char param_test=1;
// int clock_edge;
// int polarity;
//default speed
// param_port=strdup("COM3"); //default for debugging
printf("-------------------------------------------------------\n");
printf("\n");
printf(" Bus Pirate binary mode SELF TEST utility v0.1 (CC-0)\n");
printf(" http://dangerousprototypes.com\n");
printf("\n");
printf("-------------------------------------------------------\n");
// printf("\n");
//p == port
// p=polarity
// e=clock edge
if (argc <= 1) {
printf(" Help Menu\n");
print_usage(argv[0]);
exit(-1);
}
while ((opt = getopt(argc, argv, "mRs:d:")) != -1) {
// printf("%c \n",opt);
switch (opt) {
case 'd': // device eg. com1 com12 etc
if ( param_port != NULL){
printf(" Device/PORT error!\n");
exit(-1);
}
param_port = strdup(optarg);
break;
case 's':
if (param_speed != NULL) {
printf(" Speed should be set: eg 115200 \n");
exit(-1);
}
param_speed = strdup(optarg);
break;
case 'R': //do short self test
param_test = 0;
break;
case 'm': //modem debugging for testing
modem =TRUE; // enable modem mode
break;
default:
printf(" Invalid argument %c", opt);
print_usage(argv[0]);
//exit(-1);
break;
}
}
// printf(" Press escape to exit \n");
// printf("\n");
//param_port=strdup("COM3");
//Set default if NULL
if (param_port==NULL){
printf(" No serial port set\n");
print_usage(argv[0]);
exit(-1);
}
if (param_speed==NULL)
param_speed=strdup("115200");
printf("\n Parameters used: Device = %s, Speed = %s\n\n",param_port,param_speed);
if(param_test==1){//full self-test
printf(" Full self-test, attach jumpers (+5V to VPU) and (+3.3V to ADC)\n");
}else{//short test
printf(" !!!Warning, short self-test only!!!\n Many things will NOT be tested!!!\n");
}
flag=0;
//
// Loop and repeat test as needed for manufacturing
//
//TO DO: add loop here
printf(" Press Esc to exit, any other key to start the self-test \n\n");
while(1){
//pause for space, or ESC to exit
if (flag==1)
{
printf("\n--------------------- Starting a new Test-------------------------\n");
}
while(1){
Sleep(1);
if (flag==1){
flag=0; //has flag been set to just go testing?
break; // proceed with test
}
if(kbhit()){
c = getch();
if(c == 27){
printf("\n Esc key hit, stopping...\n");
printf(" (Bye for now!)\n");
exit(-1);
}else {//make space only
printf("\n Starting test! \n");
break;
}
}
}
//
// Open serial port
//
printf(" Opening Bus Pirate on %s at %sbps...\n", param_port, param_speed);
fd = serial_open(param_port);
if (fd < 0) {
fprintf(stderr, " Error opening serial port\n");
return -1;
}
//
// Enter binary mode, then enter a protocol mode
//
serial_setup(fd,(speed_t) param_speed);
if (modem==TRUE){ // connected to modem for testing response {
serial_write( fd, "ATI3\x0D\0",5 );
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf("\n %s\n",buffer);
serial_write( fd, "ATI4\x0D\0",5 );
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf("\n %s\n",buffer);
serial_write( fd, "ATI7\x0D\0",5 );
Sleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf("\n %s\n",buffer);
}
else
{
fprintf(stderr, " Configuring Bus Pirate...\n");
//BP_EnableMode(fd, SPI); //enter BBIO then SPI
if(BP_EnableBinary(fd)!=BBIO){
fprintf(stderr, " Buspirate cannot switch to binary mode :( \n");
return -1;
}
//
//Start self-test
//
printf(" Starting self-test...\n");
if(param_test==1){//full self-test
serial_write( fd, "\x11", 1);
}else{//short test
serial_write( fd, "\x10", 1);
}
//
// Done with setup
//
}
printf(" Getting self-test result...\n");
Sleep(1000); // how long to wait to get response?
res = serial_read(fd, &i, 1); //get number of errors...
if(i>0){
printf("\n %u ERRORS!!! WARNING!!! :(\n\n", (uint8_t)i);
printf(" MODE LED should be on!!!\n ");
}else{
printf("\n Self-test passed :)\n\n");
printf(" MODE LED should blink!!!\n");
}
// pause after the result
if (firsttime==0){ // run here once and don't say again the next time
printf(" Press any key to continue...\n");
firsttime=1;
while(1){
Sleep(1);
if(kbhit()){
c = getch();
break;
}
}
}
buffer[0]=0xFF;//exit self-test
buffer[1]=0x0f;//exit BBIO
res = serial_write( fd, buffer, 2);
//close port so they can attach the next Bus Pirate
serial_close(fd);
//TODO: Loop back to pause after this
printf("\n Connect another Bus Pirate and press any key to start the self-test again \n");
printf(" Or hit ESC key to stop and end the test.\n");
while(1){
Sleep(1);
if(kbhit()){
c = getch();
if(c == 27){
printf("\n Esc key hit, stopping...\n");
printf(" (Bye for now!)\n");
exit(-1);
}else {//make space only
flag=1; //flag to tell the other loop to bypass another keypress
break;
}
}
}
}
#define FREE(x) if(x) free(x);
FREE(param_port);
FREE(param_speed);
return 0;
}
int main (int argc, char* argv[])
{
int i;
int k;
int discover_iter;
int play_iter;
int num_ports = argc - 1;
int serial_fd[num_ports];
beacons_table_t beacons_table;
beacons_table = create_beacons_table();
packet_t packet_to_send;
enum state_t {DISCOVER, PLAY} state;
//-- Check if the serial device name is given
if (argc<2) {
printf ("No serial device name is given\n");
exit(0);
}
for(i = 0; i < num_ports; i++ )
{
//-- Open the serial port
serial_fd[i]=serial_open(argv[i+1],B9600);
//-- Error checking
if (serial_fd[i]==-1) {
printf ("Error opening the serial device: %s\n",argv[i+1]);
perror("OPEN");
exit(0);
}
}
/* -------------------------------------------------------------------- */
//-- Execute the main loop
state = DISCOVER;
while(1)
{
switch(state)
{
case DISCOVER:
//Build the NEW_GAME_REQUEST packet
packet_to_send.packet_id = PCK_HEADER;
packet_to_send.destination = AllNodesID;
packet_to_send.source = NodoCentralID;
packet_to_send.number = 0x001; //No necessary in this implementation
packet_to_send.length = 0x0000;
packet_to_send.packet_type = NEW_GAME_REQUEST;
packet_to_send.reserved = 0x0000;
//It's no necessary to define "data", it'll be ignored
for(k = 0; k < num_ports; k++ ) //Send a packet for each port
{
send_packet(serial_fd[k], packet_to_send);
}
/*
It's necessary to wait for the response and parse it.
In each "parse" command waits for receive one character during
TIMEOUT us (in this case 1ms). Thus, in order to wait 2 sec. aprox
for a response, the number of iterations are 2000ms/ (1ms X num_ports)
*/
for(i = 0; i <= (2000 / num_ports); i++)
{
for(k = 0; k < num_ports; k++ )
{
parse_received(serial_fd[k],&beacons_table);
}
}
////SEND PACKET AGAIN
for(k = 0; k < num_ports; k++ ) //Send a packet for each port
{
send_packet(serial_fd[k], packet_to_send);
}
/*
It's necessary to wait for the response and parse it.
In each "parse" command waits for receive one character during
TIMEOUT us (in this case 1ms). Thus, in order to wait 2 sec. aprox
for a response, the number of iterations are 2000ms/ (1ms X num_ports)
*/
for(i = 0; i <= (2000 / num_ports); i++)
{
for(k = 0; k < num_ports; k++ )
{
parse_received(serial_fd[k],&beacons_table);
}
}
print_beacon_table(beacons_table);
state = PLAY;
break;
case PLAY:
/*
It's necessary to wait for the response and parse it. The table with
the beacons and drones is being printed every 1 sec. In the same way,
in each "parse" command waits for receive one character during
TIMEOUT us (in this case 1ms). Thus, in order to wait 1 sec. aprox,
the number of iterations are 1000ms/ (1ms X num_ports)
*/
for(i = 0; i <= (1000 / num_ports); i++)
{
for(k = 0; k < num_ports; k++ )
{
parse_received(serial_fd[k],&beacons_table);
}
}
print_beacon_table(beacons_table);
state = PLAY;
break;
default:
state = DISCOVER;
break;
}
}
/* -------------------------------------------------------------------- */
for(i = 0; i < num_ports; i++ )
{
//-- Close the serial port
serial_close(serial_fd[i]);
}
return 0;
}
int main(int argc, char** argv)
{
int opt;
char buffer[256] = {0}, i;
int fd;
int res,c;
int new_state,state=0;
char *param_port = NULL;
char *param_speed = NULL;
char *param_polarity=NULL;
char *param_clockedge=NULL;
char *param_rawdata=NULL;
// int clock_edge;
// int polarity;
//default speed
// param_port=strdup("COM3"); //default for debugging
printf("-------------------------------------------------------\n");
printf("\n");
printf(" Bus Pirate binary mode SPI SNIFFER utility v0.2 (CC-0)\n");
printf(" http://dangerousprototypes.com\n");
printf("\n");
printf("-------------------------------------------------------\n");
printf("\n\n\n");
//p == port
// p=polarity
// e=clock edge
if (argc <= 1) {
printf("ERROR: Invalid argument(s).\n\n");
printf("Help Menu\n");
print_usage(argv[0]);
exit(-1);
}
while ((opt = getopt(argc, argv, "ms:p:e:d:r:")) != -1) {
// printf("%c \n",opt);
switch (opt) {
case 'd': // device eg. com1 com12 etc
if ( param_port != NULL){
printf("Device/PORT error!\n");
exit(-1);
}
param_port = strdup(optarg);
break;
case 'e': // clock edge
if (param_clockedge != NULL) {
printf("Clock Edge should be 0 or 1\n");
exit(-1);
}
param_clockedge = strdup(optarg);
break;
case 'p':
if (param_polarity != NULL) {
printf("Polarity must be 0 or 1\n");
exit(-1);
}
param_polarity = strdup(optarg);
break;
case 's':
if (param_speed != NULL) {
printf("Speed should be set: eg 115200 \n");
exit(-1);
}
param_speed = strdup(optarg);
break;
case 'r': // raw data
if (param_rawdata != NULL) {
printf("Raw Data should be 0 or 1\n");
exit(-1);
}
param_rawdata = strdup(optarg);
break;
case 'm': //modem debugging for testing
modem =TRUE; // enable modem mode
break;
default:
printf("Invalid argument %c", opt);
print_usage(argv[0]);
//exit(-1);
break;
}
}
printf(" Press escape to exit \n");
printf("\n");
//param_port=strdup("COM3");
//Set default if NULL
if (param_port==NULL){
printf("No serial port set\n");
print_usage(argv[0]);
exit(-1);
}
if (param_clockedge==NULL)
param_clockedge=strdup("1");
if (param_polarity==NULL)
param_polarity=strdup("0");
if (param_speed==NULL)
param_speed=strdup("115200");
if (param_rawdata==NULL)
param_rawdata=strdup("0");
printf("\n Parameters used: Device = %s, Speed = %s, Clock Edge= %s, Polarity= %s\n\n",param_port,param_speed,param_clockedge,param_polarity);
//
// Open serial port
//
printf(" Opening Bus Pirate on %s at %sbps...\n", param_port, param_speed);
fd = serial_open(param_port);
if (fd < 0) {
fprintf(stderr, "Error opening serial port\n");
return -1;
}
//
// Enter binary mode, then enter a protocol mode
//
serial_setup(fd,(speed_t) atoi(param_speed));
printf(" Starting SPI sniffer...\n");
if (modem==TRUE){ // connected to modem for testing response {
serial_write( fd, "ATI3\x0D\0",5 );
usleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf("\n %s\n",buffer);
serial_write( fd, "ATI4\x0D\0",5 );
usleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf("\n %s\n",buffer);
serial_write( fd, "ATI7\x0D\0",5 );
usleep(1);
res= serial_read(fd, buffer, sizeof(buffer));
printf("\n %s\n",buffer);
}
else
{
fprintf(stderr, " Configuring Bus Pirate...\n");
BP_EnableMode(fd, SPI); //enter BBIO then SPI
//
//Start sniffer
//
//configure according to user settings
//1000wxyz - SPI config, w=HiZ/3.3v, x=CKP idle, y=CKE edge, z=SMP sample
i=0x80;
if(strncmp(param_clockedge, "1", 1)==0)
i|=0x02;
if(strncmp(param_polarity, "1", 1)==0)
i|=0x04;
BP_WriteToPirate(fd, &i);
//start the sniffer
serial_write( fd, "\x0E", 1);
//
// Done with setup
//
}
printf(" (OK) Happy sniffing! Press ESC to stop.\n");
//
// Loop and print input from the serial port
//
while(1){
usleep(1);
res= serial_read(fd, buffer, 100);
if(res>0){
for(c=0; c<res; c++){
if(strncmp(param_rawdata, "1", 1)==0) printf("%02X ", (uint8_t)buffer[c]);
else {
switch(state) {
default:
case 0: // waiting CS active
if (buffer[c]==0x5B) {
printf("[");
new_state=1;
} else {
printf("Sync\n");
new_state=0;
}
break;
case 1: // check for data or CS inactive
if (buffer[c]==0x5C) {
new_state=2;
} else if (buffer[c]==0x5D) {
printf("]\n");
new_state=0;
} else {
printf("Sync\n");
new_state=0;
}
break;
case 2: // MPI
printf("0x%02X(", (uint8_t) buffer[c]);
new_state=3;
break;
case 3: // MPO
printf("0x%02X)", (uint8_t) buffer[c]);
new_state=1;
break;
}
state=new_state;
}
}
}
#ifdef WIN32
if(kbhit()){
c = getch();
if(c == 27){
printf("\n Esc key hit, stopping...\n");
printf(" Clean up Bus Pirate...\n");
buffer[0]=0x00;//exit sniffer
buffer[1]=0x00;//exit spi
buffer[2]=0x0f;//exit BBIO
res = serial_write( fd, buffer, 3);
printf(" (Bye for now!)\n");
break;
}
}
#endif
} //hit enter to stop
#define FREE(x) if(x) free(x);
FREE(param_port);
FREE(param_speed);
return 0;
}
int do_serial_comms(const char *ttyfile, const char *baudrate, struct record *root)
{
int fd;
int len;
speed_t speed;
uint8_t *ptr;
struct record *rec;
const uint8_t BACKSPACE[] = {0x08};
const uint8_t ERASE_ALL[] = {0x00};
const uint8_t ACK = 0x06;
ptr = io_buffer;
if (baudrate_to_speed_t(baudrate, &speed)) {
fprintf(stderr, "unsupported baudrate, %s\n", baudrate);
return -1;
}
fd = serial_open(ttyfile, speed);
if (fd < 0) {
fprintf(stderr, "error opening serial port\n");
return -1;
}
fprintf(stdout, "Putting card into download mode.\n");
//Set PROG and reset
set_dtr(fd, true);
set_rts(fd, true);
sleep(1);
fprintf(stdout, "Trying to synchronize with ADuC70xx: ");
fflush(stdout);
while (serial_read_fully(fd, ptr, 1, 100));
set_rts(fd, false);
do {
len = serial_write_fully(fd, BACKSPACE, sizeof(BACKSPACE), 1000);
len = serial_read_fully(fd, ptr, 24, 100);
} while (!((len > 6) && (memcmp(ptr, "ADuC70", 6) == 0)));
//Disable PROG
set_dtr(fd, false);
while (serial_read_fully(fd, ptr, 1, 100));
if ((len > 6) && (memcmp(ptr, "ADuC70", 6) == 0)) {
int product_len = (memchr(ptr, ' ', 24) - (void *)ptr);
fprintf(stdout, "Found %.*s\n", product_len, ptr);
fprintf(stdout, "Erasing: ");
fflush(stdout);
len = fill_packet(ptr, 'E', 0x00000000, ERASE_ALL, sizeof(ERASE_ALL));
len = serial_write_fully(fd, ptr, len, 1000);
len = serial_read_fully(fd, ptr, 1, 10000);
if ((len <= 0) || (ptr[0] != ACK)) {
fprintf(stdout, "FAILED\n");
goto error;
}
fprintf(stdout, "OK\n");
rec = root;
while (rec != NULL) {
int count = 0;
uint32_t address = rec->address;
uint8_t *data = data_buffer;
struct record *drec;
for (drec = rec; ((drec != NULL) && ((address + count) == drec->address) && ((count + drec->count) < DATA_BUFFER_SIZE)); drec = drec->next) {
memcpy(data, drec->data, drec->count);
data += drec->count;
count += drec->count;
}
rec = drec;
fprintf(stdout, "Writting (%#x): ", address);
fflush(stdout);
len = fill_packet(ptr, 'W', address, data_buffer, count);
len = serial_write_fully(fd, ptr, len, 1000);
len = serial_read_fully(fd, ptr, 1, 10000);
if ((len <= 0) || (ptr[0] != ACK)) {
fprintf(stdout, "FAILED\n");
goto error;
}
fprintf(stdout, "OK\n");
}
if (reset) {
fprintf(stdout, "Resetting: ");
fflush(stdout);
len = fill_packet(ptr, 'R', 0x00000001, NULL, 0);
len = serial_write_fully(fd, ptr, len, 1000);
len = serial_read_fully(fd, ptr, 1, 10000);
if ((len <= 0) || (ptr[0] != ACK)) {
fprintf(stdout, "FAILED\n");
goto error;
}
fprintf(stdout, "OK\n");
}
} else {
fprintf(stdout, "FAILED\n");
goto error;
}
if (follow) {
int count = 600;
while (count--) {
len = serial_read(fd, ptr, 16, 1000);
if (len > 0) {
dump_text(stdout, ptr, len);
}
}
}
error:
if (serial_close(fd) < 0) {
fprintf(stderr, "error closing serial port\n");
return -1;
}
return 0;
}
int main(int argc, char *argv[])
{
struct server *server1;
struct server *server2;
struct server *server3;
struct server *server4;
struct server *server5;
bool server_enabled = false;
bool serial_enabled = false;
int letest_count = 0;
int amptest_count = 0;
int vhci_count = 0;
enum vhci_type vhci_type = VHCI_TYPE_BREDRLE;
sigset_t mask;
int i;
mainloop_init();
for (;;) {
int opt;
opt = getopt_long(argc, argv, "Ssl::LBAUTvh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'S':
serial_enabled = true;
break;
case 's':
server_enabled = true;
break;
case 'l':
if (optarg)
vhci_count = atoi(optarg);
else
vhci_count = 1;
break;
case 'L':
vhci_type = VHCI_TYPE_LE;
break;
case 'B':
vhci_type = VHCI_TYPE_BREDR;
break;
case 'A':
vhci_type = VHCI_TYPE_AMP;
break;
case 'U':
if (optarg)
letest_count = atoi(optarg);
else
letest_count = 1;
break;
case 'T':
if (optarg)
amptest_count = atoi(optarg);
else
amptest_count = 1;
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (letest_count < 1 && amptest_count < 1 &&
vhci_count < 1 && !server_enabled && !serial_enabled) {
fprintf(stderr, "No emulator specified\n");
return EXIT_FAILURE;
}
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Bluetooth emulator ver %s\n", VERSION);
for (i = 0; i < letest_count; i++) {
struct bt_le *le;
le = bt_le_new();
if (!le) {
fprintf(stderr, "Failed to create LE controller\n");
return EXIT_FAILURE;
}
}
for (i = 0; i < amptest_count; i++) {
struct bt_amp *amp;
amp = bt_amp_new();
if (!amp) {
fprintf(stderr, "Failed to create AMP controller\n");
return EXIT_FAILURE;
}
}
for (i = 0; i < vhci_count; i++) {
struct vhci *vhci;
vhci = vhci_open(vhci_type);
if (!vhci) {
fprintf(stderr, "Failed to open Virtual HCI device\n");
return EXIT_FAILURE;
}
}
if (serial_enabled) {
struct serial *serial;
serial = serial_open(SERIAL_TYPE_BREDRLE);
if (!serial)
fprintf(stderr, "Failed to open serial emulation\n");
}
if (server_enabled) {
server1 = server_open_unix(SERVER_TYPE_BREDRLE,
"/tmp/bt-server-bredrle");
if (!server1)
fprintf(stderr, "Failed to open BR/EDR/LE server\n");
server2 = server_open_unix(SERVER_TYPE_BREDR,
"/tmp/bt-server-bredr");
if (!server2)
fprintf(stderr, "Failed to open BR/EDR server\n");
server3 = server_open_unix(SERVER_TYPE_AMP,
"/tmp/bt-server-amp");
if (!server3)
fprintf(stderr, "Failed to open AMP server\n");
server4 = server_open_unix(SERVER_TYPE_LE,
"/tmp/bt-server-le");
if (!server4)
fprintf(stderr, "Failed to open LE server\n");
server5 = server_open_unix(SERVER_TYPE_MONITOR,
"/tmp/bt-server-mon");
if (!server5)
fprintf(stderr, "Failed to open monitor server\n");
}
return mainloop_run();
}
static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_config *src;
struct sr_serial_dev_inst *serial;
struct sr_channel_group *cg;
struct sr_channel *ch;
GSList *l;
int ret, len;
const char *conn, *serialcomm;
char buf[100];
char *bufptr;
double version;
conn = serialcomm = NULL;
for (l = options; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_CONN:
conn = g_variant_get_string(src->data, NULL);
break;
case SR_CONF_SERIALCOMM:
serialcomm = g_variant_get_string(src->data, NULL);
break;
}
}
if (!conn)
return NULL;
if (!serialcomm)
serialcomm = SERIALCOMM;
serial = sr_serial_dev_inst_new(conn, serialcomm);
if (serial_open(serial, SERIAL_RDWR) != SR_OK)
return NULL;
serial_flush(serial);
if (serial_write_blocking(serial, CMD_VERSION,
strlen(CMD_VERSION), serial_timeout(serial,
strlen(CMD_VERSION))) < (int)strlen(CMD_VERSION)) {
sr_dbg("Unable to write while probing for hardware.");
serial_close(serial);
return NULL;
}
memset(buf, 0, sizeof(buf));
bufptr = buf;
len = sizeof(buf);
ret = serial_readline(serial, &bufptr, &len, 3000);
if (ret < 0 || len < 9 || strncmp((const char *)&buf, "version ", 8)) {
sr_dbg("Unable to probe version number.");
serial_close(serial);
return NULL;
}
version = g_ascii_strtod(buf + 8, NULL);
if (version < 1.10) {
sr_info("Firmware >= 1.10 required (got %1.2f).", version);
serial_close(serial);
return NULL;
}
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup("Arachnid Labs");
sdi->model = g_strdup("Re:load Pro");
sdi->version = g_strdup(buf + 8);
sdi->inst_type = SR_INST_SERIAL;
sdi->conn = serial;
cg = g_malloc0(sizeof(struct sr_channel_group));
cg->name = g_strdup("1");
sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
ch = sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "V");
cg->channels = g_slist_append(cg->channels, ch);
ch = sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "I");
cg->channels = g_slist_append(cg->channels, ch);
devc = g_malloc0(sizeof(struct dev_context));
sr_sw_limits_init(&devc->limits);
sdi->priv = devc;
serial_close(serial);
return std_scan_complete(di, g_slist_append(NULL, sdi));
}
static GSList *scan(GSList *options)
{
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
struct sr_serial_dev_inst *serial;
struct sr_dev_inst *sdi;
struct sr_channel *ch;
GSList *l, *devices;
gint64 start;
const char *conn;
unsigned char c;
conn = NULL;
for (l = options; l; l = l->next) {
src = l->data;
if (src->key == SR_CONF_CONN)
conn = g_variant_get_string(src->data, NULL);
}
if (!conn)
return NULL;
if (!(serial = sr_serial_dev_inst_new(conn, SERIALCOMM)))
return NULL;
if (serial_open(serial, SERIAL_RDONLY | SERIAL_NONBLOCK) != SR_OK)
return NULL;
devices = NULL;
drvc = di->priv;
start = g_get_monotonic_time();
while (g_get_monotonic_time() - start < MAX_SCAN_TIME) {
if (serial_read(serial, &c, 1) == 1 && c == 0xa5) {
/* Found one. */
if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "CEM",
"DT-885x", NULL)))
return NULL;
if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
sr_dbg("Device context malloc failed.");
return NULL;
}
devc->cur_mqflags = 0;
devc->recording = -1;
devc->cur_meas_range = 0;
devc->cur_data_source = DATA_SOURCE_LIVE;
devc->enable_data_source_memory = FALSE;
if (!(sdi->conn = sr_serial_dev_inst_new(conn, SERIALCOMM)))
return NULL;
sdi->inst_type = SR_INST_SERIAL;
sdi->priv = devc;
sdi->driver = di;
if (!(ch = sr_channel_new(0, SR_CHANNEL_ANALOG, TRUE, "SPL")))
return NULL;
sdi->channels = g_slist_append(sdi->channels, ch);
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
break;
}
/* It takes about 1ms for a byte to come in. */
g_usleep(1000);
}
serial_close(serial);
return devices;
}
struct Image*
jd11_get_picture(int picnum,int thumbnail) {
struct Image *image;
int nrofpics;
int h,fd;
unsigned char *indexbuf,*uncomp[3],**imagebufs;
int sizes[3];
char *s;
if (picnum==0) {
fprintf(stderr,"jd11_get_picture: picnum 0???\n");
assert(picnum);
}
picnum--;
fd=serial_open(serial_port);
if (fd==-1) {
return NULL;
}
nrofpics = serial_index_reader(fd,&indexbuf);
if (!nrofpics || (picnum>nrofpics)) {
return NULL;
}
image = (struct Image*)malloc(sizeof(struct Image));
memset(image,0,sizeof(*image));
if (thumbnail) {
int ind;
image->image = malloc(1*64*48*5+200); /* guessing imagesize */
strcpy(image->image,"P2\n64 48\n255\n");
s=image->image+strlen(image->image);
ind = picnum*64*48;
for (h=48;h--;) { /* upside down */
int w;
for (w=64;w--;) { /* and right to left */
sprintf(s,"%d ",indexbuf[ind+(h*64)+w]);s+=strlen(s);
if ((w&0xf)==0xf)
*s++='\n';
}
}
*s++='\0';
image->image_size = strlen(image->image);
strcpy(image->image_type,"ppm");
free(indexbuf);
return image;
}
free(indexbuf);
serial_image_reader(fd,picnum,&imagebufs,sizes);
uncomp[0] = malloc(320*480);
uncomp[1] = malloc(320*480/2);
uncomp[2] = malloc(320*480/2);
if (sizes[0]!=115200) {
picture_decomp_v1(imagebufs[0],uncomp[0],320,480);
picture_decomp_v1(imagebufs[1],uncomp[1],320,480/2);
picture_decomp_v1(imagebufs[2],uncomp[2],320,480/2);
} else {
picture_decomp_v2(imagebufs[0],uncomp[0],320,480);
picture_decomp_v2(imagebufs[1],uncomp[1],320,480/2);
picture_decomp_v2(imagebufs[2],uncomp[2],320,480/2);
}
image->image = malloc(1*640*480*3+200); /* guessing imagesize */
strcpy(image->image,"P6\n640 480\n255\n");
s=image->image+strlen(image->image);
image->image_size = strlen(image->image)+640*480*3;
for (h=480;h--;) { /* upside down */
int w;
for (w=640;w--;) { /* right to left */
/* and images are in green red blue */
*s++=uncomp[1][(h/2)*320+(w/2)];
*s++=uncomp[0][h*320+(w/2)];
*s++=uncomp[2][(h/2)*320+(w/2)];
}
}
free(uncomp[0]);free(uncomp[1]);free(uncomp[2]);
free(imagebufs[0]);free(imagebufs[1]);free(imagebufs[2]);free(imagebufs);
strcpy(image->image_type,"ppm");
serial_close(fd);
return image;
}
static GSList *scan(GSList *options, int modelid)
{
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
struct sr_config *src;
struct sr_channel *ch;
struct sr_channel_group *cg;
struct sr_serial_dev_inst *serial;
GSList *l, *devices;
struct pps_model *model;
uint8_t packet[PACKET_SIZE];
unsigned int i;
int ret;
const char *conn, *serialcomm;
char channel[10];
devices = NULL;
drvc = di->priv;
drvc->instances = NULL;
conn = serialcomm = NULL;
for (l = options; l; l = l->next) {
src = l->data;
switch (src->key) {
case SR_CONF_CONN:
conn = g_variant_get_string(src->data, NULL);
break;
case SR_CONF_SERIALCOMM:
serialcomm = g_variant_get_string(src->data, NULL);
break;
}
}
if (!conn)
return NULL;
if (!serialcomm)
serialcomm = SERIALCOMM;
if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
return NULL;
if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
return NULL;
serial_flush(serial);
/* This is how the vendor software channels for hardware. */
memset(packet, 0, PACKET_SIZE);
packet[0] = 0xaa;
packet[1] = 0xaa;
if (serial_write(serial, packet, PACKET_SIZE) == -1) {
sr_err("Unable to write while probing for hardware: %s",
strerror(errno));
return NULL;
}
/* The device responds with a 24-byte packet when it receives a packet.
* At 9600 baud, 300ms is long enough for it to have arrived. */
g_usleep(300 * 1000);
memset(packet, 0, PACKET_SIZE);
if ((ret = serial_read_nonblocking(serial, packet, PACKET_SIZE)) < 0) {
sr_err("Unable to read while probing for hardware: %s",
strerror(errno));
return NULL;
}
if (ret != PACKET_SIZE || packet[0] != 0xaa || packet[1] != 0xaa) {
/* Doesn't look like an Atten PPS. */
return NULL;
}
model = NULL;
for (i = 0; i < ARRAY_SIZE(models); i++) {
if (models[i].modelid == modelid) {
model = &models[i];
break;
}
}
if (!model) {
sr_err("Unknown modelid %d", modelid);
return NULL;
}
sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Atten", model->name, NULL);
sdi->driver = di;
sdi->inst_type = SR_INST_SERIAL;
sdi->conn = serial;
for (i = 0; i < MAX_CHANNELS; i++) {
snprintf(channel, 10, "CH%d", i + 1);
ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE, channel);
sdi->channels = g_slist_append(sdi->channels, ch);
cg = g_malloc(sizeof(struct sr_channel_group));
cg->name = g_strdup(channel);
cg->channels = g_slist_append(NULL, ch);
cg->priv = NULL;
sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
}
devc = g_malloc0(sizeof(struct dev_context));
devc->model = model;
devc->config = g_malloc0(sizeof(struct per_channel_config) * model->num_channels);
sdi->priv = devc;
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
serial_close(serial);
if (!devices)
sr_serial_dev_inst_free(serial);
return devices;
}
int _main(void)
{
THROW_BEGIN()
/* init scl and get sockets:: */
THROW_ON_ERR(scl_init("arduino"));
void *rc_socket = scl_get_socket("rc_raw");
THROW_IF(rc_socket == NULL, -ENODEV);
void *power_socket = scl_get_socket("power");
THROW_IF(power_socket == NULL, -ENODEV);
/* allocate msgpack buffers: */
msgpack_sbuffer *msgpack_buf = msgpack_sbuffer_new();
THROW_IF(msgpack_buf == NULL, -ENOMEM);
msgpack_packer *pk = msgpack_packer_new(msgpack_buf, msgpack_sbuffer_write);
THROW_IF(pk == NULL, -ENOMEM);
/* fetch parameters: */
char *dev_path;
tsint_t dev_speed;
opcd_params_init("exynos_quad.arduino_serial.", 0);
opcd_param_t params[] =
{
{"path", &dev_path},
{"speed", &dev_speed},
OPCD_PARAMS_END
};
opcd_params_apply("", params);
/* opern serial port: */
serialport_t port;
THROW_ON_ERR(serial_open(&port, dev_path, tsint_get(&dev_speed), O_RDONLY));
uint16_t channels_raw[PPM_CHAN_MAX];
uint32_t voltage_raw, current_raw;
float channels[PPM_CHAN_MAX];
while (running)
{
int c = serial_read_char(&port);
if (c < 0)
msleep(1);
/* parse channels: */
int status = ppm_parse_frame(channels_raw, (uint8_t)(c));
if (status)
{
int sig_valid = 0;
int invalid_count = 0;
FOR_N(i, PPM_CHAN_MAX)
{
uint16_t chan_in = channels_raw[i];
if (chan_in >= PPM_VALUE_INVALID)
invalid_count++;
if (chan_in > PPM_VALUE_MAX)
chan_in = PPM_VALUE_MAX;
if (chan_in < PPM_VALUE_MIN)
chan_in = PPM_VALUE_MIN;
channels[i] = (float)(chan_in - PPM_VALUE_MIN) / (PPM_VALUE_MAX - PPM_VALUE_MIN) * 2.f - 1.f;
}
sig_valid = (invalid_count < (PPM_CHAN_MAX / 3));
/* send channels: */
msgpack_sbuffer_clear(msgpack_buf);
msgpack_pack_array(pk, 1 + PPM_CHAN_MAX);
PACKI(sig_valid); /* index 0: valid */
PACKFV(channels, PPM_CHAN_MAX); /* index 1, .. : channels */
scl_copy_send_dynamic(rc_socket, msgpack_buf->data, msgpack_buf->size);
}
/* parse adc voltage/current: */
status = power_parse_frame(&voltage_raw, ¤t_raw, (uint8_t)(c));
if (status)
{
float voltage = (float)(voltage_raw) / 1000.0;
float current = (float)(current_raw) / 1000.0;
/* send voltage / current: */
msgpack_sbuffer_clear(msgpack_buf);
msgpack_pack_array(pk, 2);
PACKF(voltage); /* index 0 */
PACKF(current); /* index 1 */
scl_copy_send_dynamic(power_socket, msgpack_buf->data, msgpack_buf->size);
}
}
