void av_update(struct IC *p,bvtype *isused) { int i,j; if((p->z.flags&(VKONST|VAR))==VAR){ i=p->z.v->index; if(p->z.flags&DREFOBJ) i+=vcount-rcount; if(i<0||i>=vcount){ printf("i=%d\n",i);pric2(stdout,p); ierror(0); } if(p->z.flags&DREFOBJ){ if(!(p->z.v->flags&DNOTTYPESAFE)) BCLR(isused,i); }else{ if(ISSCALAR(p->z.v->vtyp->flags)||(p->code==ASSIGN&&zmeqto(p->q2.val.vmax,szof(p->z.v->vtyp)))) BCLR(isused,i); } /* bei Zuweisung an p wird *p aktiv */ if(i<rcount) BSET(isused,i+vcount-rcount); } for(j=0;j<p->use_cnt;j++){ i=p->use_list[j].v->index; if(p->use_list[j].flags&DREFOBJ) i+=vcount-rcount; if(i<0||i>=vcount) continue; BSET(isused,i); } }
void ScrollHoriz() { auto oldX = v_screenposx; auto diffX = v_player->x - v_screenposx; int newX; if(diffX < 144) newX = max(v_player->x - 144, v_limitleft2); else if(diffX < 160) { v_scrshiftx = 0; return; } else newX = min(v_limitright2, min(diffX - 160, 16) + v_screenposx); auto oldX = v_screenposx; v_screenposx = newX; v_scrshiftx = (newX - oldX) << 8; if(((v_screenposx & 0x10) ^ v_screenscrollx16) == 0) { v_screenscrollx16 ^= 0x10; if(v_screenposx < oldX) BSET(v_bgscroll1, Scrolled_L); // back else BSET(v_bgscroll1, Scrolled_R); // forward } }
void saucy_print_automorphism(int *gamma, int gap_mode) { int i, j; /* Print the automorphism */ for (i = 0; i < n; ++i) { /* Mark elements we've already seen */ if (BISSET(bit_contents, i)) continue; BSET(bit_contents, i); /* Skip fixed elements */ if (gamma[i] == i) continue; printf("(%d", gap_mode ? i+1 : i); /* Mark and print elements in this orbit */ for (j = gamma[i]; j != i; j = gamma[j]) { BSET(bit_contents, j); putchar(gap_mode ? ',' : ' '); printf("%d", gap_mode ? j+1 : j); } /* Finish off the orbit */ printf(")"); } /* Clean up after ourselves */ if (!gap_mode) printf("\n"); BWIPE(bit_contents, n); }
// send cnt bits to LCD controller, only low bits of "bits" are used // use timer4 to get 600kHz clock for driving WR/ signal // timer is used in one-pulse mode and is started after each WR/ change, // so there will always be minimal required length of pulse also // when interrupted by some interrupt static void lcd_send_bits(u8 cnt, u16 bits) { // shift bits to high-bits bits <<= (u8)(16 - cnt); WR0; BSET(TIM4_CR1, 0); // start timer WR0; // optimize hack do { if (bits & 0x8000) { DATA1; } else { DATA0; } bits <<= 1; // to next bit while (!BCHK(TIM4_SR, 0)); // wait for timer WR1; BRES(TIM4_SR, 0); // clear intr flag BSET(TIM4_CR1, 0); // start timer if (!--cnt) break; while (!BCHK(TIM4_SR, 0)); // wait for timer WR0; BRES(TIM4_SR, 0); // clear intr flag BSET(TIM4_CR1, 0); // start timer } while (1); while (!BCHK(TIM4_SR, 0)); // wait for timer BRES(TIM4_SR, 0); // clear intr flag }
unsigned long int x86_nop_xfer (char *xferstr) { int bw = 0; /* bitfield walker */ unsigned char tgt; /* resulting instruction */ /* in a valid xferstr we trust */ for (tgt = 0 ; xferstr != NULL && xferstr[0] != '\0' ; ++xferstr) { switch (xferstr[0]) { case ('0'): BSET (tgt, 1, 0, bw); break; case ('1'): BSET (tgt, 1, 1, bw); break; case ('r'): BSET (tgt, 3, x86_nop_rwreg (), bw); break; case ('.'): break; /* ignore */ default: fprintf (stderr, "on steroids, huh?\n"); exit (EXIT_FAILURE); break; } } if (bw != 8) { fprintf (stderr, "invalid bitwalker: bw = %d\n", bw); exit (EXIT_FAILURE); } return (tgt); }
/* node_dynamic_reset: clean a pynode, getting rid of all * data dynamically created for it. */ static void node_dynamic_reset(bNode *node, int unlink_text) { bNodeType *tinfo, *tinfo_default; Material *ma; tinfo = node->typeinfo; tinfo_default = node_dynamic_find_typeinfo(&node_all_shaders, NULL); if ((tinfo == tinfo_default) && unlink_text) { ID *textID = node->id; /* already at default (empty) state, which happens if this node's * script failed to parse at the first stage: definition. We're here * because its text was removed from Blender. */ for (ma= G.main->mat.first; ma; ma= ma->id.next) { if (ma->nodetree) { bNode *nd; for (nd= ma->nodetree->nodes.first; nd; nd = nd->next) { if (nd->id == textID) { nd->id = NULL; nd->custom1 = 0; nd->custom1 = BSET(nd->custom1, NODE_DYNAMIC_NEW); BLI_strncpy(nd->name, "Dynamic", 8); return; } } } } } node_dynamic_rem_all_links(tinfo); node_dynamic_free_typeinfo_sockets(tinfo); /* reset all other XXX shader nodes sharing this typeinfo */ for (ma= G.main->mat.first; ma; ma= ma->id.next) { if (ma->nodetree) { bNode *nd; for (nd= ma->nodetree->nodes.first; nd; nd = nd->next) { if (nd->typeinfo == tinfo) { node_dynamic_free_storage_cb(nd); node_dynamic_free_sockets(nd); //node_dynamic_update_socket_links(nd, ma->nodetree); nd->typeinfo = tinfo_default; if (unlink_text) { nd->id = NULL; nd->custom1 = 0; nd->custom1 = BSET(nd->custom1, NODE_DYNAMIC_NEW); BLI_strncpy(nd->name, "Dynamic", 8); } } } } } /* XXX hardcoded for shaders: */ if (tinfo->id) { BLI_remlink(&node_all_shaders, tinfo); } node_dynamic_free_typeinfo(tinfo); }
static void update_theta(void) { int i, j, x, y, z; /* Update all cell representatives */ for (i = 0; i < n; ++i) { /* Look for the start of an orbit */ if (i >= gamma[i]) continue; /* Find the cell rep for the two elements */ for (x = i; x != theta[x]; x = theta[x]); for (y = gamma[i]; y != theta[y]; y = theta[y]); /* Pick the cell with the smaller representative */ z = (x < y) ? x : y; /* Update the old root's cell representatives */ theta[x] = theta[y] = z; } /* Clear out last automorphism if we've already saved max */ if (saved == max_saved) { --saved; BWIPE(FIX(saved), n); BWIPE(MCR(saved), n); } /* Look for orbits in gamma and update fix and mcr */ for (i = 0; i < n; ++i) { /* Find the start of an orbit, and save it as an mcr */ if (BISSET(bit_contents, i)) continue; BSET(bit_contents, i); BSET(MCR(saved), i); /* If the element is fixed, save as fixed and continue */ if (gamma[i] == i) { BSET(FIX(saved), i); continue; } /* Find all other elements in the orbit */ for (j = gamma[i]; j != i; j = gamma[j]) { BSET(bit_contents, j); } } /* Clean up */ BWIPE(bit_contents, n); ++saved; }
void ptsstop(TTY tp, int fl) { if (!fl) { fl = TIOCPKT_STOP; BSET(tp->state, PF_STOPPED); } else BCLR(tp->state, PF_STOPPED); BSET(tp->send, fl); ptc_select(tp); }
void pwm_set_chan(char chan, char pol, char clk, char cae, char ctl) { if (pol >= 0) BSET(PWMPOL,chan,pol); if (clk >= 0) BSET(PWMCLK,chan,clk); if (cae >= 0) BSET(PWMCAE,chan,cae); if (ctl >= 0) BSET(PWMCTL,chan,ctl); }
// calculate length of SYNC signal (substract previous channel values) // also sets flag for ppm_interrupt to use new values // also starts TIM3 at first call void ppm_calc_sync(void) { // ARR must be set to computed value - 1, that is why we are substracting // 5000, it is quicker way to "add 5000" and then substract 1 from result *(u16 *)(&ppm_values[0]) = (u16)(((10 * (u32)PPM_FRAME_LENGTH - ppm_microsecs01) * PPM_MUL_SYNC - PPM(500)) / PPM(1000)); ppm_microsecs01 = 0; // for first ppm values, enable timer if (ppm_enabled) return; ppm_enabled = 1; BSET(TIM3_EGR, 0); // generate update event BSET(TIM3_CR1, 0); // enable timer }
ALIST_API ControlPartCode ALSetFocus(ControlPartCode focusPart, ALHandle hAL) { ControlPartCode result; Boolean oldFocus; CGrafPtr savePort; WindowPtr winRef; if (hAL == nil || *hAL == nil) return kControlFocusNoPart; // Keep track of the old state of things. oldFocus = (BTST((*hAL)->flags, alFFocused) != 0); switch (focusPart) { case kControlFocusNoPart: // Turn off all focusing. BCLR((*hAL)->flags, alFFocused); result = kControlFocusNoPart; break; case kControlFocusNextPart: // Switch the state from off/on to on/off. case kControlFocusPrevPart: if (BTST((*hAL)->flags, alFFocused)) { // Turn off the focus. BCLR((*hAL)->flags, alFFocused); result = kControlFocusNoPart; } else { // Turn on the focus. BSET((*hAL)->flags, alFFocused); result = kControlListBoxPart; } break; case kControlListBoxPart: // Turn on focusing. BSET((*hAL)->flags, alFFocused); result = kControlListBoxPart; break; default: // simply return the state of focus result = (BTST((*hAL)->flags, alFFocused)) ? kControlListBoxPart : kControlFocusNoPart; break; } // If the focus changed, redraw if the alFDrawFocus feature is turned on. if ( BTST((*hAL)->features, alFDrawFocus) && oldFocus != (BTST((*hAL)->flags, alFFocused) != 0)) { GDHandle saveDevice; GetGWorld(&savePort, &saveDevice); ALGetInfo(alWindow, &winRef, hAL); SetPortWindowPort(winRef); _ALDrawListBorder(hAL); SetGWorld(savePort, saveDevice); } return result; } // ALSetFocus
ALIST_API short ALFeatureFlag(unsigned long feature, short action, ALHandle hAL) { ALPtr pAL; short status; if (hAL == nil || *hAL == nil) return alBitClear; pAL = *hAL; // get current status of the specified feature status = BTST(pAL->features, feature) ? alBitSet : alBitClear; // if action is alBitToggle, invert flag if (action == alBitToggle) action = 1 - status; // reset flag according to action if (action == alBitClear) { BCLR(pAL->features, feature); if ( feature == alFInhibitRedraw ) // If we're enabling drawing, recalculate what's visible. _ALCalcVisibleCells( hAL ); } else if ( action == alBitSet ) BSET(pAL->features, feature); // return old status return status; } // ALFeatureFlag
/* * initialize - hand-craft a cache entry for startup, otherwise get ready */ static struct sset * initialize(struct vars * v, struct dfa * d, chr *start) { struct sset *ss; int i; /* is previous one still there? */ if (d->nssused > 0 && (d->ssets[0].flags & STARTER)) ss = &d->ssets[0]; else { /* no, must (re)build it */ ss = getvacant(v, d, start, start); if (ss == NULL) return NULL; for (i = 0; i < d->wordsper; i++) ss->states[i] = 0; BSET(ss->states, d->cnfa->pre); ss->hash = HASH(ss->states, d->wordsper); assert(d->cnfa->pre != d->cnfa->post); ss->flags = STARTER | LOCKED | NOPROGRESS; /* lastseen dealt with below */ } for (i = 0; i < d->nssused; i++) d->ssets[i].lastseen = NULL; ss->lastseen = start; /* maybe untrue, but harmless */ d->lastpost = NULL; d->lastnopr = NULL; return ss; }
void Task_WindOut(void) { BSET(AWS_DDR, AWS_PIN); BeginCritical(); // Fast PWM 8 bit TCCR1A = BV(COM1A1) | BV(COM1B1) | BV(WGM10); TCCR1B = BV(WGM12) | BV(CS11); // Enable PWM pins AWA_DDR |= BV(AWA_DDR_COS) | BV(AWA_DDR_SIN); EndCritical(); for (;;) { delay_ms(80); // // Dimension for 5 ms pulses (100 Hz) at 60 Kts // 60 kts - 100 revs / if (Nav_AWS < 5) windPulse = 0; else windPulse = 2000 / Nav_AWS; register int deg = Nav_AWA/10; BeginCritical(); AWA_SIN = trigint_sin8u(deg * 45 + (deg * 51 / 100)); deg = (90 - deg + 360) % 360; AWA_COS = trigint_sin8u(deg * 45 + (deg * 51 / 100)); EndCritical(); } }
static void input_loop(void) { // read initial ADC values BSET(ADC_CR1, 0); // start conversion while (!BCHK(ADC_CSR, 7)) pause(); // wait for end of conversion read_ADC(); // put initial values to all buffers ADC_BUFINIT(0); ADC_BUFINIT(1); ADC_BUFINIT(2); adc_battery = adc_battery_last; adc_battery_filt = (u32)adc_battery * ADC_BAT_FILT; // task CALC must be awaked to compute values before PPM will take on awake(CALC); input_initialized = 1; while (1) { // read ADC only when EOC flag (only for first it will not be ready) if (BCHK(ADC_CSR, 7)) read_ADC(); read_keys(); stop(); } }
// initialize LCD pins and LCD controller void lcd_init(void) { // set direction of pins IO_OPF(C, 3); // CS/ pin IO_OP(E, 5); // DATA pin IO_OP(F, 4); // WR/ pin IO_OP(D, 2); // Backlight pin // set default values to pins CS1; WR1; DATA1; LCD_BCK0; // initialize timer 4 used to time WR/ signal BSET(CLK_PCKENR1, 4); // enable clock to TIM4 TIM4_CR1 = 0b00001100; // no auto-reload, one-pulse,URS-overflow, disable TIM4_IER = 0; // no interrupts TIM4_PSCR = 0; // prescaler = 1 TIM4_ARR = 24; // it will be about 600kHz for WR/ signal TIM4_CNTR = 0; // reset timer value // initialize HT1621B lcd_command(HT_BIAS_13 | (0b10 << HT_BIAS_SHIFT)); // BIAS 1/3, 4 COMs lcd_command(HT_RC_256K); // clock RC 256kHz lcd_command(HT_SYS_DIS); // OSC+BIAS off lcd_command(HT_WDT_DIS); // disable WDT lcd_command(HT_SYS_EN); // OSC on lcd_command(HT_LCD_ON); // BIAS on // initialize LCD task, will be used when sending following lcd_command-s build(LCD); activate(LCD, lcd_loop); sleep(LCD); // no work yet }
static void read_ADC(void) { u16 *buf = adc_buffer[adc_buffer_pos]; u8 dead; ADC_NEWVAL(0); ADC_NEWVAL(1); ADC_NEWVAL(2); adc_battery_last = ADC_DB3R; adc_buffer_pos++; adc_buffer_pos &= 3; BRES(ADC_CSR, 7); // remove EOC flag BSET(ADC_CR1, 0); // start new conversion // average battery voltage and check battery low // ignore very low, which means that it is supplied from SWIM connector adc_battery_filt = adc_battery_filt * (ADC_BAT_FILT - 1); // splitted - compiler hack adc_battery_filt = (adc_battery_filt + (ADC_BAT_FILT / 2)) / ADC_BAT_FILT + adc_battery_last; adc_battery = (u16)((adc_battery_filt + (ADC_BAT_FILT / 2)) / ADC_BAT_FILT); // start checking battery after 5s from power on if (time_sec >= 5) { // wakeup task only when something changed if (adc_battery > 50 && adc_battery < battery_low_raw) { // bat low if (!menu_battery_low) { menu_battery_low = 1; awake(MENU); } } else { // bat OK, but apply some hysteresis to not switch quickly ON/OFF if (menu_battery_low && adc_battery > battery_low_raw + 100) { menu_battery_low = 0; awake(MENU); } } } // wakeup MENU task when showing battery or at calibrate if (menu_wants_adc) awake(MENU); // reset inactivity timer when some steering or throttle applied dead = cg.steering_dead_zone; if (dead < 20) dead = 20; // use some minimal dead zone for this check if (adc_steering_last < (cg.calib_steering_mid - dead) || adc_steering_last > (cg.calib_steering_mid + dead)) reset_inactivity_timer(); else { dead = cg.throttle_dead_zone; if (dead < 20) dead = 20; // use some minimal dead zone for this check if (adc_throttle_last < (cg.calib_throttle_mid - dead) || adc_throttle_last > (cg.calib_throttle_mid + dead)) reset_inactivity_timer(); } }
ALIST_API long ALAddRowUnder( long count, long superRow, ALHandle hAL ) { long result; ALCell tempCell; unsigned long superRowOffset, offset; short saveRedrawState; if ( count < 0 || hAL == nil || *hAL == nil || superRow < (*hAL)->dataBounds.top || superRow >= (*hAL)->dataBounds.bottom ) return 0; // Make sure the list is heirarchical. if ( !BTST( (*hAL)->features, alFHeirarchical ) ) return 0; saveRedrawState = ALFeatureFlag( alFInhibitRedraw, alBitSet, hAL ); result = ALAddRow( count, superRow + 1, hAL ); ALFeatureFlag( alFInhibitRedraw, saveRedrawState, hAL ); if ( result > 0 ) { tempCell.h = (**hAL).dataBounds.left; tempCell.v = superRow; superRowOffset = _ALCalcOffsetFromCell( &tempCell, &(*hAL)->dataBounds ); // Mark the superRow as an alSsuperrow, if it wasn't already. if ( !BTST( (*(*hAL)->hSelected)[ superRowOffset ], alSsuperrow ) ) { BSET( (*(*hAL)->hSelected)[ superRowOffset ], alSsuperrow ); // The row defaults to being expanded. BSET( (*(*hAL)->hSelected)[ superRowOffset ], alSexpanded ); } // Set the level of all the added rows to one greater than the superRows level. for ( tempCell.v = superRow + 1; tempCell.v <= superRow + count; tempCell.v++ ) { offset = _ALCalcOffsetFromCell(&tempCell, &(*hAL)->dataBounds); (*(*hAL)->hLevels)[ offset ] = (*(*hAL)->hLevels)[ superRowOffset ] + 1; } // Redraw the entire list. if ( !BTST((*hAL)->features, alFInhibitRedraw) ) ALUpdate( nil, hAL ); } return result; }
bool dig_write(pin_t pin, digstate_t state) { const portid_t pid = pin_pid[pin]; if(pid == PID_INVALID) { return FALSE; } BSET(*pid_port[pid], pin_offset[pin], (state == HIGH) ? 1 : 0); return TRUE; }
bool dig_mode(pin_t pin, digmode_t mode) { const portid_t pid = pin_pid[pin]; if(pid == PID_INVALID) { return FALSE; } BSET(*pid_ddr[pid], pin_offset[pin], (mode == OUTPUT) ? 1 : 0); return TRUE; }
ALIST_API OSErr ALExpandRow(long rowNum, Boolean expandChildren, ALHandle hAL) { ALCell tempCell; unsigned long superRowOffset, offset; // Sanity check. if (hAL == nil || *hAL == nil || rowNum < (**hAL).dataBounds.top || rowNum >= (**hAL).dataBounds.bottom) return paramErr; // Make sure the list is heirarchical. if ( !BTST( (*hAL)->features, alFHeirarchical ) ) return false; // The left-most cell contains the heirarchical data. tempCell.h = (**hAL).dataBounds.left; tempCell.v = rowNum; superRowOffset = _ALCalcOffsetFromCell(&tempCell, &(*hAL)->dataBounds); // Mark the row as expanded. BSET((*(*hAL)->hSelected)[superRowOffset], alSexpanded); // Check if it's a heirarchical row. if ( BTST((*(*hAL)->hSelected)[superRowOffset], alSsuperrow) ) { if ( expandChildren ) { // Mark all children as expanded. for ( tempCell.v++; tempCell.v < (*hAL)->dataBounds.bottom; tempCell.v++ ) { offset = _ALCalcOffsetFromCell( &tempCell, &(*hAL)->dataBounds ); if ( (*(*hAL)->hLevels)[ offset ] > (*(*hAL)->hLevels)[ superRowOffset ] ) BSET( (*(*hAL)->hSelected)[ offset ], alSexpanded ); else break; } } // Recalculate the visible cells. _ALCalcVisibleCells( hAL ); // Redraw the entire list. if ( !BTST((*hAL)->features, alFInhibitRedraw) ) ALUpdate( nil, hAL ); } return noErr; }
/* node_dynamic_init_cb callback: called when a pynode is created. * The pynode type is passed via node->custom2. It can be: * 0: for loaded empty nodes * NODE_DYNAMIC_MENU: for the default Dynamic node type * > NODE_DYNAMIC_MENU: for the new types defined by scripts */ static void node_dynamic_init_cb(bNode *node) { int type = node->custom2; node->custom2 = 0; if (type >= NODE_DYNAMIC_MENU) { node->custom1 = 0; if (type == NODE_DYNAMIC_MENU) { node->custom1 = BSET(node->custom1, NODE_DYNAMIC_NEW); return; } node->custom1 = BSET(node->custom1, NODE_DYNAMIC_ADDEXIST); node->id = node->typeinfo->id; } node_dynamic_setup(node); }
UINT32 cnetcard_init(CNETCARD *cnetcard) { cstring_init(CNETCARD_NAME(cnetcard), NULL_PTR); cstring_init(CNETCARD_IPV4STR(cnetcard), NULL_PTR); cstring_init(CNETCARD_MACSTR(cnetcard), NULL_PTR); BSET(CNETCARD_MACADDR(cnetcard), 0, 6); CNETCARD_IPV4VAL(cnetcard) = 0; CNETCARD_STATE(cnetcard) = CNETCARD_ERR_STATE; return (0); }
// initialize PPM pin and timer 3 void ppm_init(void) { IO_OP(D, 0); // PPM output pin, TIM3_CH2 // initialize timer3 used to generate PPM signal BSET(CLK_PCKENR1, 6); // enable master clock to TIM3 TIM3_CCMR2 = 0b01111000; // PWM2, OC2 preload, output mode TIM3_CCER1 = 0b00010000; // polarity active-high, OC2 enable TIM3_PSCR = PPM_PSC_SYNC; TIM3_IER = 1; // update interrupt enable TIM3_CR1 = 0b10000000; // auto-reload, URS-all, counter-disable ppm_set_channels(3); }
int ttwait(TTY tp) { while (qsize(&tp->outq) != 0 && ISSET(tp->state,ST_COPEN) && ISSET(tp->state,ST_SOPEN)) { BSET(tp->state,ST_DRAIN); /* Wait until output is empty */ if (Block(&tp->outq,-1l,0)==2) return RP_EINTR; } return RPDONE; }
// set number of channels void ppm_set_channels(u8 n) { // disable PPM generation till new values will not be set ppm_enabled = 0; BRES(TIM3_CR1, 0); // disable timer BSET(PD_ODR, 0); // set PPM pin to 1 // start with generating 20ms SYNC signal TIM3_CCR2H = hi8(PPM_300US_SYNC); TIM3_CCR2L = hi8(PPM_300US_SYNC); TIM3_ARRH = hi8(PPM_MUL_SYNC * 20); TIM3_ARRL = lo8(PPM_MUL_SYNC * 20); channels = n; channels2 = (u8)(n << 1); // also 2* value for compare in ppm_interrupt }
void av_change(struct IC *p,bvtype *use,bvtype *def) /* Berechnet die Aenderungen, die sich durch IC p an use und def ergeben. */ { int i,j,n=-1; int g1,g2; /* Wenn eine Quelle==Ziel, dann wird dadurch kein neuer use erzeugt, */ /* um z.B. unbenutzte Induktionsvariablen in Schleifen zu eliminieren. */ g1=compare_objs(&p->q1,&p->z,p->typf); g2=compare_objs(&p->q2,&p->z,p->typf); if(!g1&&(p->q1.flags&(VAR|DREFOBJ))==VAR) n=p->q1.v->index; if(!g2&&(p->q2.flags&(VAR|DREFOBJ))==VAR) n=p->q2.v->index; for(j=0;j<p->use_cnt;j++){ i=p->use_list[j].v->index; if(p->use_list[j].flags&DREFOBJ) i+=vcount-rcount; if(i>=vcount) continue; if(i!=n&&!BTST(def,i)) BSET(use,i); } /* Ein Wert wird nicht zerstoert, wenn es kein elementarer Typ ist und */ /* die Groesse kleiner als die Variable (steht in alle solchen ICs in */ /* q2.val.max. */ if((p->z.flags&(VAR|DREFOBJ))==VAR&&(ISSCALAR(p->z.v->vtyp->flags)||p->z.v->vtyp->flags==0||zmeqto(p->q2.val.vmax,szof(p->z.v->vtyp)))){ i=p->z.v->index; if(i>=vcount) ierror(0); if(g1&&g2&&!BTST(use,i)) BSET(def,i); /* Wenn p geaendert wird, wird auch *p geaendert */ if(i<rcount&&!BTST(def,i+vcount-rcount)) BSET(use,i+vcount-rcount); } if((p->z.flags&(VAR|DREFOBJ))==(VAR|DREFOBJ)&&g1&&g2&&!(p->z.v->flags&DNOTTYPESAFE)){ i=p->z.v->index+vcount-rcount; if(i>=vcount) ierror(0); if(!BTST(use,i)) BSET(def,i); } }
void Task_SoftUartOut(void) { // Timer2 4800 baud soft uart timer OCR2 = TCNT2_TOP; BSET(TIMSK, OCIE2); TCCR2 = BV(CS21)|BV(WGM21); // F_CPU/8 - CTC Mode SoftUartInInit(); BSET(SUART1_TXDDR, SUART1_TXPIN); BSET(SUART2_TXDDR, SUART2_TXPIN); BSET(VHF_DDR, VHF_UART); stOut[0].buf = NmeaFiOut; AvrXFlushFifo(pNmeaFiOut); pNmeaFiOut->size = (uint8_t)(sizeof(NmeaFiOut) - sizeof(AvrXFifo) + 1); stOut[1].buf = NmIIFiOut; AvrXFlushFifo(pNmIIFiOut); pNmIIFiOut->size = (uint8_t)sizeof(NmIIFiOut) - sizeof(AvrXFifo) + 1; stOut[2].buf = NmeaGpsOut; AvrXFlushFifo(pNmeaGpsOut); pNmeaGpsOut->size = (uint8_t)(sizeof(NmeaGpsOut) - sizeof(AvrXFifo) + 1); register uint8_t i; for (;;) { AvrXWaitSemaphore(&suOut); for (i = 0; i < 3; i++) { if (0 == stOut[i].state && FIFO_ERR!= AvrXPeekFifo((pAvrXFifo) stOut[i].buf)) { stOut[i].ch = AvrXPullFifo((pAvrXFifo) stOut[i].buf); stOut[i].state = 10; } } } }
static void SoftUartInInit(void) { BSET(SUART1_RXPU, SUART1_RXPIN); BSET(SUART2_RXPU, SUART2_RXPIN); BSET(SUART3_RXPU, SUART3_RXPIN); BSET(SUART4_RXPU, SUART4_RXPIN); WindBuf[2] = 1; WindBuf[3] = sizeof(WindBuf) - sizeof(NmeaBuf); DepthBuf[2]= 2; DepthBuf[3]= sizeof(DepthBuf) - sizeof(NmeaBuf); VdoBuf[2] = 3; VdoBuf[3] = sizeof(VdoBuf) - sizeof(NmeaBuf); RdrBuf[2] = 4; RdrBuf[3] = sizeof(RdrBuf) - sizeof(NmeaBuf); GpsBuf[2] = 5; GpsBuf[3] = sizeof(GpsBuf) - sizeof(NmeaBuf); stIn[0].buf = WindBuf; stIn[1].buf = DepthBuf; stIn[2].buf = VdoBuf; stIn[3].buf = RdrBuf; #if 1 // Extern Ints 0,1,2 MCUCR |= BV(ISC11)|BV(ISC01); //BCLR(MCUCSR, ISC2); GICR |= BV(INT0)|BV(INT1)|BV(INT2); #endif }
static void descend_left(void) { int temp; /* Remember that this cell is the target at this level */ start[lev] = target; /* Update greatest common ancestor with zeta */ if (!have_zeta) ++anc; /* Move the minimum label to the front */ temp = lab[target_min]; lab[target_min] = lab[target]; lab[target] = temp; /* Remember that we fixed this element at this level */ fixed[lev] = temp; BSET(bit_fixed, temp); /* Split the cell */ ptn[target] = ++lev; ++cells; /* Update cell fronts */ for (temp = target+1; temp <= target + clen[target]; ++temp) { cfront[lab[temp]] = target + 1; } /* If |target| = 2, then skip target completely */ if (clen[target] == 1) { nextnon[prevnon[target]] = nextnon[target]; prevnon[nextnon[target]] = prevnon[target]; } /* Otherwise, fix pointers to deal with nonsingle after target */ else { nextnon[target+1] = nextnon[target]; prevnon[target+1] = prevnon[target]; nextnon[prevnon[target]] = target+1; prevnon[nextnon[target]] = target+1; } /* Update cell lengths */ clen[target+1] = clen[target] - 1; clen[target] = 0; /* Now go and do some work */ refine(); }