static bool mousekey_console(uint8_t code)
{
switch (code) {
case KC_H:
case KC_SLASH: /* ? */
mousekey_console_help();
break;
case KC_Q:
case KC_ESC:
mousekey_param = 0;
print("\nQuit Mousekey Console\n");
print("C> ");
state = CONSOLE;
return false;
case KC_P:
mousekey_param_print();
break;
case KC_1:
case KC_2:
case KC_3:
case KC_4:
case KC_5:
case KC_6:
case KC_7:
case KC_8:
case KC_9:
case KC_0:
mousekey_param = numkey2num(code);
print("selected parameter: "); pdec(mousekey_param); print("\n");
break;
case KC_UP:
mousekey_param_inc(mousekey_param, 1);
break;
case KC_DOWN:
mousekey_param_dec(mousekey_param, 1);
break;
case KC_PGUP:
mousekey_param_inc(mousekey_param, 10);
break;
case KC_PGDN:
mousekey_param_dec(mousekey_param, 10);
break;
case KC_D:
mk_delay = MOUSEKEY_DELAY/10;
mk_interval = MOUSEKEY_INTERVAL;
mk_max_speed = MOUSEKEY_MAX_SPEED;
mk_time_to_max = MOUSEKEY_TIME_TO_MAX;
mk_wheel_max_speed = MOUSEKEY_WHEEL_MAX_SPEED;
mk_wheel_time_to_max = MOUSEKEY_WHEEL_TIME_TO_MAX;
print("set default values.\n");
break;
default:
print("?");
return false;
}
print("M"); pdec(mousekey_param); print("> ");
return true;
}
test_pdec()
{
_Bool local;
b = 0;
local = pdec();
assert(b == 1 && local == 0);
b = 1;
local = pdec();
assert(b == 0 && local == 1);
}
/* transfer keyboard report from buffer */
void vusb_transfer_keyboard(void)
{
if (usbInterruptIsReady()) {
if (kbuf_head != kbuf_tail) {
usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
if (debug_keyboard) {
print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("](");
phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
print(")\n");
}
}
}
}
uint8_t matrix_scan(void)
{
if (mcp23018_status) { // if there was an error
if (++mcp23018_reset_loop == 0) {
// since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans
// this will be approx bit more frequent than once per second
print("trying to reset mcp23018\n");
mcp23018_status = init_mcp23018();
if (mcp23018_status) {
print("left side not responding\n");
} else {
print("left side attached\n");
frenchdev_blink_all_leds();
}
}
}
#ifdef DEBUG_MATRIX_SCAN_RATE
matrix_scan_count++;
uint32_t timer_now = timer_read32();
if (TIMER_DIFF_32(timer_now, matrix_timer)>1000) {
print("matrix scan frequency: ");
pdec(matrix_scan_count);
print("\n");
matrix_timer = timer_now;
matrix_scan_count = 0;
}
#endif
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
wait_us(30); // without this wait read unstable value.
matrix_row_t cols = read_cols(i);
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
wait_us(1);
// this should be wait_ms(1) but has been left as-is at EZ's request
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
matrix_scan_quantum();
return 1;
}
void
pdec(Io *f, long n)
{
if(n<0){
n=-n;
if(n>=0){
pchr(f, '-');
pdec(f, n);
return;
}
/* n is two's complement minimum integer */
n=1-n;
pchr(f, '-');
pdec(f, n/10);
pchr(f, n%10+'1');
return;
}
if(n>9) pdec(f, n/10);
pchr(f, n%10+'0');
}
static void mousekey_console_help(void)
{
print("\n\n----- Mousekey Parameters Help -----\n");
print("ESC/q: quit\n");
print("1: select mk_delay(*10ms)\n");
print("2: select mk_interval(ms)\n");
print("3: select mk_max_speed\n");
print("4: select mk_time_to_max\n");
print("5: select mk_wheel_max_speed\n");
print("6: select mk_wheel_time_to_max\n");
print("p: print prameters\n");
print("d: set default values\n");
print("up: increase prameters(+1)\n");
print("down: decrease prameters(-1)\n");
print("pgup: increase prameters(+10)\n");
print("pgdown: decrease prameters(-10)\n");
print("\nspeed = delta * max_speed * (repeat / time_to_max)\n");
print("where delta: cursor="); pdec(MOUSEKEY_MOVE_DELTA);
print(", wheel="); pdec(MOUSEKEY_WHEEL_DELTA); print("\n");
print("See http://en.wikipedia.org/wiki/Mouse_keys\n");
}
static void mousekey_param_print(void)
{
print("\n\n----- Mousekey Parameters -----\n");
print("1: mk_delay(*10ms): "); pdec(mk_delay); print("\n");
print("2: mk_interval(ms): "); pdec(mk_interval); print("\n");
print("3: mk_max_speed: "); pdec(mk_max_speed); print("\n");
print("4: mk_time_to_max: "); pdec(mk_time_to_max); print("\n");
print("5: mk_wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n");
print("6: mk_wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n");
}
void testGapArrayByte()
{
uint64_t const gsize = 329114;
libmaus2::autoarray::AutoArray<uint32_t> GG(gsize);
for ( uint64_t i = 0; i < gsize; ++i )
GG[i] = 1;
for ( uint64_t i = 0; i < 32; ++i )
GG[libmaus2::random::Random::rand64() % gsize] = 257;
uint64_t const numthreads = 32;
libmaus2::suffixsort::GapArrayByte GAB(gsize,16,numthreads,"tmp");
#if defined(_OPENMP)
#pragma omp parallel for num_threads(numthreads)
#endif
for ( uint64_t i = 0; i < gsize; ++i )
for ( uint64_t j = 0; j < GG[i]; ++j )
if ( GAB(i) )
#if defined(_OPENMP)
GAB(i,omp_get_thread_num());
#else
GAB(i,0);
#endif
GAB.flush();
uint64_t offset = 0;
libmaus2::suffixsort::GapArrayByteDecoder::unique_ptr_type pdec(GAB.getDecoder(offset));
libmaus2::autoarray::AutoArray<uint32_t> TT(48);
while ( offset != gsize )
{
uint64_t const rest = gsize - offset;
uint64_t const tocopy = std::min(rest,TT.size());
pdec->decode(TT.begin(),tocopy);
for ( uint64_t i = 0; i < tocopy; ++i )
assert (
TT[i] == GG[offset+i]
);
offset += tocopy;
}
}
static void mousekey_param_print(void)
{
#ifndef NO_PRINT
print("\n\t- Values -\n");
print("1: delay(*10ms): "); pdec(mk_delay); print("\n");
print("2: interval(ms): "); pdec(mk_interval); print("\n");
print("3: max_speed: "); pdec(mk_max_speed); print("\n");
print("4: time_to_max: "); pdec(mk_time_to_max); print("\n");
print("5: wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n");
print("6: wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n");
#endif /* !NO_PRINT */
}
static void mousekey_param_print(void)
{
// Print these variables if NO_PRINT or USER_PRINT are not defined.
#if !defined(NO_PRINT) && !defined(USER_PRINT)
print("\n\t- Values -\n");
print("1: delay(*10ms): "); pdec(mk_delay); print("\n");
print("2: interval(ms): "); pdec(mk_interval); print("\n");
print("3: max_speed: "); pdec(mk_max_speed); print("\n");
print("4: time_to_max: "); pdec(mk_time_to_max); print("\n");
print("5: wheel_max_speed: "); pdec(mk_wheel_max_speed); print("\n");
print("6: wheel_time_to_max: "); pdec(mk_wheel_time_to_max); print("\n");
#endif /* !NO_PRINT */
}
int bamrefdepth(libmaus::util::ArgInfo const & arginfo)
{
int const verbose = arginfo.getValue<int>("verbose",getDefaultVerbose());
libmaus::bambam::BamAlignmentDecoderWrapper::unique_ptr_type pdec(
libmaus::bambam::BamMultiAlignmentDecoderFactory::construct(arginfo));
libmaus::bambam::BamAlignmentDecoder & bamdec = pdec->getDecoder();
libmaus::bambam::BamAlignment & algn = bamdec.getAlignment();
libmaus::bambam::BamHeader const & header = bamdec.getHeader();
std::string const sortorder = libmaus::bambam::BamHeader::getSortOrderStatic(header.text);
libmaus::bambam::BamAlignment prevalgn;
bool hasprev = false;
uint64_t c = 0;
std::deque<uint64_t> Q;
uint64_t leftpos = 0;
libmaus::autoarray::AutoArray<libmaus::bambam::cigar_operation> cigop;
libmaus::autoarray::AutoArray<char> decread;
std::vector < std::string > refnames;
for ( uint64_t i = 0; i < header.getNumRef(); ++i )
refnames.push_back(header.getRefIDName(i));
while ( bamdec.readAlignment() )
{
bool const ok =
(!hasprev)
||
(
(static_cast<uint32_t>( algn.getRefID()) >
static_cast<uint32_t>(prevalgn.getRefID())
)
||
(
(static_cast<uint32_t>( algn.getRefID()) ==
static_cast<uint32_t>(prevalgn.getRefID())
)
&&
(static_cast<uint32_t>( algn.getPos()) >=
static_cast<uint32_t>(prevalgn.getPos())
)
)
);
if ( ! ok )
{
libmaus::exception::LibMausException se;
se.getStream() << "File is not ordered by coordinate:";
se.getStream() << prevalgn.formatAlignment(header) << std::endl;
se.getStream() << algn.formatAlignment(header) << std::endl;
se.finish();
throw se;
}
// next reference sequence
if ( hasprev && (algn.getRefID() != prevalgn.getRefID()) )
{
while ( Q.size() )
{
if ( Q[0] )
std::cout << refnames[prevalgn.getRefID()] << "\t" << leftpos << "\t" << Q[0] << std::endl;
Q.pop_front();
leftpos++;
}
// Q.resize(0);
leftpos = 0;
}
if ( algn.isMapped() )
{
uint32_t const numcigop = algn.getCigarOperations(cigop);
uint64_t const readlen = algn.decodeRead(decread);
int64_t pos = algn.getPos();
uint64_t readpos = 0;
// std::cerr << "Q.size()=" << Q.size() << std::endl;
while ( Q.size() && pos > static_cast<int64_t>(leftpos) )
{
if ( Q[0] )
std::cout << refnames[algn.getRefID()] << "\t" << leftpos << "\t" << Q[0] << std::endl;
Q.pop_front();
leftpos++;
}
// skip soft clipping at front
uint64_t cidx = 0;
bool frontskip = true;
while ( cidx < numcigop && frontskip )
switch ( cigop[cidx].first )
{
// padding, ref skip, hard clip, deletion
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CPAD:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CREF_SKIP:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CHARD_CLIP:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CDEL:
cidx += 1;
break;
// insertion/soft clipping, advance on read
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CSOFT_CLIP:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CINS:
readpos += cigop[cidx++].second;
break;
// match/mismatch
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CMATCH:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CEQUAL:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CDIFF:
frontskip = false;
break;
}
for ( ; cidx < numcigop ; ++cidx )
switch ( cigop[cidx].first )
{
// padding, hard clipping (ignore)
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CPAD:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CHARD_CLIP:
break;
// ref skip, deletion (advance on reference)
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CREF_SKIP:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CDEL:
pos += cigop[cidx].second;
break;
// insertion/soft clipping (advance on read)
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CSOFT_CLIP:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CINS:
readpos += cigop[cidx].second;
break;
// match/mismatch
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CMATCH:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CEQUAL:
case libmaus::bambam::BamFlagBase::LIBMAUS_BAMBAM_CDIFF:
for ( uint64_t i = 0; static_cast<int64_t>(i) < cigop[cidx].second; ++i, ++pos, ++readpos )
{
if ( ! Q.size() )
{
Q.push_back(1);
leftpos = pos;
}
else
{
while ( pos-leftpos >= Q.size() )
Q.push_back(0);
assert ( pos-leftpos < Q.size() );
Q[pos-leftpos] += 1;
}
}
break;
}
#if 0
if ( readpos != readlen )
{
std::cerr << "readpos=" << readpos << " readlen=" << readlen << std::endl;
std::cerr << algn.formatAlignment(header) << std::endl;
}
#endif
assert (readpos == readlen);
}
prevalgn.swap(algn);
hasprev = true;
if ( verbose && ( ((++c) & ((1ull<<20)-1)) == 0 ) )
std::cerr << "[V] " << c << std::endl;
}
while ( Q.size() )
{
if ( Q[0] )
std::cout << refnames[prevalgn.getRefID()] << "\t" << leftpos << "\t" << Q[0] << std::endl;
Q.pop_front();
leftpos++;
}
if ( verbose )
std::cerr << "[V] " << c << std::endl;
return EXIT_SUCCESS;
}
uint8_t matrix_scan(void)
{
if (mcp23018_status) { // if there was an error
if (++mcp23018_reset_loop == 0) {
// since mcp23018_reset_loop is 8 bit - we'll try to reset once in 255 matrix scans
// this will be approx bit more frequent than once per second
print("trying to reset mcp23018\n");
mcp23018_status = init_mcp23018();
if (mcp23018_status) {
print("left side not responding\n");
} else {
print("left side attached\n");
ergodox_blink_all_leds();
}
}
}
#ifdef DEBUG_MATRIX_FREQ
matrix_scan_count++;
uint32_t timer_now = timer_read32();
if (TIMER_DIFF_32(timer_now, matrix_timer)>1000) {
print("matrix scan frequency: ");
pdec(matrix_scan_count);
print("\n");
matrix_timer = timer_now;
matrix_scan_count = 0;
}
#endif
#ifdef KEYMAP_CUB
uint8_t layer = biton32(layer_state);
ergodox_board_led_off();
ergodox_left_led_1_off();
ergodox_left_led_2_off();
ergodox_left_led_3_off();
switch (layer) {
case 1:
// all
ergodox_left_led_1_on();
ergodox_left_led_2_on();
ergodox_left_led_3_on();
break;
case 2:
// blue
ergodox_left_led_2_on();
break;
case 8:
// blue and green
ergodox_left_led_2_on();
// break missed intentionally
case 3:
// green
ergodox_left_led_3_on();
break;
case 6:
ergodox_board_led_on();
// break missed intentionally
case 4:
case 5:
case 7:
// red
ergodox_left_led_1_on();
break;
default:
// none
break;
}
mcp23018_status = ergodox_left_leds_update();
#endif
#ifdef KEYMAP_SIMON
uint8_t layer = biton32(layer_state);
ergodox_board_led_off();
switch (layer) {
case 0:
// none
break;
default:
ergodox_board_led_on();
break;
}
#endif
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
select_row(i);
matrix_row_t cols = read_cols(i);
if (matrix_debouncing[i] != cols) {
matrix_debouncing[i] = cols;
if (debouncing) {
debug("bounce!: "); debug_hex(debouncing); debug("\n");
}
debouncing = DEBOUNCE;
}
unselect_rows();
}
if (debouncing) {
if (--debouncing) {
_delay_ms(1);
} else {
for (uint8_t i = 0; i < MATRIX_ROWS; i++) {
matrix[i] = matrix_debouncing[i];
}
}
}
return 1;
}
int main(int argc, char **argv) {
char *bin = "tlmtestcapture.funcubebin";
char *csv = NULL, *csv_hdrs = "NONE\n";
char *pay = NULL;
FILE *fp, *cp = NULL, *pp = NULL;
uint32_t dhex = 0;
decode_t pdec = NULL;
uint8_t pkt[256];
int arg;
for (arg=1; arg<argc; arg++) {
if (!strncmp(argv[arg], "-i", 2)) {
bin = argv[++arg];
} else if (!strncmp(argv[arg], "-f", 2)) {
pdec = decode_fc1;
csv_hdrs = csv_fc1;
} else if (!strncmp(argv[arg], "-u", 2)) {
pdec = decode_ukube;
csv_hdrs = csv_ukube;
} else if (!strncmp(argv[arg], "-n", 2)) {
pdec = decode_nayif;
csv_hdrs = csv_nayif;
} else if (!strncmp(argv[arg], "-c", 2)) {
csv = argv[++arg];
} else if (!strncmp(argv[arg], "-p", 2)) {
pay = argv[++arg];
} else if (!strncmp(argv[arg], "-d", 2)) {
dhex = (uint32_t)atol(argv[++arg]);
} else {
return usage();
}
}
fprintf(stderr, "dumping: %s\n", bin);
fp = fopen(bin, "rb");
if (!fp) {
perror("opening bin file");
return 1;
}
if (csv) {
cp = fopen(csv, "wb");
if (!cp) {
perror("opening CSV file");
return 1;
} else {
fputs(csv_hdrs, cp);
}
}
if (pay) {
pp = fopen(pay, "wb");
if (!pp) {
perror("opening Payload file");
return 1;
}
}
while (fread(pkt, sizeof(pkt), 1, fp)==1) {
uint32_t s = 0;
if (pdec) s = pdec(pkt, cp);
if (dhex > 0 && s == dhex) { dump(pkt, sizeof(pkt)); if (pp) fwrite(pkt+56, sizeof(pkt)-56, 1, pp); }
if (cp) fprintf(cp, "\n");
}
fclose(fp);
if (cp)
fclose(cp);
if (pp)
fclose(pp);
return 0;
}
/* Display score */
disp_score()
{
pdec(33,27,plr_score,7,1,APLT1|BG_BIT);
bckdsp &= ~B_SCORE; /* Disable score update */
}
