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; }