{ 0x3FFF, 126, 15 } // MFX
};
+Driver::TelemetryInfo ArduControl::telemetry_info[4] =
+{
+ { "voltage", "Voltage", "V", 1 },
+ { "current", "Current", "A", 2 },
+ { "cmd-queue-depth", "Cmd queue", "", 0 },
+ { "s88-latency", "S88 latency", "ms", 0 }
+};
+
ArduControl::ArduControl(const Options &opts):
serial(opts.get<string>(string(), "ttyUSB0")),
debug(opts.get<unsigned>("debug")),
return get_item(sensors, addr).state;
}
+const Driver::TelemetryInfo *ArduControl::enumerate_telemetry(unsigned i) const
+{
+ if(i<4)
+ return telemetry_info+i;
+ else
+ return 0;
+}
+
+float ArduControl::get_telemetry_value(const string &name) const
+{
+ if(name==telemetry_info[0].name)
+ return monitor.get_voltage();
+ else if(name==telemetry_info[1].name)
+ return monitor.get_current();
+ else if(name==telemetry_info[2].name)
+ return command_queue.size();
+ else if(name==telemetry_info[3].name)
+ return s88.get_latency()/Time::msec;
+ else
+ throw key_error(name);
+}
+
void ArduControl::tick()
{
Tag tag;
if(active_accessory && off_timeout)
{
+ bool success = (monitor.get_peak()>0.35f && monitor.get_current()<monitor.get_peak()-0.2f);
Time::TimeStamp t = Time::now();
- if(t>off_timeout)
+ if(t>off_timeout || success)
{
Accessory &acc = *active_accessory;
// Assume success if we were uncertain of the physical setting
if(acc.uncertain&bit)
acc.uncertain &= ~bit;
- else if(acc.kind==Accessory::TURNOUT && monitor.get_peak()<0.5f)
+ else if(acc.kind==Accessory::TURNOUT && !success)
{
if(debug>=1)
IO::print("Peak current only %.2f A\n", monitor.get_peak());
state(0),
uncertain((1<<bits)-1),
target(0),
- active_time(500*Time::msec)
+ active_time((bits*700)*Time::msec)
{ }
unsigned ArduControl::Accessory::create_state_command(unsigned b, bool c, char *buffer) const
return true;
}
+template<typename T>
+unsigned ArduControl::Queue<T>::size() const
+{
+ return items.size();
+}
+
template<typename T>
bool ArduControl::Queue<T>::empty() const
{
}
+bool ArduControl::CommandQueueTask::get_work(PendingCommand &cmd)
+{
+ return queue.pop(cmd);
+}
+
+void ArduControl::CommandQueueTask::push(const PendingCommand &cmd)
+{
+ queue.push(cmd);
+}
+
+
+ArduControl::Task::Task(const string &n, unsigned p):
+ name(n),
+ priority(p)
+{ }
+
+void ArduControl::Task::sleep(const Time::TimeDelta &dt)
+{
+ sleep_timeout = Time::now()+dt;
+}
+
+
+ArduControl::CommandQueueTask::CommandQueueTask():
+ Task("CommandQueue")
+{ }
+
+
ArduControl::RefreshTask::RefreshTask():
+ Task("Refresh", 2),
next(cycle.end()),
round(0),
loco(0),
++next;
if(next==cycle.end())
{
- next= cycle.begin();
+ next = cycle.begin();
++round;
}
}
ArduControl::S88Task::S88Task(ArduControl &c):
+ Task("S88"),
control(c),
n_octets(0),
- octets_remaining(0),
- delay(0)
+ octets_remaining(0)
{ }
bool ArduControl::S88Task::get_work(PendingCommand &cmd)
{
- if(delay)
- {
- --delay;
- return false;
- }
if(octets_remaining || !n_octets)
return false;
+ Time::TimeStamp t = Time::now();
+ if(last_poll)
+ latency = t-last_poll;
+ last_poll = t;
+
octets_remaining = n_octets;
cmd.command[0] = S88_READ;
cmd.command[1] = octets_remaining;
cmd.length = 2;
- delay = 4;
+ sleep(100*Time::msec);
return true;
}
ArduControl::MfxAnnounceTask::MfxAnnounceTask():
+ Task("MfxAnnounce", 1),
serial(0)
{ }
bool ArduControl::MfxAnnounceTask::get_work(PendingCommand &cmd)
{
- Time::TimeStamp t = Time::now();
- if(t<next)
- return false;
-
cmd.command[0] = MFX_ANNOUNCE;
cmd.command[1] = serial>>8;
cmd.command[2] = serial;
cmd.length = 3;
- next = t+400*Time::msec;
+
+ sleep(400*Time::msec);
return true;
}
ArduControl::MfxSearchTask::MfxSearchTask(ArduControl &c):
+ Task("MfxSearch", 1),
control(c),
next_address(1),
size(0),
return true;
}
- Time::TimeStamp t = Time::now();
- if(t<next)
- return false;
-
cmd.command[0] = MFX_SEARCH;
for(unsigned i=0; i<4; ++i)
cmd.command[1+i] = bits>>(24-i*8);
cmd.command[5] = size;
cmd.length = 6;
- next = t+200*Time::msec;
+ sleep(200*Time::msec);
if(control.debug>=1)
IO::print("Search %08X/%d\n", bits, size);
}
else
{
- next = Time::now()+2*Time::sec;
+ sleep(2*Time::sec);
bits = 0;
size = 0;
misses = 0;
ArduControl::MonitorTask::MonitorTask():
+ Task("Monitor"),
voltage(0),
current(0),
base_level(0),
bool ArduControl::MonitorTask::get_work(PendingCommand &cmd)
{
- Time::TimeStamp t = Time::now();
- if(t<next_poll)
- return false;
-
if(next_type==0)
cmd.command[0] = READ_INPUT_VOLTAGE;
else
cmd.command[0] = READ_TRACK_CURRENT;
cmd.length = 1;
- next_poll = t+200*Time::msec;
+ sleep(200*Time::msec);
next_type = (next_type+1)%5;
return true;
control(c),
done(false)
{
+ tasks.push_back(&control.command_queue);
tasks.push_back(&control.monitor);
tasks.push_back(&control.mfx_announce);
tasks.push_back(&control.mfx_search);
bool ArduControl::ControlThread::get_work(PendingCommand &cmd)
{
- if(control.command_queue.pop(cmd))
- return true;
+ Time::TimeStamp t = Time::now();
+
+ unsigned count = 0;
+ for(; (count<tasks.size() && tasks[count]->get_sleep_timeout()<=t); ++count) ;
+
+ for(; count>0; --count)
+ {
+ unsigned i = 0;
+ for(unsigned j=1; j<count; ++j)
+ if(tasks[j]->get_priority()<tasks[i]->get_priority())
+ i = j;
+
+ Task *task = tasks[i];
+ bool result = task->get_work(cmd);
- for(vector<Task *>::iterator i=tasks.begin(); i!=tasks.end(); ++i)
- if((*i)->get_work(cmd))
+ Time::TimeStamp st = max(task->get_sleep_timeout(), t);
+ for(; (i+1<tasks.size() && tasks[i+1]->get_sleep_timeout()<=st); ++i)
+ tasks[i] = tasks[i+1];
+ tasks[i] = task;
+
+ if(result)
+ {
+ if(control.debug>=2)
+ IO::print("Scheduled task %s\n", task->get_name());
return true;
+ }
+ }
// As fallback, send an idle packet for the MM protocol
cmd.command[0] = MOTOROLA_SPEED;
projects / r2c2.git / blobdiff