double dumptime() {
static unsigned prevMicroSec = getMicroseconds();
unsigned curMicroSec = getMicroseconds();
double res = (curMicroSec - prevMicroSec)/1000000.0;
prevMicroSec = curMicroSec;
return res;
}
// workerProcessCron is the cron of worker process, it must be called before
// worker process initialized.
//
// `fake_func` is used by spawnFakeWorker and call it every cron.
void workerProcessCron(void (*fake_func)(void *data), void *data)
{
static long long max_cron_interval = 0;
struct timeval nowval;
long long interval;
int refresh_seconds;
void (*worker_cron)();
refresh_seconds = Server.stat_refresh_seconds;
worker_cron = WorkerProcess->worker->cron;
while (WorkerProcess->alive) {
arrayEach(WorkerProcess->apps, appCronRun);
if (worker_cron)
worker_cron();
if (fake_func)
fake_func(data);
processEvents(WorkerProcess->center, WHEATSERVER_CRON_MILLLISECONDS);
if (WorkerProcess->ppid != getppid()) {
wheatLog(WHEAT_NOTICE, "parent change, worker shutdown");
WorkerProcess->alive = 0;
}
clientsCron();
if (Server.cron_time.tv_sec - WorkerProcess->refresh_time > refresh_seconds) {
sendStatPacket(WorkerProcess);
WorkerProcess->refresh_time = Server.cron_time.tv_sec;
}
// Get the max worker cron interval for statistic info
gettimeofday(&nowval, NULL);
interval = getMicroseconds(nowval) - getMicroseconds(Server.cron_time);
if (interval > max_cron_interval) {
max_cron_interval = interval;
getStatValByName("Max worker cron interval") = interval;
}
Server.cron_time = nowval;
}
// Stop accept new client
deleteEvent(WorkerProcess->center, Server.ipfd, EVENT_READABLE|EVENT_WRITABLE);
WorkerProcess->refresh_time = Server.cron_time.tv_sec;
while (Server.cron_time.tv_sec - WorkerProcess->refresh_time < Server.graceful_timeout) {
processEvents(WorkerProcess->center, WHEATSERVER_CRON_MILLLISECONDS);
gettimeofday(&Server.cron_time, NULL);
}
}
static PyObject *convert( const posix_time::ptime &t )
{
if ( t.is_special() )
{
PyErr_SetString(PyExc_ValueError, "Cannot convert out-of-range ptime to datetime");
throw_error_already_set();
}
gregorian::date date = t.date();
posix_time::time_duration dur = t.time_of_day();
return PyDateTime_FromDateAndTime(
static_cast<int>( date.year() ),
static_cast<int>( date.month() ),
static_cast<int>( date.day() ),
static_cast<int>( dur.hours() ),
static_cast<int>( dur.minutes() ),
static_cast<int>( dur.seconds() ),
getMicroseconds( dur )
);
}
std::uint64_t getUptimeMicroseconds() const
{
return getMicroseconds() - started_at_usec_;
}
MonotonicTimekeeper() :
started_at_usec_(getMicroseconds())
{ }
void EncUpdate(void) {
int i;
int32_t timestamp0, timestamp1, timestamp;
/* Declare local variables */
unsigned int EncBit_CNT;
unsigned int CurEncPos[ENCNUM];
bool phase_sync;
phase_sync = true;
//trigger for start
ENC_CLOCK = 0;
timestamp0 = getMicroseconds();
timestamp1 = timestamp0+ENC_HALF_PEROID;
//work
/* Initialize local variables */
for (i = 0; i < ENCNUM; ++i) {
CurEncPos[i] = 0;
}
//wait
timestamp = getMicroseconds();
if (timestamp>=timestamp1) {
phase_sync = false;
}
while (timestamp<timestamp1) {
timestamp = getMicroseconds();
}
/* Read 13-bit resolution Digital Encoders */
/* Synchro-Serial Interface reading */
for (EncBit_CNT = 0; EncBit_CNT < 13; ++EncBit_CNT) {
// Trigger ENC_CLOCK to a logical high state
ENC_CLOCK = 1;
timestamp1 += ENC_HALF_PEROID;
//work
// Read Encoder data
for (i = 0; i < ENCNUM; ++i) {
CurEncPos[i] <<= 0b1;
}
//wait
timestamp = getMicroseconds();
if (timestamp>=timestamp1) {
phase_sync = false;
}
while (timestamp<timestamp1) {
timestamp = getMicroseconds();
}
// Trigger ENC_CLOCK to a logical low state
ENC_CLOCK = 0;
timestamp1 += ENC_HALF_PEROID;
//work
// Read Encoder data
for (i = 0; i < ENCNUM; ++i) {
if (*(enc_data[i].port) & enc_data[i].mask)
CurEncPos[i] |= 0b1;
}
//wait
timestamp = getMicroseconds();
if (timestamp>=timestamp1) {
phase_sync = false;
break;
}
while (timestamp<timestamp1) {
timestamp = getMicroseconds();
}
}
//End. Set ENC_CLOCK to a logical high state
ENC_CLOCK = 1;
if (phase_sync) {
for (i = 0; i < ENCNUM; ++i) {
EncPos[i] = CurEncPos[i];
}
}
}
// Performs a spin wait for the specified number of microseconds. Exact microsecond accuracy is not super important here. It is, however, at the very least accurate to the millisecond.
void busyWait(time_t us){
us += getMicroseconds();
while (getMicroseconds() < us);
}
double Time::getSeconds()
{
return getMicroseconds() * 0.000001;
}
int64_t getMicrosecondsRealtime() {
return getMicroseconds(CLOCK_REALTIME);
}
int64_t getMicrosecondsMonotonic() {
return getMicroseconds(CLOCK_MONOTONIC);
}
int64_t getMilliseconds() const
{
return int64_t(0.5 + getMicroseconds() / 1000.0);
}
void SoundplaneOSCOutput::processSoundplaneMessage(const SoundplaneDataMessage* msg)
{
static const MLSymbol startFrameSym("start_frame");
static const MLSymbol touchSym("touch");
static const MLSymbol onSym("on");
static const MLSymbol continueSym("continue");
static const MLSymbol offSym("off");
static const MLSymbol controllerSym("controller");
static const MLSymbol xSym("x");
static const MLSymbol ySym("y");
static const MLSymbol xySym("xy");
static const MLSymbol zSym("z");
static const MLSymbol toggleSym("toggle");
static const MLSymbol endFrameSym("end_frame");
static const MLSymbol matrixSym("matrix");
static const MLSymbol nullSym;
if (!mActive) return;
MLSymbol type = msg->mType;
MLSymbol subtype = msg->mSubtype;
int voiceIdx, offset;
float x, y, z, dz, note, vibrato;
if(type == startFrameSym)
{
const uint64_t dataPeriodMicrosecs = 1000*1000 / mDataFreq;
mCurrFrameStartTime = getMicroseconds();
if (mCurrFrameStartTime > mLastFrameStartTime + (uint64_t)dataPeriodMicrosecs)
{
mLastFrameStartTime = mCurrFrameStartTime;
mTimeToSendNewFrame = true;
}
else
{
mTimeToSendNewFrame = false;
}
mGotNoteChangesThisFrame = false;
mGotMatrixThisFrame = false;
for(int i=0; i < kSoundplaneMaxTouches; ++i)
{
mPrevPortOffsetsByTouch[i] = mPortOffsetsByTouch[i];
}
// update all voice states
for(int offset=0; offset < kNumUDPPorts; ++offset)
{
for(int voiceIdx=0; voiceIdx < kSoundplaneMaxTouches; ++voiceIdx)
{
OSCVoice& v = mOSCVoices[offset][voiceIdx];
if (v.mState == kVoiceStateOff)
{
v.mState = kVoiceStateInactive;
}
}
}
}
else if(type == touchSym)
{
// get incoming touch data from message
voiceIdx = msg->mData[0];
x = msg->mData[1];
y = msg->mData[2];
z = msg->mData[3];
dz = msg->mData[4];
note = msg->mData[5];
vibrato = msg->mData[6];
offset = msg->mOffset;
mPortOffsetsByTouch[voiceIdx] = offset;
// update new voice state for incoming touch
OSCVoice& v = mOSCVoices[offset][voiceIdx];
v.x = x;
v.y = y;
v.z = z;
v.note = note + vibrato;
if(subtype == onSym)
{
v.startX = x;
v.startY = y;
// send dz (velocity) as first z value
v.z = dz;
v.mState = kVoiceStateOn;
mGotNoteChangesThisFrame = true;
}
if(subtype == continueSym)
{
v.mState = kVoiceStateActive;
}
if(subtype == offSym)
{
if((v.mState == kVoiceStateActive) || (v.mState == kVoiceStateOn))
{
v.mState = kVoiceStateOff;
v.z = 0;
mGotNoteChangesThisFrame = true;
}
}
}
else if(type == controllerSym)
{
// when a controller message comes in, make a local copy of the message and store by zone ID.
int zoneID = msg->mData[0];
mMessagesByZone[zoneID] = *msg;
}
else if(type == matrixSym)
{
// store matrix to send with bundle
mGotMatrixThisFrame = true;
mMatrixMessage = *msg;
}
else if(type == endFrameSym)
{
if(mGotNoteChangesThisFrame || mTimeToSendNewFrame)
{
sendFrame();
}
// format and send matrix in OSC blob if we got one.
// matrix is always sent to the default port.
if(mGotMatrixThisFrame)
{
osc::OutboundPacketStream& p = getPacketStreamForOffset(0);
UdpTransmitSocket& socket = getTransmitSocketForOffset(0);
p << osc::BeginMessage( "/t3d/matrix" );
p << osc::Blob( &(msg->mMatrix), sizeof(msg->mMatrix) );
p << osc::EndMessage;
mGotMatrixThisFrame = false;
socket.Send( p.Data(), p.Size() );
}
}
}
int Milliseconds::getTime() const
{
return (getSeconds()*1000) + (getMicroseconds()/1000);
};
