int main(void) {
board_init(BOARD_MODE_RUN);
board_console_init(BOARD_DEBUG_BAUD);
SysTick_Config(BOARD_SYSTICK_100MS / 10);
// Initialize modem
modem_init();
if (!modem_enable()) error("modem enable");
if (!modem_register(60000)) error("network register");
if (!modem_gprs_attach(CELL_APN, CELL_USER, CELL_PWD, 30000)) error("GPRS attach");
double lat = 0.0, lon = 0.0;
rtc_datetime_t date;
modem_location(&lat, &lon, &date, 30000);
PRINTF("%04hd-%02hd-%02hd %02hd:%02hd:%02hd\r\n",
date.year, date.month, date.day, date.hour, date.minute, date.second);
PRINTF("Location: lat=%f, lon=%f\r\n", lat, lon);
if (!modem_tcp_connect("api.ubirch.com", 80, 5000)) error("TCP connect");
const char *send_data = "GET / HTTP/1.1\r\n\r\n";
if (!modem_tcp_send((const uint8_t *) send_data, (uint8_t) strlen(send_data), 30000))
error("simulated HTTP GET");
uint8_t buffer[8192];
size_t received = modem_tcp_receive(buffer, 1500, 10000);
PRINTF("received %d bytes\r\n", received);
dbg_dump("RCV", buffer, received);
modem_tcp_close(1000);
modem_disable();
while (true) {
delay(1000);
}
}
LONG WINAPI bad_exception(struct _EXCEPTION_POINTERS* ExceptionInfo) {
dbg_dump(ExceptionInfo);
ExitProcess(0);
}
static void atp_complete(struct urb* urb)
{
int x, y, x_z, y_z, x_f, y_f;
int retval, i, j;
int key;
struct atp *dev = urb->context;
switch (urb->status) {
case 0:
/* success */
break;
case -EOVERFLOW:
if(!dev->overflowwarn) {
printk(KERN_WARNING "appletouch: OVERFLOW with data "
"length %d, actual length is %d\n",
dev->datalen, dev->urb->actual_length);
dev->overflowwarn = 1;
}
case -ECONNRESET:
case -ENOENT:
case -ESHUTDOWN:
/* This urb is terminated, clean up */
dbg("%s - urb shutting down with status: %d",
__FUNCTION__, urb->status);
return;
default:
dbg("%s - nonzero urb status received: %d",
__FUNCTION__, urb->status);
goto exit;
}
/* drop incomplete datasets */
if (dev->urb->actual_length != dev->datalen) {
dprintk("appletouch: incomplete data package"
" (first byte: %d, length: %d).\n",
dev->data[0], dev->urb->actual_length);
goto exit;
}
/* reorder the sensors values */
if (atp_is_geyser_3(dev)) {
memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
/*
* The values are laid out like this:
* -, Y1, Y2, -, Y3, Y4, -, ..., -, X1, X2, -, X3, X4, ...
* '-' is an unused value.
*/
/* read X values */
for (i = 0, j = 19; i < 20; i += 2, j += 3) {
dev->xy_cur[i] = dev->data[j + 1];
dev->xy_cur[i + 1] = dev->data[j + 2];
}
/* read Y values */
for (i = 0, j = 1; i < 9; i += 2, j += 3) {
dev->xy_cur[ATP_XSENSORS + i] = dev->data[j + 1];
dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 2];
}
} else if (atp_is_geyser_2(dev)) {
memset(dev->xy_cur, 0, sizeof(dev->xy_cur));
/*
* The values are laid out like this:
* Y1, Y2, -, Y3, Y4, -, ..., X1, X2, -, X3, X4, -, ...
* '-' is an unused value.
*/
/* read X values */
for (i = 0, j = 19; i < 20; i += 2, j += 3) {
dev->xy_cur[i] = dev->data[j];
dev->xy_cur[i + 1] = dev->data[j + 1];
}
/* read Y values */
for (i = 0, j = 1; i < 9; i += 2, j += 3) {
dev->xy_cur[ATP_XSENSORS + i] = dev->data[j];
dev->xy_cur[ATP_XSENSORS + i + 1] = dev->data[j + 1];
}
} else {
for (i = 0; i < 8; i++) {
/* X values */
dev->xy_cur[i ] = dev->data[5 * i + 2];
dev->xy_cur[i + 8] = dev->data[5 * i + 4];
dev->xy_cur[i + 16] = dev->data[5 * i + 42];
if (i < 2)
dev->xy_cur[i + 24] = dev->data[5 * i + 44];
/* Y values */
dev->xy_cur[i + 26] = dev->data[5 * i + 1];
dev->xy_cur[i + 34] = dev->data[5 * i + 3];
}
}
dbg_dump("sample", dev->xy_cur);
if (!dev->valid) {
/* first sample */
dev->valid = 1;
dev->x_old = dev->y_old = -1;
memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
if (dev->size_detect_done ||
atp_is_geyser_3(dev)) /* No 17" Macbooks (yet) */
goto exit;
/* 17" Powerbooks have extra X sensors */
for (i = (atp_is_geyser_2(dev) ? 15 : 16); i < ATP_XSENSORS; i++) {
if (!dev->xy_cur[i])
continue;
printk(KERN_INFO "appletouch: 17\" model detected.\n");
if (atp_is_geyser_2(dev))
input_set_abs_params(dev->input, ABS_X, 0,
(20 - 1) *
ATP_XFACT - 1,
ATP_FUZZ, 0);
else
input_set_abs_params(dev->input, ABS_X, 0,
(ATP_XSENSORS - 1) *
ATP_XFACT - 1,
ATP_FUZZ, 0);
break;
}
dev->size_detect_done = 1;
goto exit;
}
for (i = 0; i < ATP_XSENSORS + ATP_YSENSORS; i++) {
/* accumulate the change */
signed char change = dev->xy_old[i] - dev->xy_cur[i];
dev->xy_acc[i] -= change;
/* prevent down drifting */
if (dev->xy_acc[i] < 0)
dev->xy_acc[i] = 0;
}
memcpy(dev->xy_old, dev->xy_cur, sizeof(dev->xy_old));
dbg_dump("accumulator", dev->xy_acc);
x = atp_calculate_abs(dev->xy_acc, ATP_XSENSORS,
ATP_XFACT, &x_z, &x_f);
y = atp_calculate_abs(dev->xy_acc + ATP_XSENSORS, ATP_YSENSORS,
ATP_YFACT, &y_z, &y_f);
key = dev->data[dev->datalen - 1] & 1;
if (x && y) {
if (dev->x_old != -1) {
x = (dev->x_old * 3 + x) >> 2;
y = (dev->y_old * 3 + y) >> 2;
dev->x_old = x;
dev->y_old = y;
if (debug > 1)
printk(KERN_DEBUG "appletouch: X: %3d Y: %3d "
"Xz: %3d Yz: %3d\n",
x, y, x_z, y_z);
input_report_key(dev->input, BTN_TOUCH, 1);
input_report_abs(dev->input, ABS_X, x);
input_report_abs(dev->input, ABS_Y, y);
input_report_abs(dev->input, ABS_PRESSURE,
min(ATP_PRESSURE, x_z + y_z));
atp_report_fingers(dev->input, max(x_f, y_f));
}
dev->x_old = x;
dev->y_old = y;
} else if (!x && !y) {
int dbg_cmd(int argc, char *argv[])
{
char* cmd = NULL;
char* arg1 = NULL;
char* arg2 = NULL;
if (argc > 1) {
cmd = argv[1];
if ( argc > 2 ) {
arg1 = argv[2];
if ( argc > 3 ) {
arg2 = argv[3];
}
}
}
else {
DEBUGF("usage: fat command [options]\n"
"commands:\n"
" dir <dir>\n"
" ds <sector> - display sector\n"
" type <file>\n"
" head <file>\n"
" tail <file>\n"
" mkfile <file> <size (KB)>\n"
" chkfile <file>\n"
" del <file>\n"
" rmdir <dir>\n"
" dump <file> <offset>\n"
" mkdir <dir>\n"
" trunc <file> <size>\n"
" wrtest <file>\n"
" append <file>\n"
" test <file>\n"
" ren <file> <newname>\n"
);
return -1;
}
if (!strcasecmp(cmd, "dir"))
{
if ( arg1 )
dbg_dir(arg1);
else
dbg_dir("/");
}
if (!strcasecmp(cmd, "ds"))
{
if ( arg1 ) {
DEBUGF("secnum: %ld\n", strtol(arg1, NULL, 0));
dbg_dump_sector(strtol(arg1, NULL, 0));
}
}
if (!strcasecmp(cmd, "type"))
{
if (arg1)
dbg_type(arg1);
}
if (!strcasecmp(cmd, "head"))
{
if (arg1)
return dbg_head(arg1);
}
if (!strcasecmp(cmd, "tail"))
{
if (arg1)
dbg_tail(arg1);
}
if (!strcasecmp(cmd, "mkfile"))
{
if (arg1) {
if (arg2)
return dbg_mkfile(arg1,strtol(arg2, NULL, 0));
else
return dbg_mkfile(arg1,1);
}
}
if (!strcasecmp(cmd, "chkfile"))
{
if (arg1) {
if (arg2)
return dbg_chkfile(arg1, strtol(arg2, NULL, 0));
else
return dbg_chkfile(arg1, 0);
}
}
if (!strcasecmp(cmd, "mkdir"))
{
if (arg1) {
return dbg_mkdir(arg1);
}
}
if (!strcasecmp(cmd, "del"))
{
if (arg1)
return remove(arg1);
}
if (!strcasecmp(cmd, "rmdir"))
{
if (arg1)
return rmdir(arg1);
}
if (!strcasecmp(cmd, "dump"))
{
if (arg1) {
if (arg2)
return dbg_dump(arg1, strtol(arg2, NULL, 0));
else
return dbg_dump(arg1, 0);
}
}
if (!strcasecmp(cmd, "wrtest"))
{
if (arg1)
return dbg_wrtest(arg1);
}
if (!strcasecmp(cmd, "append"))
{
if (arg1)
return dbg_append(arg1);
}
if (!strcasecmp(cmd, "test"))
{
if (arg1)
return dbg_test(arg1);
}
if (!strcasecmp(cmd, "trunc"))
{
if (arg1 && arg2)
return dbg_trunc(arg1, strtol(arg2, NULL, 0));
}
if (!strcasecmp(cmd, "ren"))
{
if (arg1 && arg2)
return rename(arg1, arg2);
}
return 0;
}
LONG WINAPI bad_exception(struct _EXCEPTION_POINTERS* ExceptionInfo) {
dbg_dump(ExceptionInfo);
// 不退出
return true;
/*ExitProcess(0);*/
}
/* return 0: on error, 1: success */
static int dev_command (struct device *dev, SANE_Byte * cmd, size_t reqlen)
{
SANE_Status status;
size_t sendlen = cmd[3] + 4;
SANE_Byte *res = dev->res;
assert (reqlen <= sizeof (dev->res)); /* requested len */
dev->reslen = sizeof (dev->res); /* doing full buffer to flush stalled commands */
if (cmd[2] == CMD_SET_WINDOW) {
/* Set Window have wrong packet length, huh. */
sendlen = 25;
}
if (cmd[2] == CMD_READ_IMAGE) {
/* Read Image is raw data, don't need to read response */
res = NULL;
}
dev->state = 0;
DBG (4, ":: dev_command(%s[%#x], %lu)\n", str_cmd(cmd[2]), cmd[2],
(u_long)reqlen);
status = dev->io->dev_request(dev, cmd, sendlen, res, &dev->reslen);
if (status != SANE_STATUS_GOOD) {
DBG (1, "%s: dev_request: %s\n", __FUNCTION__, sane_strstatus (status));
dev->state = SANE_STATUS_IO_ERROR;
return 0;
}
if (!res) {
/* if not need response just return success */
return 1;
}
/* normal command reply, some sanity checking */
if (dev->reslen < reqlen) {
DBG (1, "%s: illegal response len %lu, need %lu\n",
__FUNCTION__, (u_long)dev->reslen, (u_long)reqlen);
dev->state = SANE_STATUS_IO_ERROR;
return 0;
} else {
size_t pktlen; /* len specified in packet */
if (DBG_LEVEL > 3)
dbg_dump(dev);
if (dev->res[0] != RES_CODE) {
DBG (2, "%s: illegal data header %02x\n", __FUNCTION__, dev->res[0]);
dev->state = SANE_STATUS_IO_ERROR;
return 0;
}
pktlen = dev->res[2] + 3;
if (dev->reslen != pktlen) {
DBG (2, "%s: illegal response len %lu, should be %lu\n",
__FUNCTION__, (u_long)pktlen, (u_long)dev->reslen);
dev->state = SANE_STATUS_IO_ERROR;
return 0;
}
if (dev->reslen > reqlen)
DBG (2, "%s: too big packet len %lu, need %lu\n",
__FUNCTION__, (u_long)dev->reslen, (u_long)reqlen);
}
dev->state = 0;
if (cmd[2] == CMD_SET_WINDOW ||
cmd[2] == CMD_OBJECT_POSITION ||
cmd[2] == CMD_READ ||
cmd[2] == CMD_RESERVE_UNIT) {
if (dev->res[1] == STATUS_BUSY)
dev->state = SANE_STATUS_DEVICE_BUSY;
else if (dev->res[1] == STATUS_CANCEL)
dev->state = SANE_STATUS_CANCELLED;
else if (dev->res[1] == STATUS_CHECK)
dev->state = resolv_state((cmd[2] == CMD_READ)?
(dev->res[12] << 8 | dev->res[13]) :
(dev->res[4] << 8 | dev->res[5]));
if (dev->state)
DBG (3, "%s(%s[%#x]): => %d: %s\n",
__FUNCTION__, str_cmd(cmd[2]), cmd[2],
dev->state, sane_strstatus(dev->state));
}
return 1;
}
int main(int argc, char* argv[])
{
int opt, opt_idx;
int in_fmt = INPUT_FMT_FASTA;
int out_fmt = ADJ_GRAPH_FMT_MM;
/* Size of the graph structure. */
size_t n = 100000000;
/* K-mer size. */
size_t k = 25;
/* Number of threads. */
size_t num_threads = 1;
struct option long_options[] =
{
{"fasta", no_argument, &in_fmt, INPUT_FMT_FASTA},
{"fastq", no_argument, &in_fmt, INPUT_FMT_FASTQ},
{"mm", no_argument, &out_fmt, ADJ_GRAPH_FMT_MM},
{"hb", no_argument, &out_fmt, ADJ_GRAPH_FMT_HB},
{"threads", required_argument, NULL, 't'},
{"verbose", no_argument, NULL, 'v'},
{"help", no_argument, NULL, 'h'},
{0, 0, 0, 0}
};
while (true) {
opt = getopt_long(argc, argv, "n:k:t:vh", long_options, &opt_idx);
if (opt == -1) break;
switch (opt) {
case 'n':
n = strtoul(optarg, NULL, 10);
break;
case 'k':
k = strtoul(optarg, NULL, 10);
break;
case 't':
num_threads = strtoul(optarg, NULL, 10);
break;
case 'v':
pique_verbose = true;
break;
case 'h':
print_help(stdout);
return EXIT_SUCCESS;
case '?':
return 1;
case 0:
break;
default:
abort();
}
}
kmer_init();
dbg_t* G = dbg_alloc(n, k);
pthread_mutex_t f_mutex;
pthread_mutex_init_or_die(&f_mutex, NULL);
pthread_t* threads = malloc_or_die(num_threads * sizeof(pthread_t));
pique_ctx_t ctx;
ctx.fmt = in_fmt;
ctx.G = G;
ctx.f_mutex = &f_mutex;
size_t i;
if (optind >= argc) {
ctx.f = fastq_create(stdin);
for (i = 0; i < num_threads; ++i) {
pthread_create(&threads[i], NULL, pique_thread, &ctx);
}
for (i = 0; i < num_threads; ++i) {
pthread_join(threads[i], NULL);
}
fastq_free(ctx.f);
} else {
FILE* file;
for (; optind < argc; ++optind) {
file = fopen(argv[optind], "r");
if (file == NULL) {
fprintf(stderr, "Cannot open %s for reading.\n", argv[optind]);
return EXIT_FAILURE;
}
ctx.f = fastq_create(file);
for (i = 0; i < num_threads; ++i) {
pthread_create(&threads[i], NULL, pique_thread, &ctx);
}
for (i = 0; i < num_threads; ++i) {
pthread_join(threads[i], NULL);
}
fastq_free(ctx.f);
}
}
dbg_dump(G, stdout, num_threads, out_fmt);
pthread_mutex_destroy(&f_mutex);
dbg_free(G);
kmer_free();
return EXIT_SUCCESS;
}
int teleinfo_read_frame_ext(const int fd, char *const buffer,
const size_t buflen, int *error_counter)
{
char *p = buffer;
size_t s = 0;
char c;
enum state { INIT, FRAME_BEGIN, FRAME_END, MSG_BEGIN, MSG_END };
enum state current_state = INIT;
int error_count = 0;
int bytes_in_init_mode = 0;
do {
int res = read(fd, &c, 1);
if (!res) {
syslog(LOG_ERR, "unable to read from source\n");
return EIO;
}
switch (c) {
case STX:
if (current_state != INIT) {
#ifdef DEBUG
syslog(LOG_INFO,
"new STX detected but not expected, resetting frame begin");
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
dbg_dump(buffer, s);
#endif
error_count++;
}
current_state = FRAME_BEGIN;
p = buffer;
s = 0;
// if (s<buflen) { *p++ = c; s++; } else { return EMSGSIZE; }
break;
case LF:
if (current_state != INIT) {
if ((current_state != FRAME_BEGIN)
&& (current_state != MSG_END)) {
#ifdef DEBUG
syslog(LOG_INFO,
"LF detected but not expected, frame is invalid");
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
dbg_dump(buffer, s);
#endif
error_count++;
current_state = INIT;
} else {
current_state = MSG_BEGIN;
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
}
} // else do nothing: simply skip the char
break;
case CR:
if (current_state != INIT) {
if (current_state != MSG_BEGIN) {
#ifdef DEBUG
syslog(LOG_INFO,
"CR detected but not expected, frame is invalid");
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
dbg_dump(buffer, s);
#endif
error_count++;
current_state = INIT;
} else {
current_state = MSG_END;
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
}
} // else do nothing: simply skip the char
break;
case ETX:
if (current_state != INIT) {
if (current_state != MSG_END) {
#ifdef DEBUG
syslog(LOG_INFO,
"ETX detected but not expected, frame is invalid");
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
dbg_dump(buffer, s);
#endif
error_count++;
current_state = INIT;
} else {
current_state = FRAME_END;
// if (s<buflen) { *p++ = c; s++; } else { return EMSGSIZE; }
}
} // else do nothing: simply skip the char
break;
case EOT:
syslog(LOG_INFO,
"frame have been interrupted by EOT, resetting frame");
current_state = INIT;
break;
default:
switch (current_state) {
case INIT:
// STX have not been detected yet, so we skip char
break;
case FRAME_BEGIN:
#ifdef DEBUG
syslog(LOG_INFO,
"STX should be followed by LF, frame is invalid");
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
dbg_dump(buffer, s);
#endif
current_state = INIT;
error_count++;
break;
case FRAME_END:
// We should not be here !
break;
case MSG_BEGIN:
// Message content
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
break;
case MSG_END:
#ifdef DEBUG
syslog(LOG_INFO,
"CR should be followed by ETX or LF, frame is invalid");
if (s < buflen) {
*p++ = c;
s++;
} else {
return EMSGSIZE;
}
dbg_dump(buffer, s);
#endif
current_state = INIT;
error_count++;
break;
}
}
if (current_state == INIT)
bytes_in_init_mode++;
} while ((current_state != FRAME_END) && (error_count < 10)
&& (bytes_in_init_mode < TI_FRAME_LENGTH_MAX * 2));
if (error_counter != NULL) {
*error_counter = error_count;
}
if (current_state == FRAME_END) {
return 0;
} else {
syslog(LOG_INFO, "too many error while reading, giving up");
return EBADMSG;
}
}
