bool onOffDelayUpdate(OnOffDelay* me, bool Trg) {
switch (me->state) {
case S0:
if (Trg) {
me->state = S1;
timerStart(me->timer, me->TH);
}
break;
case S1:
if (Trg) {
if (timerExpired(me->timer)) {
me->state = S2;
}
} else {
me->state = S0;
}
break;
case S2:
if (!Trg) {
me->state = S3;
timerStart(me->timer, me->TL);
}
break;
case S3:
if (!Trg) {
if (timerExpired(me->timer)) {
me->state = S0;
}
} else {
me->state = S0;
}
break;
}
return onOffDelayOutput(me);
}
static void issueDelayReqTimerExpired(PtpClock *ptpClock)
{
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
if(ptpClock->portDS.portState != PTP_SLAVE)
{
break;
}
if (timerExpired(DELAYREQ_INTERVAL_TIMER, ptpClock->itimer))
{
timerStart(DELAYREQ_INTERVAL_TIMER, getRand(pow2ms(ptpClock->portDS.logMinDelayReqInterval + 1)), ptpClock->itimer);
DBGV("event DELAYREQ_INTERVAL_TIMEOUT_EXPIRES\n");
issueDelayReq(ptpClock);
}
break;
case P2P:
if (timerExpired(PDELAYREQ_INTERVAL_TIMER, ptpClock->itimer))
{
timerStart(PDELAYREQ_INTERVAL_TIMER, getRand(pow2ms(ptpClock->portDS.logMinPdelayReqInterval + 1)), ptpClock->itimer);
DBGV("event PDELAYREQ_INTERVAL_TIMEOUT_EXPIRES\n");
issuePDelayReq(ptpClock);
}
break;
default:
break;
}
}
//print new line
void PrintLine()
{
setTimerIn4ms(3);
while(!timerExpired());
UART_Transmit(13);
setTimerIn4ms(3);
while(!timerExpired());
UART_Transmit(10);
}
bool offDelayUpdate(OffDelay* me, bool Trg, bool R) {
if (R) {
me->state = S0;
} else {
switch (me->state) {
case S0:
if (Trg) {
me->state = S1;
}
break;
case S1:
if (!Trg) {
timerStart(me->timer, me->T);
me->state = S2;
}
break;
case S2:
if (Trg) {
me->state = S1;
} else {
if (timerExpired(me->timer)) {
me->state = S0;
}
}
break;
}
}
return offDelayOutput(me);
}
//Need to add the hangs
unsigned char st_beforePowerOff(void){
//State Transition is occurring
if (timerCountDownActivated == POWEROFF_ACK_WAITING) {
if (isPowerLED_ON() == OFF)
{
timerCountDownActivated = NOT_ACTIVATED;
setTimerIn100ms(ZERO);
setActivityDetected(FALSE);
powerSupplyON(OFF);
return POWEROFF;
}
else if (timerExpired())
{
timerCountDownActivated = NOT_ACTIVATED;
}
else
{
return BEFOREPOWEROFF;
}
}
//Needs to send every five seconds
sendPowerOffRequest();
timerCountDownActivated = POWEROFF_ACK_WAITING;
setTimerIn100ms(POWEROFF_WAIT);
return BEFOREPOWEROFF;
}
unsigned char st_powerOff(void){
//State Transition is occuring
if (timerCountDownActivated == POWER_BUTTON_ON) {
if (timerExpired())
{
powerButtonPressed(RELEASED);
if (isPowerLED_ON()) {
timerCountDownActivated = NOT_ACTIVATED;
setTimerIn100ms(ZERO);
setHeartBeat(OFF);
return BOOTING;
}
}
//May hangs here
return POWEROFF;
}
//Press the button for POWER_BUTTON_PRESSED time and switch state
if (activityDetected()) {
powerSupplyON(ON);
powerButtonPressed(PRESSED);
timerCountDownActivated = POWER_BUTTON_ON;
setTimerIn100ms(POWER_BUTTON_PRESSED);
}
return POWEROFF;
}
unsigned char st_suspend(void){
//State Transition is occuring
if (timerCountDownActivated == POWER_BUTTON_OFF) {
if (timerExpired())
{
powerButtonPressed(RELEASED);
timerCountDownActivated = NOT_ACTIVATED;
if (getActivityInactiveTimeInS() > POWEROFF_THRESOLD_SEC) {
return BEFOREPOWEROFF;
}
else
{
setHeartBeat(OFF);
return BOOTING;
}
}
else{
return SUSPEND;
}
}
//Activty detected OR NON-Activity for too long
if (activityDetected() || getActivityInactiveTimeInS() > POWEROFF_THRESOLD_SEC) {
powerButtonPressed(PRESSED);
timerCountDownActivated = POWER_BUTTON_OFF;
setTimerIn100ms(POWER_BUTTON_PRESSED);
}
return SUSPEND;
}
bool debounceUpdate(Debounce* me, bool i) {
switch (me->state) {
case S0: // init
timerInit(me->timer);
timerSingleShot(me->timer);
me->state = S1;
break;
case S1: // steady state
if (i) { // rising edge of input
timerStart(me->timer, DEBOUNCE_TIME);
me->state = S2;
}
break;
case S2: // input is high
if (i) {
if (timerExpired(me->timer)) { // if it is high for the debounce time
me->state = S3; // it is considered high for the observer (output)
}
} else {
me->state = S1;
}
break;
case S3: // input is steady high
if (!i) { // if it goes low next state
timerStart(me->timer, DEBOUNCE_TIME);
me->state = S4;
}
break;
case S4:
if (!i) {
if (timerExpired(me->timer)) {
me->state = S1;
}
} else {
me->state = S3;
}
break;
}
return debounceOutput(me);
}
/**
* @brief ClientInfo::ClientInfo default constructor for ClientInfo.
* @param parent the parent object.
* @param clientAddress the client IP address.
*/
ClientInfo::ClientInfo(QObject *parent, QString clientAddress) : QObject(parent)
{
qDebug() << "Client Created";
address = clientAddress;
//start the timeout timer
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(timerExpired()));
timer->start(1000);
}
//print text and new line
void PrintLn(char Text[40])
{
unsigned char Len, i, T;
Len = Length(Text);
for (i=0; i<Len; i++)
{
T = Text[i];
setTimerIn4ms(3);
while(!timerExpired());
UART_Transmit(T);
}
setTimerIn4ms(3);
while(!timerExpired());
UART_Transmit(13);
setTimerIn4ms(3);
while(!timerExpired());
UART_Transmit(10);
}
unsigned char st_run(void){
if (timerCountDownActivated == POWER_SUPPLY) {
if (isPowerLED_ON()== OFF) {
timerCountDownActivated = NOT_ACTIVATED;
setTracking(OFF);
setHeartBeat(OFF);
setActivityDetected(FALSE);
return POWEROFF;
}
return RUN;
}
else if (timerCountDownActivated == SUSPEND_ACK_WAITING) {
if (timerExpired()) {
//Computer might hangs
//Heartbeat = TRUE but never ACK SUSPEND
timerCountDownActivated = NOT_ACTIVATED;
}else if (getSuspendAcknowledge()) {
timerCountDownActivated = NOT_ACTIVATED;
setTimerIn100ms(ZERO);
setTracking(OFF);
setHeartBeat(OFF);
setActivityDetected(FALSE);
return SUSPEND;
}
return RUN;
}
if (getHeartBeatInactiveTimeInS() > HEARTBEAT_THRESOLD_SEC) {
//Ubuntu hangs -> Turn it off
powerSupplyON(OFF);
timerCountDownActivated = POWER_SUPPLY;
}else if (getTracking()==OFF) {
//Ubuntu not tracking -> Suspend
sendSuspendRequest();
timerCountDownActivated = SUSPEND_ACK_WAITING;
setTimerIn100ms(SUSPENSION_WAIT);
}
return RUN;
}
QueueScheduler::QueueScheduler()
{
currentState = NOT_ENABLED;
isRatePeriod = false;
schedDb = 0;
currentSchedule = 0;
restrictedSpeed = -1; // not restricted
nextBoundary.setSingleShot(true);
connect(&nextBoundary, SIGNAL(timeout()), this, SLOT(timerExpired()));
currentTime = QDateTime::currentDateTime();
currentMonday = currentTime.addDays((currentTime.date().dayOfWeek() - 1) * -1);
QTime mondayTime(0,0);
currentMonday.setTime(mondayTime);
// qDebug() << "Monday is " << currentMonday.toString("ddd dd MM yyyy hh:mm:ss");
}
/*
this function checks if wr timer has expired for a current WR state
*/
void wrTimerExpired(UInteger8 currentState, RunTimeOpts *rtOpts, PtpPortDS *ptpPortDS, Enumeration8 wrMode)
{
UInteger8 wrStateRetry;
/*WRS_IDLE state does not expire */
if(currentState == WRS_IDLE)
return;
if(timerExpired(&ptpPortDS->wrTimers[currentState]))
{
if(currentState == WRS_CALIBRATION && ptpPortDS->calRetry > 0)
wrStateRetry = ptpPortDS->calRetry;
else if(currentState == WRS_RESP_CALIB_REQ && ptpPortDS->otherNodeCalRetry > 0)
wrStateRetry = ptpPortDS->otherNodeCalRetry;
else
wrStateRetry = ptpPortDS->wrStateRetry;
if (ptpPortDS->currentWRstateCnt < wrStateRetry)
{
PTPD_TRACE(TRACE_WR_PROTO, ptpPortDS, "WR_Slave_TIMEOUT: state[= %d] timeout, repeat state\n", currentState);
toWRState(currentState, rtOpts, ptpPortDS);
}
else
{
// PTPD_TRACE(TRACE_WR_PROTO, ptpPortDS,"WR_Slave_TIMEOUT: state[=%d] timeout, repeated %d times, going to Standard PTP\n", \
currentState,ptpPortDS->currentWRstateCnt );
ptpPortDS->wrModeON = FALSE;
toWRState(WRS_IDLE, rtOpts, ptpPortDS);
if(rtOpts->disableFallbackIfWRFails)
{
PTPD_TRACE(TRACE_WR_PROTO, ptpPortDS,"WR_Slave_TIMEOUT: state[=%d] timeout, disabling port (standard PTP fallback OFF).\n", currentState);
toState(PTP_DISABLED, rtOpts, ptpPortDS);
} else if(wrMode == WR_MASTER)
toState(PTP_MASTER, rtOpts, ptpPortDS);
else toState(PTP_SLAVE, rtOpts, ptpPortDS);
/*
* RE-INITIALIZATION OF White Rabbit Data Sets
* (chapter (Re-)Initialization of wrspec
*/
initWrData(ptpPortDS, INIT); //INIT mode because we don't need to remember WR port mode and port role
}
}
}
//------------------------------------------------------------------------------
void appService(Application *app)
{
if(asicReportValid())
{
uint32_t nonce = asicGetNonce();
uint32_t nonce_reversed = 0;
timerStop(&app->work_timer);
asicStop();
asicResetSpi();
app->state.state = STATE_RESET;
SPCR |= _BV(SPIE);
nonce_reversed |= nonce & 0xFF;
nonce >>= 8;
nonce_reversed <<= 8;
nonce_reversed |= nonce & 0xFF;
nonce >>= 8;
nonce_reversed <<= 8;
nonce_reversed |= nonce & 0xFF;
nonce >>= 8;
nonce_reversed <<= 8;
nonce_reversed |= nonce & 0xFF;
nonce_reversed = nonce_reversed - 0xC0;
app->state.nonce = nonce_reversed;
app->state.nonce_valid = 1;
sendCmdReply(app, 'S', (uint8_t *)&app->state, sizeof(State));
}
if(timerExpired(&app->work_timer))
{
asicStop();
asicResetSpi();
app->state.state = STATE_RESET;
app->state.nonce = 0;
app->state.nonce_valid = 0;
sendCmdReply(app, 'S', (uint8_t *)&app->state, sizeof(State));
}
}
/* handle actions and events for 'port_state' */
void
doState(RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
UInteger8 state;
ptpClock->message_activity = FALSE;
/* Process record_update (BMC algorithm) before everything else */
switch (ptpClock->portState)
{
case PTP_LISTENING:
case PTP_PASSIVE:
case PTP_SLAVE:
case PTP_MASTER:
/*State decision Event*/
/* If we received a valid Announce message, and can use it (record_update), then run the BMC algorithm */
if(ptpClock->record_update)
{
DBG2("event STATE_DECISION_EVENT\n");
ptpClock->record_update = FALSE;
state = bmc(ptpClock->foreign, rtOpts, ptpClock);
if(state != ptpClock->portState)
toState(state, rtOpts, ptpClock);
}
break;
default:
break;
}
switch (ptpClock->portState)
{
case PTP_FAULTY:
/* imaginary troubleshooting */
DBG("event FAULT_CLEARED\n");
toState(PTP_INITIALIZING, rtOpts, ptpClock);
return;
case PTP_LISTENING:
case PTP_UNCALIBRATED:
case PTP_SLAVE:
// passive mode behaves like the SLAVE state, in order to wait for the announce timeout of the current active master
case PTP_PASSIVE:
handle(rtOpts, ptpClock);
/*
* handle SLAVE timers:
* - No Announce message was received
* - Time to send new delayReq (miss of delayResp is not monitored explicitelly)
*/
if (timerExpired(ANNOUNCE_RECEIPT_TIMER, ptpClock->itimer))
{
DBG("event ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES\n");
ptpClock->number_foreign_records = 0;
ptpClock->foreign_record_i = 0;
if(!ptpClock->slaveOnly &&
ptpClock->clockQuality.clockClass != 255) {
m1(rtOpts,ptpClock);
toState(PTP_MASTER, rtOpts, ptpClock);
} else {
/*
* Force a reset when getting a timeout in state listening, that will lead to an IGMP reset
* previously this was not the case when we were already in LISTENING mode
*/
toState(PTP_LISTENING, rtOpts, ptpClock);
}
}
if (timerExpired(OPERATOR_MESSAGES_TIMER, ptpClock->itimer)) {
reset_operator_messages(rtOpts, ptpClock);
}
if (ptpClock->delayMechanism == E2E) {
if(timerExpired(DELAYREQ_INTERVAL_TIMER,
ptpClock->itimer)) {
DBG2("event DELAYREQ_INTERVAL_TIMEOUT_EXPIRES\n");
issueDelayReq(rtOpts,ptpClock);
}
} else if (ptpClock->delayMechanism == P2P) {
if (timerExpired(PDELAYREQ_INTERVAL_TIMER,
ptpClock->itimer)) {
DBGV("event PDELAYREQ_INTERVAL_TIMEOUT_EXPIRES\n");
issuePDelayReq(rtOpts,ptpClock);
}
/* FIXME: Path delay should also rearm its timer with the value received from the Master */
}
break;
case PTP_MASTER:
/*
* handle SLAVE timers:
* - Time to send new Sync
* - Time to send new Announce
* - Time to send new PathDelay
* (DelayResp has no timer - as these are sent and retransmitted by the slaves)
*/
if (timerExpired(SYNC_INTERVAL_TIMER, ptpClock->itimer)) {
DBGV("event SYNC_INTERVAL_TIMEOUT_EXPIRES\n");
issueSync(rtOpts, ptpClock);
}
if (timerExpired(ANNOUNCE_INTERVAL_TIMER, ptpClock->itimer)) {
DBGV("event ANNOUNCE_INTERVAL_TIMEOUT_EXPIRES\n");
issueAnnounce(rtOpts, ptpClock);
}
if (ptpClock->delayMechanism == P2P) {
if (timerExpired(PDELAYREQ_INTERVAL_TIMER,
ptpClock->itimer)) {
DBGV("event PDELAYREQ_INTERVAL_TIMEOUT_EXPIRES\n");
issuePDelayReq(rtOpts,ptpClock);
}
}
// TODO: why is handle() below expiretimer, while in slave is the opposite
handle(rtOpts, ptpClock);
if (ptpClock->slaveOnly || ptpClock->clockQuality.clockClass == 255)
toState(PTP_LISTENING, rtOpts, ptpClock);
break;
case PTP_DISABLED:
handle(rtOpts, ptpClock);
break;
default:
DBG("(doState) do unrecognized state\n");
break;
}
}
/* handle actions and events for 'port_state' */
void doState(PtpClock *ptpClock)
{
ptpClock->messageActivity = FALSE;
switch (ptpClock->portDS.portState)
{
case PTP_LISTENING:
case PTP_UNCALIBRATED:
case PTP_SLAVE:
case PTP_PRE_MASTER:
case PTP_MASTER:
case PTP_PASSIVE:
/*State decision Event*/
if (getFlag(ptpClock->events, STATE_DECISION_EVENT))
{
DBGV("event STATE_DECISION_EVENT\n");
clearFlag(ptpClock->events, STATE_DECISION_EVENT);
ptpClock->recommendedState = bmc(ptpClock);
switch (ptpClock->recommendedState)
{
case PTP_MASTER:
case PTP_PASSIVE:
if (ptpClock->defaultDS.slaveOnly || ptpClock->defaultDS.clockQuality.clockClass == 255)
{
ptpClock->recommendedState = PTP_LISTENING;
}
break;
default:
break;
}
}
break;
default:
break;
}
switch (ptpClock->recommendedState)
{
case PTP_MASTER:
switch (ptpClock->portDS.portState)
{
case PTP_PRE_MASTER:
if (timerExpired(QUALIFICATION_TIMEOUT, ptpClock->itimer))
{
toState(ptpClock, PTP_MASTER);
}
break;
case PTP_MASTER:
break;
default:
toState(ptpClock, PTP_PRE_MASTER);
break;
}
break;
case PTP_PASSIVE:
if (ptpClock->portDS.portState != ptpClock->recommendedState)
{
toState(ptpClock, PTP_PASSIVE);
}
break;
case PTP_SLAVE:
switch (ptpClock->portDS.portState)
{
case PTP_UNCALIBRATED:
if (getFlag(ptpClock->events, MASTER_CLOCK_SELECTED))
{
DBG("event MASTER_CLOCK_SELECTED\n");
clearFlag(ptpClock->events, MASTER_CLOCK_SELECTED);
toState(ptpClock, PTP_SLAVE);
}
if (getFlag(ptpClock->events, MASTER_CLOCK_CHANGED))
{
DBG("event MASTER_CLOCK_CHANGED\n");
clearFlag(ptpClock->events, MASTER_CLOCK_CHANGED);
}
break;
case PTP_SLAVE:
if (getFlag(ptpClock->events, SYNCHRONIZATION_FAULT))
{
DBG("event SYNCHRONIZATION_FAULT\n");
clearFlag(ptpClock->events, SYNCHRONIZATION_FAULT);
toState(ptpClock, PTP_UNCALIBRATED);
}
if (getFlag(ptpClock->events, MASTER_CLOCK_CHANGED))
{
DBG("event MASTER_CLOCK_CHANGED\n");
clearFlag(ptpClock->events, MASTER_CLOCK_CHANGED);
toState(ptpClock, PTP_UNCALIBRATED);
}
break;
default:
toState(ptpClock, PTP_UNCALIBRATED);
break;
}
break;
case PTP_LISTENING:
if (ptpClock->portDS.portState != ptpClock->recommendedState)
{
toState(ptpClock, PTP_LISTENING);
}
break;
case PTP_INITIALIZING:
break;
default:
DBG("doState: unrecognized recommended state %d\n", ptpClock->recommendedState);
break;
}
switch (ptpClock->portDS.portState)
{
case PTP_INITIALIZING:
if (TRUE == doInit(ptpClock))
{
toState(ptpClock, PTP_LISTENING);
}
else
{
toState(ptpClock, PTP_FAULTY);
}
break;
case PTP_FAULTY:
/* imaginary troubleshooting */
DBG("event FAULT_CLEARED\n");
toState(ptpClock, PTP_INITIALIZING);
return;
case PTP_DISABLED:
handle(ptpClock);
break;
case PTP_LISTENING:
case PTP_UNCALIBRATED:
case PTP_SLAVE:
case PTP_PASSIVE:
if (timerExpired(ANNOUNCE_RECEIPT_TIMER, ptpClock->itimer))
{
DBGV("event ANNOUNCE_RECEIPT_TIMEOUT_EXPIRES\n");
ptpClock->foreignMasterDS.count = 0;
ptpClock->foreignMasterDS.i = 0;
if (!(ptpClock->defaultDS.slaveOnly || ptpClock->defaultDS.clockQuality.clockClass == 255))
{
m1(ptpClock);
ptpClock->recommendedState = PTP_MASTER;
toState(ptpClock, PTP_MASTER);
}
else if (ptpClock->portDS.portState != PTP_LISTENING)
{
toState(ptpClock, PTP_LISTENING);
}
break;
}
handle(ptpClock);
break;
case PTP_MASTER:
if (timerExpired(SYNC_INTERVAL_TIMER, ptpClock->itimer))
{
DBGV("event SYNC_INTERVAL_TIMEOUT_EXPIRES\n");
issueSync(ptpClock);
}
if (timerExpired(ANNOUNCE_INTERVAL_TIMER, ptpClock->itimer))
{
DBGV("event ANNOUNCE_INTERVAL_TIMEOUT_EXPIRES\n");
issueAnnounce(ptpClock);
}
handle(ptpClock);
issueDelayReqTimerExpired(ptpClock);
break;
default:
DBG("doState: do unrecognized state %d\n", ptpClock->portDS.portState);
break;
}
}
SoundGenerator::SoundGenerator(QObject *parent)
: QObject(parent)
, m_clockCount(0)
, m_function(Inactive)
, m_device(0)
, m_timer(new QTimer(this))
{
m_channelA.fineTune = 0;
m_channelA.coarseTune = 0;
m_channelA.amplitudeLevel = 0;
m_channelA.mixValue = 0;
m_channelA.toneOutput = 0;
m_channelA.counter = 0;
m_channelB.fineTune = 0;
m_channelB.coarseTune = 0;
m_channelB.amplitudeLevel = 0;
m_channelB.mixValue = 0;
m_channelB.toneOutput = 0;
m_channelB.counter = 0;
m_channelC.fineTune = 0;
m_channelC.coarseTune = 0;
m_channelC.amplitudeLevel = 0;
m_channelC.mixValue = 0;
m_channelC.toneOutput = 0;
m_channelC.counter = 0;
m_envelope.fineTune = 0;
m_envelope.coarseTune = 0;
m_envelope.counter = 0;
m_envelope.shapePosition = 0;
m_envelope.shouldHold = true;
m_mixerA.isChannelNoiseOn = false;
m_mixerA.isChannelToneOn = false;
m_mixerB.isChannelNoiseOn = false;
m_mixerB.isChannelToneOn = false;
m_mixerC.isChannelNoiseOn = false;
m_mixerC.isChannelToneOn = false;
m_noise.period = 0;
m_noise.rng = 1;
m_noise.noiseOutput = 0xff;
m_noise.counter = 0;
QList<byte_t> shape;
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 0;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0
<< 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15;
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0 << 15;
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15;
ENVELOPE_SHAPES.append(shape);
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15
<< 15 << 14 << 13 << 12 << 11 << 10 << 9 << 8 << 7 << 6 << 5 << 4 << 3 << 2 << 1 << 0;
ENVELOPE_SHAPES.append(shape);
shape.clear();
shape << 0 << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10 << 11 << 12 << 13 << 14 << 15 << 0;
ENVELOPE_SHAPES.append(shape);
m_envelope.currentShape = ENVELOPE_SHAPES[0];
m_audioBuffer.resize(882000);
m_bufferPos = 0;
m_bufferPtr = reinterpret_cast<qint8 *>(m_audioBuffer.data());
connect(m_timer, SIGNAL(timeout()), SLOT(timerExpired()));
m_timer->start(20);
}
void EventApplet::init()
{
KConfigGroup cg = config();
disabledResources = cg.readEntry("DisabledResources", QStringList());
QString normalEventFormat = cg.readEntry("NormalEventFormat", QString("%{startDate} %{startTime} %{summary}"));
QString todoFormat = cg.readEntry("TodoFormat", QString("%{dueDate} %{summary}"));
QString noDueDateFormat = cg.readEntry("NoDueDateFormat", QString("%{summary}"));
int dtFormat = cg.readEntry("DateFormat", ShortDateFormat);
QString dtString = cg.readEntry("CustomDateFormat", QString("dd.MM."));
m_period = cg.readEntry("Period", 365);
m_urgency = cg.readEntry("UrgencyTime", 15);
m_birthdayUrgency = cg.readEntry("BirthdayUrgencyTime", 14);
m_urgentBg = QColor(cg.readEntry("UrgentColor", QString("#FF0000")));
m_urgentBg.setAlphaF(cg.readEntry("UrgentOpacity", 10)/100.0);
m_colors.insert(urgentColorPos, m_urgentBg);
m_passedFg = QColor(cg.readEntry("PassedColor", QString("#C3C3C3")));
m_colors.insert(passedColorPos, m_passedFg);
m_todoBg = QColor(cg.readEntry("TodoColor", QString("#FFD235")));
m_todoBg.setAlphaF(cg.readEntry("TodoOpacity", 10)/100.0);
m_colors.insert(todoColorPos, m_todoBg);
m_showFinishedTodos = cg.readEntry("ShowFinishedTodos", FALSE);
m_finishedTodoBg = QColor(cg.readEntry("FinishedTodoColor", QString("#6FACE0")));
m_finishedTodoBg.setAlphaF(cg.readEntry("FinishedTodoOpacity", 10)/100.0);
m_colors.insert(finishedTodoColorPos, m_finishedTodoBg);
int opacity = cg.readEntry("KOOpacity", 10);
setupCategoryColors(opacity);
QString koConfigPath = KStandardDirs::locateLocal("config", "korganizerrc");
m_categoryColorWatch = new KDirWatch(this);
m_categoryColorWatch->addFile(koConfigPath);
connect(m_categoryColorWatch, SIGNAL(created(const QString &)), this, SLOT(koConfigChanged()));
connect(m_categoryColorWatch, SIGNAL(dirty(const QString &)), this, SLOT(koConfigChanged()));
connect(Plasma::Theme::defaultTheme(), SIGNAL(themeChanged()), this, SLOT(plasmaThemeChanged()));
QStringList keys, values;
keys << i18n("Birthday") << i18n("Holiday");
values << QString("%{startDate} %{yearsSince}. %{summary}") << QString("%{startDate} %{summary} to %{endDate}");
keys = cg.readEntry("CategoryFormatsKeys", keys);
values = cg.readEntry("CategoryFormatsValues", values);
for (int i = 0; i < keys.size(); ++i) {
m_categoryFormat.insert(keys.at(i), values.at(i));
}
QStringList headerList;
headerList << i18n("Today") << i18n("Events of today") << QString::number(0);
headerList << i18n("Tomorrow") << i18n("Events for tomorrow") << QString::number(1);
headerList << i18n("Week") << i18n("Events of the next week") << QString::number(2);
headerList << i18n("Next 4 weeks") << i18n("Events for the next 4 weeks") << QString::number(8);
headerList << i18n("Later") << i18n("Events later than 4 weeks") << QString::number(29);
m_headerItemsList = cg.readEntry("HeaderItems", headerList);
m_delegate = new EventItemDelegate(this, normalEventFormat, todoFormat, noDueDateFormat, dtFormat, dtString);
m_delegate->setCategoryFormats(m_categoryFormat);
graphicsWidget();
Plasma::ToolTipManager::self()->registerWidget(this);
createToolTip();
lastCheckTime = QDateTime::currentDateTime();
m_timer = new QTimer();
connect(m_timer, SIGNAL(timeout()), this, SLOT(timerExpired()));
QTimer::singleShot(0, this, SLOT(setupModel()));
}
/* handle actions and events for 'port_state' */
void doState(PtpClock *ptpClock)
{
UInteger8 state;
ptpClock->message_activity = FALSE;
switch(ptpClock->port_state)
{
case PTP_LISTENING:
case PTP_PASSIVE:
case PTP_SLAVE:
case PTP_MASTER:
if(ptpClock->record_update)
{
ptpClock->record_update = FALSE;
state = bmc(ptpClock->foreign, ptpClock);
if(state != ptpClock->port_state)
toState(state, ptpClock);
}
break;
default:
break;
}
switch(ptpClock->port_state)
{
case PTP_FAULTY:
/* imaginary troubleshooting */
DBG("event FAULT_CLEARED\n");
toState(PTP_INITIALIZING, ptpClock);
return;
case PTP_LISTENING:
case PTP_PASSIVE:
case PTP_UNCALIBRATED:
case PTP_SLAVE:
handle(ptpClock);
if(timerExpired(SYNC_RECEIPT_TIMER, ptpClock->itimer))
{
DBG("event SYNC_RECEIPT_TIMEOUT_EXPIRES\n");
ptpClock->number_foreign_records = 0;
ptpClock->foreign_record_i = 0;
if(!ptpClock->runTimeOpts.slaveOnly && ptpClock->clock_stratum != 255)
{
m1(ptpClock);
toState(PTP_MASTER, ptpClock);
}
else if(ptpClock->port_state != PTP_LISTENING)
toState(PTP_LISTENING, ptpClock);
}
break;
case PTP_MASTER:
if(timerExpired(SYNC_INTERVAL_TIMER, ptpClock->itimer))
{
DBGV("event SYNC_INTERVAL_TIMEOUT_EXPIRES\n");
issueSync(ptpClock);
}
handle(ptpClock);
if(ptpClock->runTimeOpts.slaveOnly || ptpClock->clock_stratum == 255)
toState(PTP_LISTENING, ptpClock);
break;
case PTP_DISABLED:
handle(ptpClock);
break;
default:
DBG("do unrecognized state\n");
break;
}
}
/**
* switchCounterCount - count the number of subsequent switch toggles
*
* @param me
* @param i - value of the input signal
* @return value of the counter. It can be retrieved calling
*/
unsigned char switchCounterCount(SwitchCounter* me, bool i) {
i = debounceUpdate(me->ireader, i);
if (me->button==0) { // bistable switch
switch (me->state) {
case 0: // steady state: input=0
if (i) { // if input goes high
me->cntr++; // counter is incremented
timerStart(me->timer, me->timeout); // timer is retriggered
me->state++;
} else if (timerExpired(me->timer)) { // if input stay low for the time
me->cntr = 0; // counter goes to 0
}
break;
case 1:
if (i) { // if input stay high
if (timerExpired(me->timer)) { // after the timeout
me->cntr = 0; // counter goes to 0
me->state++;
}
} else { // if input goes low
timerStart(me->timer, 500); // for 1 s
me->state--;
}
break;
case 2:
if (!i) { // if input goes low
me->state = 0;
}
break;
}
} else { // monostable button
switch (me->state) {
case 0: // steady state: input=0
ZERO:
if (i) { // on button press
me->cntr++; // counter is incremented
me->state++; // go next state
} else if (timerExpired(me->timer)) { // if input stay low for the timeout
me->cntr = 0; // counter goes to 0
}
break;
case 1: // button is pressed: wait till release
if (!i) { // on button release
timerStart(me->timer, 1500); // 1 s timer
me->state++; // go next state
}
break;
case 2: // button just released
if (i) { // if button pressed again
me->state = 0;
goto ZERO;
}
if (timerExpired(me->timer)) { // if 1 s elapsed
timerStart(me->timer, me->timeout); // timeout is retriggered
me->state = 0;
}
break;
}
}
return me->cntr;
}
void KHelpMenu::dialogFinished()
{
QTimer::singleShot( 0, this, SLOT(timerExpired()) );
}
GLWidget::GLWidget(QWidget *parent)
: QGLWidget(QGLFormat(QGL::SampleBuffers), parent)
{
// set default look at
lookAt[0]=0;
lookAt[1]=0;
lookAt[2]=10;
// set initial light position
lightPos = { 0,0,0,1 };
// load the model and move it down 100 units
modelLocation[0] = 0;
modelLocation[1] = -100;
modelLocation[2] = 0;
qtPurple = QColor::fromCmykF(0.39, 0.39, 0.0, 0.0);
// no models loaded yet so set it to a invalid id
modelDisplayList = -1;
numMaterial = 0;
// create new timer to handle animation
t = new QTimer();
// connect the timers timeout signal to the timer expired slot
connect(t, SIGNAL(timeout()), this, SLOT(timerExpired()));
// start the timer with a 30ms timout (30ms ~ 30Hz)
t->start(30);
// steal all keyboard inputs
this->grabKeyboard();
theta = 180;
phi = 0;
// update the GL context
updateGL();
// go load the terain
loadNewModel(GL_TEXTURE0, "./models/terrain1.obj");
this->terrainModel = getModelByName("terrain1.obj");
// activate all the textures
glActiveTexture(GL_TEXTURE1);
loadTexture("./models/Grass.jpg");
glActiveTexture(GL_TEXTURE2);
loadTexture("./models/WoodChips.jpg");
glActiveTexture(GL_TEXTURE3);
loadTexture("./models/SkyBox.jpg");
// build the skybox
this->skyBoxModel.setDisplayID( buildSkyBox(490));
// activate the skybox texture
glActiveTexture(GL_TEXTURE0);
// load all shaders
program.removeAllShaders();
program.addShaderFromSourceFile(QGLShader::Vertex, "./shaders/perpixelphong.vert");
program.addShaderFromSourceFile(QGLShader::Fragment, "./shaders/perpixelphong.frag");
// compile and bind the shader
program.bind();
// update all uniform values
program.setUniformValue("heightMap",0);
program.setUniformValue("baseMap1", 1);
program.setUniformValue("baseMap2", 2);
program.setUniformValue("skybox", 3);
program.setUniformValue("mode", int(0));
program.setUniformValue("envMap", 3);
program.setUniformValue("numWaves", int(4));
// set the parameter for the sum of sins equation
waveAmp = {1.5,1.5,1,2, 10,10,10,10};
wavelength= {50,30,50,30, 10,10,10,10};
waveSpeed = {10,20,10,10, 10,10,10,10};
direction[0] = QVector2D(-.2,.5);
direction[1] = QVector2D(.5, -.3);
direction[2] = QVector2D(0,1);
direction[3] = QVector2D(-.1, -.8);
program.setUniformValueArray("direction", direction, 4);
program.setUniformValueArray("amplitude", waveAmp, 8,1);
program.setUniformValueArray("wavelength", wavelength, 8,1);
program.setUniformValueArray("speed", waveSpeed, 8,1);
}
