static void output_close(struct hfmodem_state *dev)
{
/* release regions used for PTT output */
output_status(dev, 0);
if (dev->ptt_out.flags & SP_SER)
release_region(dev->ptt_out.seriobase, SER_EXTENT);
if (dev->ptt_out.flags & SP_PAR)
parport_release(dev->ptt_out.pardev);
if (dev->ptt_out.flags & SP_MIDI)
release_region(dev->ptt_out.midiiobase, MIDI_EXTENT);
dev->ptt_out.flags = 0;
}
static int output_response(request_rec *r, SV *res)
{
dTHX;
AV *res_av;
SV **status;
SV **headers;
AV *headers_av;
SV **body;
int rc;
if (!SvROK(res) || SvTYPE(SvRV(res)) != SVt_PVAV) {
server_error(r, "response must be an array reference");
return HTTP_INTERNAL_SERVER_ERROR;
}
res_av = (AV *) SvRV(res);
if (av_len(res_av) != 2) {
server_error(r, "response must have 3 elements");
return HTTP_INTERNAL_SERVER_ERROR;
}
status = av_fetch(res_av, 0, 0);
if (!SvOK(*status)) {
server_error(r, "response status must be a scalar value");
return HTTP_INTERNAL_SERVER_ERROR;
}
rc = output_status(r, *status);
if (rc != OK) return rc;
headers = av_fetch(res_av, 1, 0);
if (!SvROK(*headers) || SvTYPE(SvRV(*headers)) != SVt_PVAV) {
server_error(r, "response headers must be an array reference");
return HTTP_INTERNAL_SERVER_ERROR;
}
headers_av = (AV *) SvRV(*headers);
if ((av_len(headers_av) + 1) % 2 != 0) {
server_error(r, "num of response headers must be even");
return HTTP_INTERNAL_SERVER_ERROR;
}
rc = output_headers(r, headers_av);
if (rc != OK) return rc;
body = av_fetch(res_av, 2, 0);
if (!SvROK(*body)) {
server_error(r, "response body must be a reference");
return HTTP_INTERNAL_SERVER_ERROR;
}
rc = output_body(r, *body);
return rc;
}
static void output_open(struct hfmodem_state *dev)
{
dev->ptt_out.flags = 0;
if (dev->ptt_out.seriobase > 0) {
if (!check_region(dev->ptt_out.seriobase, SER_EXTENT)) {
request_region(dev->ptt_out.seriobase, SER_EXTENT, "hfmodem ser ptt");
dev->ptt_out.flags |= SP_SER;
outb(0, UART_IER(dev->ptt_out.seriobase));
/* 5 bits, 1 stop, no parity, no break, Div latch access */
outb(0x80, UART_LCR(dev->ptt_out.seriobase));
outb(0, UART_DLM(dev->ptt_out.seriobase));
outb(1, UART_DLL(dev->ptt_out.seriobase)); /* as fast as possible */
/* LCR and MCR set by output_status */
} else
printk(KERN_WARNING "%s: PTT output: serial port at 0x%x busy\n",
hfmodem_drvname, dev->ptt_out.seriobase);
}
if (dev->ptt_out.pariobase > 0) {
if (parport_claim(dev->ptt_out.pardev))
printk(KERN_WARNING "%s: PTT output: parallel port at 0x%x busy\n",
hfmodem_drvname, dev->ptt_out.pariobase);
else
dev->ptt_out.flags |= SP_PAR;
}
if (dev->ptt_out.midiiobase > 0) {
if (!check_region(dev->ptt_out.midiiobase, MIDI_EXTENT)) {
request_region(dev->ptt_out.midiiobase, MIDI_EXTENT, "hfmodem midi ptt");
dev->ptt_out.flags |= SP_MIDI;
} else
printk(KERN_WARNING "%s: PTT output: midi port at 0x%x busy\n",
hfmodem_drvname, dev->ptt_out.midiiobase);
}
output_status(dev, 0);
printk(KERN_INFO "%s: PTT output:", hfmodem_drvname);
if (dev->ptt_out.flags & SP_SER)
printk(" serial interface at 0x%x", dev->ptt_out.seriobase);
if (dev->ptt_out.flags & SP_PAR)
printk(" parallel interface at 0x%x", dev->ptt_out.pariobase);
if (dev->ptt_out.flags & SP_MIDI)
printk(" mpu401 (midi) interface at 0x%x", dev->ptt_out.midiiobase);
if (!dev->ptt_out.flags)
printk(" none");
printk("\n");
}
/**
* This is just a hard-coded message for now. Not really sure what we want
* out of it.
*/
void process_enviracom(ENVIRAMSG *msg) {
__u16 tempcode;
// We only process 'R' messages
if (msg->command != 0x40) {
return;
}
switch (msg->type) {
// M 1081 3D R 05 23 64 02 30 00 DC
case 0x1081:
break;
// M 1082 3D R 05 1B C6 02 30 00 45
// M 1084 3D R 08 2D 32 15 40 04 56 01 18 A0
// M 1085 3D R 08 28 C8 10 EA 05 6E 02 30 E3
// M 3114 3D R 03 01 C8 11 C3
case 0x3114:
break;
// Circulator status
// M 3180 3D R 01 C8 45
case 0x3180:
aquastatus.circulator = (msg->payload[0] == 0xC8) ? 1 : 0;
break;
// Boiler temperature
case 0x3200:
tempcode = (msg->payload[0] << 8) + (msg->payload[1]);
aquastatus.tempf = (tempcode * 0.018) + 32;
aquastatus.tempc = (tempcode / 100.0);
break;
// M 3E70 11 R 05 00 00 01 80 0C D7
case 0x3E70:
break;
}
output_status();
}
void statusDialog::display()
{
if (m_textWin != NULL) {
STATUS_PKT sp;
long hPos = GetScrollPos(m_textWin, SB_HORZ);
long vPos = GetScrollPos(m_textWin, SB_VERT);
long selStart;
long selEnd;
SendMessage(m_textWin, EM_GETSEL, (WPARAM)&selStart, (LPARAM)&selEnd);
SetWindowText(m_textWin, "");
sp.bs = NULL;
sp.context = this;
sp.callback = displayString;
output_status(&sp);
SendMessage(m_textWin, EM_SETSEL, selStart, selEnd);
SendMessage(m_textWin, WM_HSCROLL, MAKEWPARAM(SB_THUMBPOSITION, hPos), 0);
SendMessage(m_textWin, WM_VSCROLL, MAKEWPARAM(SB_THUMBPOSITION, vPos), 0);
}
}
int main(int argc, char *argv[])
{
/*
* Default config file. If we set a config file in startup switches, it
* will be re-filled by parse_options()
*/
cfgfile = APCCONF;
init_ups_struct(ups);
/* parse_options is self messaging on errors, so we need only to exit() */
if (parse_options(argc, argv))
exit(1);
check_for_config(&myUPS, cfgfile);
attach_driver(ups);
if (ups->driver == NULL)
Error_abort0("Apcupsd cannot continue without a valid driver.\n");
printf("Attached to driver: %s\n", ups->driver->driver_name);
device_open(ups);
device_get_capabilities(ups);
device_read_static_data(ups);
device_read_volatile_data(ups);
output_status(ups, 0, stat_open, stat_print, stat_close);
device_close(ups);
exit(0);
}
void Controller::done()
{
if( !segments_.empty() )
{
if( !last_sat_solution_.empty() )
{
logger.debug( mmlt_msg( "Adding separators and non-separable segments to triangulation..." ) );
for( const SegmentIndex& seg_index : last_sat_solution_ )
{
logger.debug(mmlt_msg("Segment index: %1").arg(seg_index));
const Segment& segment = segments_[seg_index];
triangulation_.insert_constraint(segment.source(), segment.target());
}
}
const Segment& shortest_triangulation_segment =
segments_[triangulation_.shortest_segment(segments_)];
logger.info(
mmlt_msg("shortest constrained triangulation segment: %1 (%2)")
.arg(shortest_triangulation_segment.to_string())
.arg(segment_length_to_string(shortest_triangulation_segment))
);
if( settings_.draw_triangulation )
{
draw_triangulation();
}
}
output_status();
logger.print(mmlt_msg("iterations=%1 gap=%2").arg(stats_.iteration).arg(stats_.gap()));
logger.time( mmlt_msg( "SAT solving" ), stats_.sat_solving_time);
}
static void output_device_count(t_sixaxis *x)
{
output_status(x, ps_total, device_count);
}
static void output_poll_time(t_sixaxis *x)
{
output_status(x, ps_poll, x->x_delay);
}
static void output_device_number(t_sixaxis *x)
{
output_status(x, ps_device, x->x_device_number);
}
static void output_open_status(t_sixaxis *x)
{
output_status(x, ps_open, x->x_device_open);
}
static void hfmodem_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
struct hfmodem_state *dev = (struct hfmodem_state *)dev_id;
unsigned int dmaptr;
__s16 *s;
unsigned int curfrag, nfrags;
int i;
hfmodem_time_t l1time;
dmaptr = dev->scops->intack(dev);
l1time = hfmodem_refclock_current(dev, ((SIZE+dmaptr-dev->dma.last_dmaptr) % SIZE) *
INC_SAMPLE, 1);
curfrag = (dev->dma.last_dmaptr = dmaptr) / HFMODEM_FRAGSAMPLES;
l1time -= INC_SAMPLE * (SIZE+dmaptr-dev->dma.fragptr*HFMODEM_FRAGSAMPLES) % SIZE;
sti();
/*
* handle receiving
*/
if (dev->dma.ptt_frames <= 0) {
while (dev->dma.fragptr != curfrag) {
if (dev->dma.fragptr < HFMODEM_EXCESSFRAGS) {
s = dev->dma.buf + SIZE + HFMODEM_FRAGSAMPLES * dev->dma.fragptr;
memcpy(s, s - SIZE, HFMODEM_FRAGSIZE);
} else
s = dev->dma.buf + HFMODEM_FRAGSAMPLES * dev->dma.fragptr;
if (dev->sbuf.kbuf && dev->sbuf.kptr && dev->sbuf.rem > 0) {
i = HFMODEM_FRAGSAMPLES;
if (i > dev->sbuf.rem)
i = dev->sbuf.rem;
memcpy(dev->sbuf.kptr, s, i * sizeof(s[0]));
dev->sbuf.rem -= i;
dev->sbuf.kptr += i;
}
hfmodem_input_samples(dev, l1time, INC_SAMPLE, s);
l1time += INC_FRAGMENT;
dev->dma.fragptr++;
if (dev->dma.fragptr >= HFMODEM_NUMFRAGS)
dev->dma.fragptr = 0;
}
/*
* check for output
*/
if (hfmodem_next_tx_event(dev, l1time) > (long)INC_FRAGMENT/2)
goto int_return;
/*
* start output
*/
output_status(dev, 1);
dev->scops->prepare_output(dev);
dev->dma.last_dmaptr = 0;
/*
* clock adjust
*/
l1time = hfmodem_refclock_current(dev, 0, 0);
/*
* fill first two fragments
*/
dev->dma.ptt_frames = 1;
for (i = 0; i < 2 && i < HFMODEM_NUMFRAGS; i++)
if (hfmodem_output_samples(dev, l1time+i*INC_FRAGMENT, INC_SAMPLE,
dev->dma.buf+i*HFMODEM_FRAGSAMPLES))
dev->dma.ptt_frames = i + 1;
dev->dma.lastfrag = 0;
dev->scops->trigger_output(dev);
/*
* finish already pending rx requests
*/
hfmodem_finish_pending_rx_requests(dev);
goto int_return;
}
/*
* handle transmitting
*/
nfrags = HFMODEM_NUMFRAGS + curfrag - dev->dma.lastfrag;
dev->dma.lastfrag = curfrag;
if (nfrags >= HFMODEM_NUMFRAGS)
nfrags -= HFMODEM_NUMFRAGS;
dev->dma.ptt_frames -= nfrags;
if (dev->dma.ptt_frames < 0)
dev->dma.ptt_frames = 0;
while (dev->dma.ptt_frames < HFMODEM_NUMFRAGS && dev->dma.ptt_frames < 4 &&
hfmodem_output_samples(dev, l1time+dev->dma.ptt_frames*INC_FRAGMENT,
INC_SAMPLE, dev->dma.buf + HFMODEM_FRAGSAMPLES *
((curfrag + dev->dma.ptt_frames) % HFMODEM_NUMFRAGS)))
dev->dma.ptt_frames++;
if (dev->dma.ptt_frames > 0)
goto int_return;
/*
* start receiving
*/
output_status(dev, 0);
dev->dma.last_dmaptr = 0;
dev->dma.lastfrag = 0;
dev->dma.fragptr = 0;
dev->dma.ptt_frames = 0;
dev->scops->prepare_input(dev);
dev->scops->trigger_input(dev);
hfmodem_refclock_current(dev, 0, 0); /* needed to reset the time difference */
int_return:
hfmodem_wakeup(dev);
}
bool Controller::iteration()
{
QElapsedTimer iteration_time;
iteration_time.start();
++stats_.iteration;
SATProblem sat_problem(intersection_graph_, segments_);
SegmentIndex new_bound = ( stats_.lower_bound() + stats_.upper_bound() + 1 ) / 2;
logger.debug( mmlt_msg( "Trying new lower bound: %1" )
.arg( new_bound ) );
sat_problem.set_short_segment_range( new_bound, stats_.upper_bound() );
{
SATSolution sat_solution;
QElapsedTimer sat_time;
sat_time.start();
cplex_solver_.solve_decision_problem(
settings_,
file_prefix_,
sat_problem,
sat_solution
);
stats_.sat_solving_time += sat_time.elapsed();
// there is no feasible triangulation
if(sat_solution.empty())
{
if(new_bound > stats_.lower_bound())
{
new_bound = new_bound - 1;
}
logger.debug( mmlt_msg( "New upper bound: %1" )
.arg(new_bound));
stats_.add_upper_bound(new_bound);
}
// there is a feasible triangulation
else
{
SegmentIndex sat_bound = sat_solution.shortest_segment();
if(sat_bound > stats_.upper_bound())
{
sat_bound = stats_.upper_bound();
}
logger.debug( mmlt_msg( "New lower bound: %1" ).arg(sat_bound) );
stats_.add_lower_bound(sat_bound);
// remember last solution
last_sat_solution_.clear();
std::copy(sat_solution.begin(), sat_solution.end(), std::back_inserter(last_sat_solution_));
if( settings_.draw_sat_solution )
{
draw_sat_solution();
}
}
}
logger.time( mmlt_msg( "iteration %1" )
.arg(stats_.iteration),
iteration_time.elapsed());
if( ( stats_.gap() < 1 )
|| ( stats_.iteration > settings_.max_iterations ) )
{
return false;
}
else
{
output_status();
return true;
}
}
bool Controller::start()
{
if(points_.empty())
{
logger.error( mmlt_msg( "There are no points!" ) );
return false;
}
if( settings_.complete_sat )
{
stats_.add_upper_bound( segments_.size() );
SATProblem sat_problem( intersection_graph_, segments_ );
sat_problem.set_short_segment_range( stats_.lower_bound(), stats_.upper_bound() );
SATSolution sat_solution;
QElapsedTimer sat_time;
sat_time.start();
cplex_solver_.solve_optimization_problem(
settings_,
file_prefix_,
sat_problem,
sat_solution
);
stats_.sat_solving_time += sat_time.elapsed();
// there is no feasible triangulation
if( sat_solution.empty() )
{
logger.error( mmlt_msg( "No feasible solution!" ) );
}
// there is a feasible triangulation
else
{
SegmentIndex sat_bound = sat_solution.shortest_segment();
if(sat_bound > stats_.upper_bound())
{
sat_bound = stats_.upper_bound();
}
stats_.add_lower_bound(sat_bound);
// remember solution
last_sat_solution_.clear();
std::copy(sat_solution.begin(), sat_solution.end(), std::back_inserter(last_sat_solution_));
if( settings_.draw_sat_solution )
{
draw_sat_solution();
}
}
return false;
}
else
{
pre_solving();
if( ( stats_.gap() < 1 )
|| ( settings_.max_iterations == 0 ) )
{
return false;
}
output_status();
}
return true;
}
