void ReportDescParserBase::PrintUsagePage(uint16_t page) {
    E_Notify(pstrSpace, 0x80);

    if (page > 0x00 && page < 0x11)
        E_Notify((char*)pgm_read_pointer(&usagePageTitles0[page - 1]), 0x80);
    else if (page > 0x7f && page < 0x84)
        E_Notify(pstrUsagePageMonitor, 0x80);
    else if (page > 0x83 && page < 0x8c)
        E_Notify(pstrUsagePagePower, 0x80);
    else if (page > 0x8b && page < 0x92)
        E_Notify((char*)pgm_read_pointer(&usagePageTitles1[page - 0x8c]), 0x80);
    else if (page > 0xfeff && page <= 0xffff)
        E_Notify(pstrUsagePageVendorDefined, 0x80);
    else
        switch (page) {
        case 0x14:
            E_Notify(pstrUsagePageAlphaNumericDisplay, 0x80);
            break;
        case 0x40:
            E_Notify(pstrUsagePageMedicalInstruments, 0x80);
            break;
        default:
            E_Notify(pstrUsagePageUndefined, 0x80);
        }
}
void ReportDescParserBase::PrintGameControlsPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x04)
        E_Notify((char*)pgm_read_pointer(&gameTitles0[usage - 1]), 0x80);
    else if (usage > 0x1f && usage < 0x3a)
        E_Notify((char*)pgm_read_pointer(&gameTitles1[usage - 0x20]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintAlphanumDisplayPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x03)
        E_Notify((char*)pgm_read_pointer(&aplphanumTitles0[usage - 1]), 0x80);
    else if (usage > 0x1f && usage < 0x4e)
        E_Notify((char*)pgm_read_pointer(&aplphanumTitles1[usage - 0x1f]), 0x80);
    else if (usage > 0x7f && usage < 0x96)
        E_Notify((char*)pgm_read_pointer(&digitTitles2[usage - 0x80]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintDigitizerPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x0e)
        E_Notify((char*)pgm_read_pointer(&digitTitles0[usage - 1]), 0x80);
    else if (usage > 0x1f && usage < 0x23)
        E_Notify((char*)pgm_read_pointer(&digitTitles1[usage - 0x1f]), 0x80);
    else if (usage > 0x2f && usage < 0x47)
        E_Notify((char*)pgm_read_pointer(&digitTitles2[usage - 0x2f]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintSportsControlsPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x05)
        E_Notify((char*)pgm_read_pointer(&sportsCtrlTitles0[usage - 1]), 0x80);
    else if (usage > 0x2f && usage < 0x3a)
        E_Notify((char*)pgm_read_pointer(&sportsCtrlTitles1[usage - 0x30]), 0x80);
    else if (usage > 0x4f && usage < 0x64)
        E_Notify((char*)pgm_read_pointer(&sportsCtrlTitles2[usage - 0x50]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintSimulationControlsPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x0d)
        E_Notify((char*)pgm_read_pointer(&simuTitles0[usage - 1]), 0x80);
    else if (usage > 0x1f && usage < 0x26)
        E_Notify((char*)pgm_read_pointer(&simuTitles1[usage - 0x20]), 0x80);
    else if (usage > 0xaf && usage < 0xd1)
        E_Notify((char*)pgm_read_pointer(&simuTitles2[usage - 0xb0]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintGenericDesktopPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x0a)
        E_Notify((char*)pgm_read_pointer(&genDesktopTitles0[usage - 1]), 0x80);
    else if (usage > 0x2f && usage < 0x49)
        E_Notify((char*)pgm_read_pointer(&genDesktopTitles1[usage - 0x30]), 0x80);
    else if (usage > 0x7f && usage < 0x94)
        E_Notify((char*)pgm_read_pointer(&genDesktopTitles2[usage - 0x80]), 0x80);
    else if (usage > 0x9f && usage < 0xa9)
        E_Notify((char*)pgm_read_pointer(&genDesktopTitles3[usage - 0xa0]), 0x80);
    else if (usage > 0xaf && usage < 0xb8)
        E_Notify((char*)pgm_read_pointer(&genDesktopTitles4[usage - 0xb0]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
Exemplo n.º 8
0
// run the n'th command in the menu
int8_t
Menu::_call(uint8_t n, uint8_t argc)
{
    func fn;

    fn = (func)pgm_read_pointer(&_commands[n].func);
    return(fn(argc, &_argv[0]));
}
void ReportDescParserBase::PrintLEDPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x4e)
        E_Notify((char*)pgm_read_pointer(&ledTitles[usage - 1]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintGenericDeviceControlsPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x1f && usage < 0x27)
        E_Notify((char*)pgm_read_pointer(&genDevCtrlTitles[usage - 0x20]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
Exemplo n.º 11
0
/*
  run one tick
  this will run as many scheduler tasks as we can in the specified time
 */
void AP_Scheduler::run(uint16_t time_available)
{
    for (uint8_t i=0; i<_num_tasks; i++) {
        uint16_t dt = _tick_counter - _last_run[i];
        uint16_t interval_ticks = pgm_read_word(&_tasks[i].interval_ticks);
        if (dt >= interval_ticks) {
            // this task is due to run. Do we have enough time to run it?
            _task_time_allowed = pgm_read_word(&_tasks[i].max_time_micros);

            if (dt >= interval_ticks*2) {
                // we've slipped a whole run of this task!
                if (_debug != 0) {
                    hal.console->printf_P(PSTR("Scheduler slip task[%u] (%u/%u/%u)\n"), 
                                          (unsigned)i, 
                                          (unsigned)dt,
                                          (unsigned)interval_ticks,
                                          (unsigned)_task_time_allowed);
                }
            }
            if (_task_time_allowed <= time_available) {
                // run it
                _task_time_started = hal.scheduler->micros();
                task_fn_t func = (task_fn_t)pgm_read_pointer(&_tasks[i].function);
                func();
                
                // record the tick counter when we ran. This drives
                // when we next run the event
                _last_run[i] = _tick_counter;
                
                // work out how long the event actually took
                uint32_t time_taken = hal.scheduler->micros() - _task_time_started;
                
                if (time_taken > _task_time_allowed) {
                    // the event overran!
                    if (_debug > 1) {
                        hal.console->printf_P(PSTR("Scheduler overrun task[%u] (%u/%u)\n"), 
                                              (unsigned)i, 
                                              (unsigned)time_taken,
                                              (unsigned)_task_time_allowed);
                    }
                    goto update_spare_ticks;
                }
                time_available -= time_taken;
            }
        }
    }

    // update number of spare microseconds
    _spare_micros += time_available;

update_spare_ticks:
    _spare_ticks++;
    if (_spare_ticks == 32) {
        _spare_ticks /= 2;
        _spare_micros /= 2;
    }
}
void ReportDescParserBase::PrintMedicalInstrumentPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage == 1)
        E_Notify(pstrUsageMedicalUltrasound, 0x80);
    else if (usage > 0x1f && usage < 0x28)
        E_Notify((char*)pgm_read_pointer(&medInstrTitles0[usage - 0x1f]), 0x80);
    else if (usage > 0x3f && usage < 0x45)
        E_Notify((char*)pgm_read_pointer(&medInstrTitles1[usage - 0x40]), 0x80);
    else if (usage > 0x5f && usage < 0x62)
        E_Notify((char*)pgm_read_pointer(&medInstrTitles2[usage - 0x60]), 0x80);
    else if (usage == 0x70)
        E_Notify(pstrUsageDepthGainCompensation, 0x80);
    else if (usage > 0x7f && usage < 0x8a)
        E_Notify((char*)pgm_read_pointer(&medInstrTitles3[usage - 0x80]), 0x80);
    else if (usage > 0x9f && usage < 0xa2)
        E_Notify((char*)pgm_read_pointer(&medInstrTitles4[usage - 0xa0]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintTelephonyPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x08)
        E_Notify((char*)pgm_read_pointer(&telTitles0[usage - 1]), 0x80);
    else if (usage > 0x1f && usage < 0x32)
        E_Notify((char*)pgm_read_pointer(&telTitles1[usage - 0x1f]), 0x80);
    else if (usage > 0x4f && usage < 0x54)
        E_Notify((char*)pgm_read_pointer(&telTitles2[usage - 0x4f]), 0x80);
    else if (usage > 0x6f && usage < 0x75)
        E_Notify((char*)pgm_read_pointer(&telTitles3[usage - 0x6f]), 0x80);
    else if (usage > 0x8f && usage < 0x9f)
        E_Notify((char*)pgm_read_pointer(&telTitles4[usage - 0x8f]), 0x80);
    else if (usage > 0xaf && usage < 0xc0)
        E_Notify((char*)pgm_read_pointer(&telTitles5[usage - 0xaf]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}
void ReportDescParserBase::PrintConsumerPageUsage(uint16_t usage) {
    E_Notify(pstrSpace, 0x80);

    if (usage > 0x00 && usage < 0x07)
        E_Notify((char*)pgm_read_pointer(&consTitles0[usage - 1]), 0x80);
    else if (usage > 0x1f && usage < 0x23)
        E_Notify((char*)pgm_read_pointer(&consTitles1[usage - 0x1f]), 0x80);
    else if (usage > 0x2f && usage < 0x37)
        E_Notify((char*)pgm_read_pointer(&consTitles2[usage - 0x2f]), 0x80);
    else if (usage > 0x3f && usage < 0x49)
        E_Notify((char*)pgm_read_pointer(&consTitles3[usage - 0x3f]), 0x80);
    else if (usage > 0x5f && usage < 0x67)
        E_Notify((char*)pgm_read_pointer(&consTitles4[usage - 0x5f]), 0x80);
    else if (usage > 0x7f && usage < 0xa5)
        E_Notify((char*)pgm_read_pointer(&consTitles5[usage - 0x7f]), 0x80);
    else if (usage > 0xaf && usage < 0xcf)
        E_Notify((char*)pgm_read_pointer(&consTitles6[usage - 0xaf]), 0x80);
    else if (usage > 0xdf && usage < 0xeb)
        E_Notify((char*)pgm_read_pointer(&consTitles7[usage - 0xdf]), 0x80);
    else if (usage > 0xef && usage < 0xf6)
        E_Notify((char*)pgm_read_pointer(&consTitles8[usage - 0xef]), 0x80);
    else if (usage > 0xff && usage < 0x10e)
        E_Notify((char*)pgm_read_pointer(&consTitles9[usage - 0xff]), 0x80);
    else if (usage > 0x14f && usage < 0x156)
        E_Notify((char*)pgm_read_pointer(&consTitlesA[usage - 0x14f]), 0x80);
    else if (usage > 0x15f && usage < 0x16b)
        E_Notify((char*)pgm_read_pointer(&consTitlesB[usage - 0x15f]), 0x80);
    else if (usage > 0x16f && usage < 0x175)
        E_Notify((char*)pgm_read_pointer(&consTitlesC[usage - 0x16f]), 0x80);
    else if (usage > 0x17f && usage < 0x1c8)
        E_Notify((char*)pgm_read_pointer(&consTitlesD[usage - 0x17f]), 0x80);
    else if (usage > 0x1ff && usage < 0x29d)
        E_Notify((char*)pgm_read_pointer(&consTitlesE[usage - 0x1ff]), 0x80);
    else
        E_Notify(pstrUsagePageUndefined, 0x80);
}