inline void motors_init (void) {
set_output(MOTOR0_DDR, MOTOR0_STEP_DD);
set_output(MOTOR0_DDR, MOTOR0_DIR_DD);
output_low(MOTOR0_PORT, MOTOR0_STEP);
output_low(MOTOR0_PORT, MOTOR0_DIR);
set_output(MOTOR1_DDR, MOTOR1_STEP_DD);
set_output(MOTOR1_DDR, MOTOR1_DIR_DD);
output_low(MOTOR1_PORT, MOTOR1_STEP);
output_low(MOTOR1_PORT, MOTOR1_DIR);
set_output(MOTOR2_DDR, MOTOR2_STEP_DD);
set_output(MOTOR2_DDR, MOTOR2_DIR_DD);
output_low(MOTOR2_PORT, MOTOR2_STEP);
output_low(MOTOR2_PORT, MOTOR2_DIR);
set_output(MOTOR3_DDR, MOTOR3_STEP_DD);
set_output(MOTOR3_DDR, MOTOR3_DIR_DD);
output_low(MOTOR3_PORT, MOTOR3_STEP);
output_low(MOTOR3_PORT, MOTOR3_DIR);
set_output(MOTOR4_DDR, MOTOR4_STEP_DD);
set_output(MOTOR4_DDR, MOTOR4_DIR_DD);
output_low(MOTOR4_PORT, MOTOR4_STEP);
output_low(MOTOR4_PORT, MOTOR4_DIR);
return;
}
static void timer_handler(int sig, siginfo_t *si, void *uc) {
struct node_data *data = si->si_value.sival_ptr;
struct timeval tv;
static unsigned long lasttime = 0;
static unsigned long cumulative = 0;
unsigned long newtime;
char percent;
int i;
gettimeofday(&tv, NULL);
newtime = (tv.tv_sec) * 1000 + (tv.tv_usec) / 1000;
/* calculate how far into the period we are */
cumulative += (newtime - lasttime);
lasttime = newtime;
if (cumulative >= PWM_PERIOD)
cumulative = 0;
percent = 100 * cumulative / PWM_PERIOD;
DEBUG("Output timer sig=%d: newtime=%ld cumulative=%ld percent=%d\n", sig, newtime, cumulative, percent);
for (i=0; i< NUM_NODES; i++){
if (data[i].output.power > percent && ! data[i].output.state)
set_output(&data[i], ON);
else if (data[i].output.power < percent && data[i].output.state)
set_output(&data[i], OFF);
}
}
int main(void) {
// initialize the direction of PORTD #6 to be an output
set_output(DDRC, LED1);
set_output(DDRC, LED2);
set_output(DDRC, LED3);
set_output(DDRD, LED4);
while (1) {
output_high(PORTC, LED1);
delay_ms(200);
output_high(PORTC, LED2);
delay_ms(200);
output_high(PORTC, LED3);
delay_ms(200);
output_high(PORTD, LED4);
delay_ms(200);
output_low(PORTC, LED1);
delay_ms(200);
output_low(PORTC, LED2);
delay_ms(200);
output_low(PORTC, LED3);
delay_ms(200);
output_low(PORTD, LED4);
delay_ms(200);
}
}
static inline void mode_strobe(void) {
while(1) {
set_output(STROBE_ON_OUT, 0);
delay_5ms(strobe_delay);
set_output(STROBE_OFF_OUT, 0);
delay_5ms(strobe_delay);
}
}
//Target side: true for side 1, false for side 2
void pick_side(bool targetSide){
if(targetSide){
set_output(false,SIDE_1_ENABLE);
set_output(true,SIDE_2_ENABLE);
}else{
set_output(false,SIDE_2_ENABLE);
set_output(true,SIDE_1_ENABLE);
}
}
void pick_input(uint8_t target){
if(target <= 3){
bool bit_low = target & 0x01;
bool bit_high = target & 0x02;
set_output(bit_low, BIT_0_CONTROL);
set_output(bit_high, BIT_1_CONTROL);
}
}
int main(void)
{
// Lights, backlights, and fan initialization
set_output(F1DD,F1PIN);
set_output(F2DD,F2PIN);
set_output(LDD,LPIN);
set_output(BLDD,BLPIN);
set_high(LPORT,BLPIN);
TCCR0A = 0xA3; // Timer0, channels A and B to Fast PWM Mode
TCCR2A = 0x23; // Timer2, channel B to Fast PWM Mode
TCCR0B = 0x05; // Prescaler is 1024 to give MOSFETS plenty of time
TCCR2B = 0x07;
OCR0A = 0xFF; // Rev up fans for 2s to avoid stalling
OCR0B = 0xFF;
_delay_ms(2000);
OCR0A = 0x7F; // Reduce fans to 50% power (127)
OCR0B = 0x7F;
uchar i;
for (i=0; i<3; i++) { // Blink lights to signal life
OCR2B = 0xFF;
_delay_ms(200);
OCR2B = 0x00;
_delay_ms(200);
}
OCR2B = 0x14; // Init lights at low brightness (20)
// LCD initialization
_delay_ms(200);
CHA_LCDinit();
CHA_LCDclr();
CHB_LCDinit();
CHB_LCDclr();
CHA_LCDstringLine(lcdinit,0); // LCD ready to go!
// USB initialization
wdt_enable(WDTO_1S); // Enable 1s watchdog timer
usbInit();
usbDeviceDisconnect(); // Enforce re-enumeration
for(i = 0; i<200; i++) { // Wait 200 ms
wdt_reset(); // Keep the watchdog happy
_delay_ms(1);
}
usbDeviceConnect();
sei(); // Enable interrupts after re-enumeration
CHB_LCDstringLine(usbinit,0); // USB ready to go!
while(1) { // Feed watchdog and poll USB forever
wdt_reset();
usbPoll();
}
return 0;
}
void javax_wukong_wknode_WuNodeLeds_void__init()
{
set_output(DDRK, 0);
set_output(DDRK, 1);
set_output(DDRK, 2);
set_output(DDRK, 3);
output_high(PORTK, 0);
output_high(PORTK, 1);
output_high(PORTK, 2);
output_high(PORTK, 3);
}
/* Init on board LEDs */
void led_init() {
drive(LED1);
drive(LED2);
set_output(LED1);
set_output(LED2);
delay_1s();
clr_output(LED1);
clr_output(LED2);
}
bool extract_boundary::run(viennamesh::algorithm_handle &)
{
mesh_handle input_mesh = get_required_input<mesh_handle>("mesh");
mesh_handle output_mesh = make_data<mesh_handle>();
point_container hole_points;
seed_point_container seed_points;
std::cerr << "Extract boundary of " << input_mesh.size() << " partitions" << std::endl;
//MY IMPLEMENTATION
output_mesh.resize(input_mesh.size());
for (size_t i = 0; i < input_mesh.size(); ++i)
{
hole_points.clear();
seed_points.clear();
input_mesh(i).set_full_layout();
viennagrid::extract_boundary( input_mesh(i), output_mesh(i), viennagrid::facet_dimension(input_mesh(i)) );
viennagrid::extract_seed_points( input_mesh(i), seed_points );
// viennagrid::extract_hole_points( input_mesh(), hole_points );
// set_output( "mesh", output_mesh ); //MY IMPLEMENTATION
// if (!hole_points.empty())
// {
// info(1) << "Extracted " << hole_points.size() << " hole points" << std::endl;
// for (point_container::const_iterator it = hole_points.begin(); it != hole_points.end(); ++it)
// info(1) << " " << *it << std::endl;
//
// point_handle output_hole_points = make_data<point>();
// output_hole_points.set( hole_points );
// set_output( "hole_points", output_hole_points );
// }
if (!seed_points.empty())
{
info(1) << "Extracted " << seed_points.size() << " seed points" << std::endl;
for (seed_point_container::const_iterator it = seed_points.begin(); it != seed_points.end(); ++it)
info(1) << " " << (*it).first << " -> " << (*it).second << std::endl;
seed_point_handle output_seed_points = make_data<seed_point>();
output_seed_points.set( seed_points );
set_output( "seed_points", output_seed_points );
}
}//end of for over input_mesh.size()
set_output( "mesh", output_mesh );
return true;
}
irom static void trigger_timer(gpio_t *gpio, bool_t onoff)
{
const gpio_config_entry_t *cfg = get_config(gpio);
if(onoff)
{
set_output(gpio, cfg->timer.direction == gpio_up ? 1 : 0);
gpio->timer.delay = cfg->timer.delay;
}
else
{
set_output(gpio, cfg->timer.direction == gpio_up ? 0 : 1);
gpio->timer.delay = 0;
}
}
/**
@brief Called by the parser when it is in one of the UESC states.
@param a Parser data.
@param wc Character.
*/
static void json_string_uesc(struct parser_arg *a, wchar_t wc)
{
if (wc == L'\0') {
set_state(a, END);
a->error = JSONERR_PREMATURE_EOF;
a->textidx--;
} else if (json_xdigit(wc) == 0xFF) {
set_state(a, END);
a->error = JSONERR_UNEXPECTED_TOKEN;
a->textidx--;
} else {
a->curr = a->curr << 4;
a->curr |= json_xdigit(wc);
if (a->state < UESC3) {
// continue reading all the input
a->state += 1;
} else {
// time to "publish" our unicode escape
if (a->prev == 0) {
// if there was no "prev", that means this might be the start of a
// surrogate pair. Check for that!
if (0xD800 <= a->curr && a->curr <= 0xDFFF) {
// yup, it's a surrogate pair!
a->prev = a->curr;
} else {
// nope, keep going
set_output(a, a->curr);
}
} else {
// there was a previous starting surrogate
if (0xD800 <= a->curr && a->curr <= 0xDFFF) {
// and this is also a surrogate
a->curr &= 0x03FF; // clear upper bits; keep lower 10
a->curr |= (a->prev & 0x03FF) << 10;
a->curr += 0x10000; // apparently this needs to happen (?)
a->prev = 0;
set_output(a, a->curr);
} else {
// not a legal surrogate to match previous surrogate.
a->state = END;
a->error = JSONERR_INVALID_SURROGATE;
}
}
set_state(a, INSTRING);
a->curr = 0;
}
}
}
bool hts_engine_call::execute()
{
set_input();
set_output();
engine_impl->synthesize();
return !output.is_stopped();
}
void DISCRETE_CLASS_FUNC(dss_input_stream, input_write)(int sub_node, UINT8 data )
{
UINT8 new_data = 0;
new_data = data;
if (m_data != new_data)
{
if (m_is_buffered)
{
/* Bring the system up to now */
m_buffer_stream->update();
m_data = new_data;
}
else
{
/* Bring the system up to now */
m_device->update_to_current_time();
m_data = new_data;
/* Update the node output here so we don't have to do it each step */
set_output(0, new_data * m_gain + m_offset);
}
}
}
static void start_pulse(const device_config *device)
{
ttl74123_t *chip = get_safe_token(device);
attotime duration = compute_duration(chip);
if (timer_running(chip))
{
/* retriggering, but not if we are called to quickly */
attotime delay_time = attotime_make(0, ATTOSECONDS_PER_SECOND * chip->intf->cap * 220);
if (attotime_compare(timer_timeelapsed(chip->timer), delay_time) >= 0)
{
timer_adjust_oneshot(chip->timer, duration, 0);
if (LOG) logerror("74123 %s: Retriggering pulse. Duration: %f\n", device->tag, attotime_to_double(duration));
}
else
{
if (LOG) logerror("74123 %s: Retriggering failed.\n", device->tag);
}
}
else
{
/* starting */
timer_adjust_oneshot(chip->timer, duration, 0);
set_output(device);
if (LOG) logerror("74123 %s: Starting pulse. Duration: %f\n", device->tag, attotime_to_double(duration));
}
}
//! set parameter
void sci_psk_dem::set(int param, var* p_v)
{
int iv;
double v;
var_vec *p_var_vec;
var_ivec *p_var_ivec;
p_var_vec = NULL;
p_var_ivec = NULL;
// p_v might be either var_vec, var_ivec or var_bvec
p_var_vec = dynamic_cast<var_vec *> (p_v);
if (p_var_vec == NULL) {
p_var_ivec = dynamic_cast<var_ivec *> (p_v);
if (p_var_ivec == NULL) {
throw sci_exception ("sci_psk_dem::set - p_v - bad cast");
}
}
switch (param)
{
case SCI_SIZE: // size constellation
if (p_var_vec) {
iv = (int)p_var_vec->v[0];
}
else if (p_var_ivec) {
iv = p_var_ivec->v[0];
}
else {
throw sci_exception ("sci_psk_dem::set - SCI_SIZE - bad cast");
}
set_size(iv);
break;
case SCI_SCALE:
if (p_var_vec) {
v = p_var_vec ->v[0];
} else {
throw sci_exception ("sci_psk_dem::set - SCI_SCALE - bad cast");
}
set_scale(v);
break;
case SCI_OUTPUT:
if (p_var_vec) {
iv = (int)p_var_vec->v[0];
}
else if (p_var_ivec) {
iv = p_var_ivec->v[0];
}
else {
throw sci_exception ("sci_psk_dem::set - SCI_OUTPUT - bad cast");
}
set_output( iv );
break;
default:
throw sci_exception ("sci_psk_mod::set - unknown param");
}
return;
};
int main(const int argc, const char* const argv[]) {
if (argc == 1) show_usage();
const std::string filename = argv[1];
if (filename == "-v" or filename == "--version") version_information();
if (argc >= 3 and filename == std::string(argv[2])) {
errout << "Output filename: \"" << argv[2] << "\" identical with input filename.";
std::exit(code(Error::file_writing));
}
if (argc >= 4 and filename == std::string(argv[3])) {
errout << "Log filename: \"" << argv[3] << "\" identical with input filename.";
std::exit(code(Error::file_writing));
}
const InOut::ConformityLevel conlev = (argc >= 5) ? InOut::s2conlev(argv[4]) : InOut::ConformityLevel::normal;
const LogLevel loglev = (argc >= 6) ? s2loglev(argv[5]) : LogLevel::normal;
set_output(argc, argv, solout, logout, errout);
const InOut::InputStream in(filename, errout);
Input::ReadDimacs rd(*in, errout, conlev);
const ClauseSets::DClauseSet& F = rd();
const Encodings::Encoding enc(F);
const Translations::Translation trans(F,enc);
const ClauseSets::CLS G = trans();
output(filename, conlev, F, enc, trans, G, loglev);
}
void main(void)
{
struct puzzleStruct puzzle;
struct buttonStruct buttons;
bool result = true;
//init code here
setup_int();
init_puzzle(&puzzle);
init_buttons(&buttons);
init_inputs();
//Enter main loop
for(;;) {
//Draw GUI
build_gui(&puzzle);
//Handle USB
update_puzzle(&puzzle,&buttons);
//Set output
set_output(&puzzle);
//Check inputs
update_buttons(&buttons);
//Read result
result = check_result(&puzzle);
}
}
Data_Exception::Data_Exception(const string &comment) {
_min = 0;
_max = 0;
_value = 0;
_comment = string(comment);
set_output();
}
static msg_t uart_thread(void *arg) {
(void)arg;
chRegSetThreadName("UART");
uartStart(&HW_UART_DEV, &uart_cfg);
palSetPadMode(HW_UART_TX_PORT, HW_UART_TX_PIN, PAL_MODE_ALTERNATE(HW_UART_GPIO_AF) |
PAL_STM32_OSPEED_HIGHEST |
PAL_STM32_PUDR_PULLUP);
palSetPadMode(HW_UART_RX_PORT, HW_UART_RX_PIN, PAL_MODE_ALTERNATE(HW_UART_GPIO_AF) |
PAL_STM32_OSPEED_HIGHEST |
PAL_STM32_PUDR_PULLUP);
systime_t time = chTimeNow();
for(;;) {
time += MS2ST(1);
if ((systime_t) ((float) chTimeElapsedSince(last_uart_update_time)
/ ((float) CH_FREQUENCY / 1000.0)) > (float)TIMEOUT) {
mcpwm_set_brake_current(-10.0);
} else {
set_output(out_received);
}
chThdSleepUntil(time);
}
return 0;
}
static void start_pulse(TTL74123_state *chip)
{
attotime duration = compute_duration(chip);
if (timer_running(chip))
{
/* retriggering, but not if we are called to quickly */
attotime delay_time = attotime_make(0, ATTOSECONDS_PER_SECOND * chip->intf->cap * 220);
if (attotime_compare(timer_timeelapsed(chip->timer), delay_time) >= 0)
{
timer_adjust(chip->timer, duration, 0, attotime_never);
if (LOG) logerror("74123 #%d: Retriggering pulse. Duration: %f\n", chip->which, attotime_to_double(duration));
}
else
{
if (LOG) logerror("74123 #%d: Retriggering failed.\n", chip->which);
}
}
else
{
/* starting */
timer_adjust(chip->timer, duration, 0, attotime_never);
set_output(chip);
if (LOG) logerror("74123 #%d: Starting pulse. Duration: %f\n", chip->which, attotime_to_double(duration));
}
}
Data_Exception::Data_Exception(long int min, long int max, long int value, const char *comment) {
_min = min;
_max = max;
_value = value;
_comment = string(comment);
set_output();
}
void ttl74123_device::start_pulse()
{
attotime duration = compute_duration();
if(timer_running())
{
/* retriggering, but not if we are called to quickly */
attotime delay_time = attotime(0, ATTOSECONDS_PER_SECOND * m_cap * 220);
if(m_timer->elapsed() >= delay_time)
{
m_timer->adjust(duration);
if (LOG) logerror("74123 %s: Retriggering pulse. Duration: %f\n", tag(), duration.as_double());
}
else
{
if (LOG) logerror("74123 %s: Retriggering failed.\n", tag());
}
}
else
{
/* starting */
m_timer->adjust(duration);
set_output();
if (LOG) logerror("74123 %s: Starting pulse. Duration: %f\n", tag(), duration.as_double());
}
}
inline void spi_slave_init (void) {
// slave select, dmx channel select, ready to transmit (ok) line
set_input(SPI_OUT_DDR, SPI_OUT_CHAN0_DDR);
set_input(SPI_OUT_DDR, SPI_OUT_CHAN1_DDR);
set_input(SPI_OUT_DDR, SPI_OUT_SS_DDR);
set_output(SPI_OUT_DDR, SPI_OUT_OK_DDR);
output_low(SPI_OUT_PORT, SPI_OUT_OK);
// pull-ups on inputs (hi-z doesn't work with 3 slaves)
input_pullup(SPI_OUT_PORT, SPI_OUT_CHAN0);
input_pullup(SPI_OUT_PORT, SPI_OUT_CHAN1);
input_pullup(SPI_OUT_PORT, SPI_OUT_SS);
// DI and USCK are inputs. DO is an output, but has to be set as Hi-Z
// input to prevent muliple slaves driving one line.
set_input(SPI_DDR, SPI_DI_DDR);
set_input(SPI_DDR, SPI_USCK_DDR);
set_input(SPI_DDR, SPI_DO_DDR);
input_pullup(SPI_PORT, SPI_DI);
input_pullup(SPI_PORT, SPI_USCK);
input_hiz(SPI_PORT, SPI_DO);
// enable external interrupt PCINT3 on PB3 (SPI_OUT_SS)
PCMSK |= _BV(PCINT3);
GIMSK |= _BV(PCIE);
// three-wire mode (SPI), external clock (SPI mode 0)
USICR = _BV(USIWM0) | _BV(USICS1) /* | _BV(USICS0) */;
}
static void clear_callback(int which)
{
struct TTL74123 *c = chip + which;
c->timer_active = 0;
set_output(which, 0);
}
int main(void) {
for (int i=0; i<3; i++) {
set_output(DDRB, led[i]);
}
uint8_t tick = 0;
while(1) {
for (int i=0; i<3; i++) {
if (tick < current[i]) {
output_high(PORTB, led[i]);
} else {
output_low(PORTB, led[i]);
}
}
tick = (tick+1)%256;
if (tick == 0) {
if (reached()) {
retarget();
} else {
approach();
}
}
}
return 0;
}
blargg_err_t SNES_SPC::skip( int count )
{
#if SPC_LESS_ACCURATE
if ( count > 2 * sample_rate * 2 )
{
set_output( 0, 0 );
// Skip a multiple of 4 samples
time_t end = count;
count = (count & 3) + 1 * sample_rate * 2;
end = (end - count) * (clocks_per_sample / 2);
m.skipped_kon = 0;
m.skipped_koff = 0;
// Preserve DSP and timer synchronization
// TODO: verify that this really preserves it
int old_dsp_time = m.dsp_time + m.spc_time;
m.dsp_time = end - m.spc_time + skipping_time;
end_frame( end );
m.dsp_time = m.dsp_time - skipping_time + old_dsp_time;
dsp.write( SPC_DSP::r_koff, m.skipped_koff & ~m.skipped_kon );
dsp.write( SPC_DSP::r_kon , m.skipped_kon );
clear_echo();
}
#endif
return play( count, 0 );
}
Data_Exception::Data_Exception(long int min, long int max, long int value) {
_min = min;
_max = max;
_value = value;
_comment = string("");
set_output();
}
bool triangle_convert::run(viennamesh::algorithm_handle &)
{
data_handle<triangle_mesh> input_mesh = get_required_input<triangle_mesh>("mesh");
set_output( "mesh", input_mesh );
return true;
}
void ttl74123_device::start_pulse()
{
attotime duration = compute_duration();
if(timer_running())
{
/* retriggering, but not if we are called to quickly */
attotime delay_time = attotime_make(0, ATTOSECONDS_PER_SECOND * m_config.m_cap * 220);
if(attotime_compare(timer_timeelapsed(m_timer), delay_time) >= 0)
{
timer_adjust_oneshot(m_timer, duration, 0);
if (LOG) logerror("74123 %s: Retriggering pulse. Duration: %f\n", tag(), attotime_to_double(duration));
}
else
{
if (LOG) logerror("74123 %s: Retriggering failed.\n", tag());
}
}
else
{
/* starting */
timer_adjust_oneshot(m_timer, duration, 0);
set_output();
if (LOG) logerror("74123 %s: Starting pulse. Duration: %f\n", tag(), attotime_to_double(duration));
}
}
