void action(boolean flag) {
pending_actions = flag;
// If negative action, abort buzzer immedielty.
if (!flag) {
enterIdleState();
}
}
void setup() {
// Fast PWM mode, OC2B output active high.
TCCR0A = L(COM0A1) | L(COM0A0) | H(COM0B1) | H(COM0B0) | H(WGM01) | H(WGM00);
// Prescaler x256 (62.5Khz @ 16Mhz).
TCCR0B = L(FOC0A) | L(FOC0B) | H(WGM02) | H(CS02) | L(CS01) | L(CS00);
// Clear counter.
TCNT0 = 0;
// Compare A, sets output frequency.
OCR0A = kDivider;
// Compare B, sets output duty cycle.
OCR0B = kDivider / 2;
// Diabled interrupts.
TIMSK0 = L(OCIE0B) | L(OCIE0A) | L(TOIE0);
TIFR0 = L(OCF0B) | L(OCF0A) | L(TOV0);
enterIdleState();
}
// Called from loop() when in ACTIVE state.
static inline void loopInActiveState() {
// If within current slot time then do nothing.
const uint16 slot_time_millis = slotTimeMillis(active_sequence_number, active_slot_index);
if (timer.timeMillis() < slot_time_millis) {
return;
}
// Advance to next slot.
timer.restart();
active_slot_index++;
const uint16 next_slot_time_millis = slotTimeMillis(active_sequence_number, active_slot_index);
// If this is a normal slot, start playing it.
if (next_slot_time_millis) {
// Odd slots are off, even are on.
if (active_slot_index & 0x1) {
buzzerOff();
}
else {
buzzerOn();
}
return;
}
// Here when we reached a terminator slot at the end of the sequence.
// If there are pending action, start a new sequence.
if (pending_actions) {
// Stay in active state and start another cycle.
pending_actions = false;
// We play sequence 1 once and then switch to sequence 2.
active_sequence_number = 2;
active_slot_index = 0;
// First slot is always on (even index).
buzzerOn();
return;
}
// Here when at end of sequence and no pending action. Switch
// to off state.
enterIdleState();
}
void DebuggerDriver::processOutput(const QByteArray& data)
{
// write to log file (do not log delayed output - it would appear twice)
if (m_logFile.isOpen()) {
m_logFile.write(data);
m_logFile.flush();
}
/*
* gdb sometimes produces stray output while it's idle. This happens if
* it receives a signal, most prominently a SIGCONT after a SIGTSTP:
* The user haltet kdbg with Ctrl-Z, then continues it with "fg", which
* also continues gdb, which repeats the prompt!
*/
if (m_activeCmd == 0 && m_state != DSinterrupted) {
// ignore the output
TRACE("ignoring stray output: " + QString(data));
return;
}
ASSERT(m_state == DSrunning || m_state == DSrunningLow || m_state == DSinterrupted);
ASSERT(m_activeCmd != 0 || m_state == DSinterrupted);
// collect output until next prompt string is found
// accumulate it
m_output += data;
// check for a prompt
int promptStart = findPrompt(m_output);
if (promptStart >= 0)
{
// found prompt!
// terminate output before the prompt
m_output.resize(promptStart);
/*
* We've got output for the active command. But if it was
* interrupted, ignore it.
*/
if (m_state != DSinterrupted) {
/*
* m_state shouldn't be DSidle while we are parsing the output
* so that all commands produced by parse() go into the queue
* instead of being written to gdb immediately.
*/
ASSERT(m_state != DSidle);
CmdQueueItem* cmd = m_activeCmd;
m_activeCmd = 0;
commandFinished(cmd);
delete cmd;
}
// empty buffer
m_output.clear();
// also clear delayed output if interrupted
if (m_state == DSinterrupted) {
m_delayedOutput = std::queue<QByteArray>();
}
/*
* We parsed some output successfully. Unless there's more delayed
* output, the debugger must be idle now, so send down the next
* command.
*/
if (m_delayedOutput.empty()) {
if (m_hipriCmdQueue.empty() && m_lopriCmdQueue.empty()) {
// no pending commands
m_state = DSidle;
emit enterIdleState();
} else {
writeCommand();
}
}
}
}
