/* Show current setup */ void vpr_show_setup(INP t_options options, INP t_vpr_setup vpr_setup) { ShowSetup(options, vpr_setup); }
/* Initialize VPR 1. Read Options 2. Read Arch 3. Read Circuit 4. Sanity check all three */ void vpr_init(INP int argc, INP char **argv, OUTP t_options *options, OUTP t_vpr_setup *vpr_setup, OUTP t_arch *arch) { char* pszLogFileName = "vpr_stdout.log"; unsigned char enableTimeStamps = 1; unsigned long maxWarningCount = 100000; unsigned long maxErrorCount = 1000; if (PrintHandlerExists() == 1) { has_printhandler_pre_vpr = TRUE; } else { has_printhandler_pre_vpr = FALSE; } if (has_printhandler_pre_vpr == FALSE) { PrintHandlerNew(pszLogFileName); PrintHandlerInit(enableTimeStamps, maxWarningCount, maxErrorCount); } /* Print title message */ vpr_print_title(); /* Print usage message if no args */ if (argc < 3) { vpr_print_usage(); exit(1); } memset(options, 0, sizeof(t_options)); memset(vpr_setup, 0, sizeof(t_vpr_setup)); memset(arch, 0, sizeof(t_arch)); /* Read in user options */ ReadOptions(argc, argv, options); /* Timing option priorities */ vpr_setup->TimingEnabled = IsTimingEnabled(options); /* Determine whether echo is on or off */ setEchoEnabled(IsEchoEnabled(options)); setDumpVtbEnabled(IsDumpVtbEnabled(options)); SetPostSynthesisOption(IsPostSynthesisEnabled(options)); vpr_setup->constant_net_delay = options->constant_net_delay; /* Read in arch and circuit */ SetupVPR(options, vpr_setup->TimingEnabled, TRUE, &vpr_setup->FileNameOpts, arch, &vpr_setup->Operation, &vpr_setup->user_models, &vpr_setup->library_models, &vpr_setup->PackerOpts, &vpr_setup->PlacerOpts, &vpr_setup->AnnealSched, &vpr_setup->RouterOpts, &vpr_setup->RoutingArch, &vpr_setup->Segments, &vpr_setup->Timing, &vpr_setup->ShowGraphics, &vpr_setup->GraphPause, &vpr_setup->PowerOpts); /* Check inputs are reasonable */ CheckOptions(*options, vpr_setup->TimingEnabled); CheckArch(*arch, vpr_setup->TimingEnabled); /* Verify settings don't conflict or otherwise not make sense */ CheckSetup(vpr_setup->Operation, vpr_setup->PlacerOpts, vpr_setup->AnnealSched, vpr_setup->RouterOpts, vpr_setup->RoutingArch, vpr_setup->Segments, vpr_setup->Timing, arch->Chans); /* flush any messages to user still in stdout that hasn't gotten displayed */ fflush(stdout); /* Read blif file and sweep unused components */ read_and_process_blif(vpr_setup->PackerOpts.blif_file_name, vpr_setup->PackerOpts.sweep_hanging_nets_and_inputs, vpr_setup->user_models, vpr_setup->library_models, vpr_setup->PowerOpts.do_power, vpr_setup->FileNameOpts.ActFile); fflush(stdout); ShowSetup(*options, *vpr_setup); }
int main(int argc, char **argv) { int simSize = 14; int xx; simResults = (double *) malloc(simSize*sizeof(double)); simCounts = (unsigned long *) malloc(simSize*sizeof(unsigned long)); simIndex = 0; for(xx = 0; xx < simSize ; xx++) { simResults[xx] = 0.0; simCounts[xx] = 0; } t_options Options; t_arch Arch = { 0 }; enum e_operation Operation; struct s_placer_opts PlacerOpts; struct s_annealing_sched AnnealSched; struct s_router_opts RouterOpts; struct s_det_routing_arch RoutingArch; t_segment_inf *Segments; t_timing_inf Timing; t_subblock_data Subblocks; boolean ShowGraphics; boolean TimingEnabled; int GraphPause; /* Print title message */ PrintTitle(); /* Print usage message if no args */ if(argc < 2) { PrintUsage(); exit(1); } /* Read in available inputs */ ReadOptions(argc, argv, &Options); /* Determine whether timing is on or off */ TimingEnabled = IsTimingEnabled(Options); /* Use inputs to configure VPR */ SetupVPR(Options, TimingEnabled, &Arch, &Operation, &PlacerOpts, &AnnealSched, &RouterOpts, &RoutingArch, &Segments, &Timing, &Subblocks, &ShowGraphics, &GraphPause); /* Check inputs are reasonable */ CheckOptions(Options, TimingEnabled); CheckArch(Arch, TimingEnabled); /* Verify settings don't conflict or otherwise not make sense */ CheckSetup(Operation, PlacerOpts, AnnealSched, RouterOpts, RoutingArch, Segments, Timing, Subblocks, Arch.Chans); /* Output the current settings to console. */ ShowSetup(Options, Arch, TimingEnabled, Operation, PlacerOpts, AnnealSched, RouterOpts, RoutingArch, Segments, Timing, Subblocks); if(Operation == TIMING_ANALYSIS_ONLY) { do_constant_net_delay_timing_analysis( Timing, Subblocks, Options.constant_net_delay); return 0; } /* Startup X graphics */ set_graphics_state(ShowGraphics, GraphPause, RouterOpts.route_type); if(ShowGraphics) { init_graphics("VPR: Versatile Place and Route for FPGAs"); alloc_draw_structs(); } /* Do the actual operation */ place_and_route(Operation, PlacerOpts, Options.PlaceFile, Options.NetFile, Options.ArchFile, Options.RouteFile, AnnealSched, RouterOpts, RoutingArch, Segments, Timing, &Subblocks, Arch.Chans); /* Close down X Display */ if(ShowGraphics) close_graphics(); /* free data structures */ free(Options.PlaceFile); free(Options.NetFile); free(Options.ArchFile); free(Options.RouteFile); freeArch(&Arch); printf("\nTiming Results\n"); for(xx = 0; xx < simSize ; xx++) { if(simCounts[xx] != 0) { simResults[xx] /= (double) simCounts[xx]; } printf("Index: %d\tAverage Clock: %f\n", xx, simResults[xx]); } free(simResults); free(simCounts); /* Return 0 to single success to scripts */ return 0; }
void main(void) { uns8 DropoutCount; int nii@NegFact; uns8 LowGasCount; OPTION_REG = 0b.00000.011; // TMR0 w/ int clock, 1:16 presc (see _PreScale0), // weak pullups on // general ports setup TRISA = 0b.00111111; // all inputs ADCON1 = 0b.0.000.0010; // uses 5V as Vref #ifdef BOARD_3_0 PORTB = 0b.1000.0000; // all outputs to low, except RB7 (LISL-CS)! TRISB = 0b.0000.0000; // all servo and LED outputs PORTC = 0b.0100.0000; // all outputs to low, except TxD TRISC = 0b.10000100; // RC7, RC2 are inputs #endif #ifdef BOARD_3_1 PORTB = 0b.1100.0000; // all outputs to low, except RB6 & 7 (I2C)! TRISB = 0b.0100.0000; // all servo and LED outputs PORTC = 0b.0110.0000; // all outputs to low, except TxD and CS TRISC = 0b.10000100; // RC7, RC2 are inputs RBPU_ = 1; // enable weak pullups #endif #ifdef BOARD_3_1 LedShadow = 0; #endif ALL_LEDS_OFF; // timer setup T1CON = 0b.00.11.0001; // enable TMR1, 1:8 prescaler, run with 2us clock CCP1CON = 0b.00.00.0100; // capture mode every falling edge TMR2 = 0; T2CON = 0b.0.1111.1.11; // enable TMR2, 1:16 prescaler, 1:16 postscaler (see _Pre/PostScale2) PR2 = TMR2_5MS; // set compare reg to 9ms // setup flags register Flags = 0; _NoSignal = 1; // assume no signal present InitArrays(); LedRed_ON; // red LED on Delaysec(1); // wait 1/10 sec until LISL is ready to talk #ifdef USE_ACCSENS IsLISLactive(); #ifdef ICD2_DEBUG _UseLISL = 1; // because debugger uses RB7 (=LISL-CS) :-( #endif NeutralLR = 0; NeutralFB = 0; NeutralUD = 0; if( _UseLISL ) GetEvenValues(); // into Rp, Np, Tp #endif // setup serial port for 8N1 TXSTA = 0b.0010.0100; // async mode, BRGH = 1 RCSTA = 0b.1001.0000; // receive mode SPBRG = _B38400; #ifdef BOARD_3_0 _SerEnabled = 1; // serial link is enabled #endif W = RCREG; // be sure to empty FIFO // enable the interrupts CCP1IE = 1; TMR2IE = 1; // T1-Capture and T2 interrupt enable PEIE = 1; // enable peripheral interrupts // send hello text to serial COM Delaysec(1); // just to see the output after powerup ShowSetup(1); IK6 = IK7 = _Neutral; #ifdef BOARD_3_1 InitDirection(); // init compass sensor #endif Restart: IGas =IK5 = _Minimum; // assume parameter set #1 // DON'T MOVE THE UFO! // ES KANN LOSGEHEN! while(1) { T0IE = 0; // disable TMR0 interrupt ALL_LEDS_OFF; LedRed_ON; // red LED on if(_UseLISL) LedYellow_ON; // to signal LISL sensor is active InitArrays(); GIE = 1; // enable all interrupts // Wait until a valid RX signal is received DropoutCount = MODELLOSTTIMER; do { Delaysec(2); // wait 2/10 sec until signal is there ProcessComCommand(); if( _NoSignal ) { if( Switch ) { if( --DropoutCount == 0 ) { Beeper_TOG; // toggle beeper "model lost" DropoutCount = MODELLOSTTIMERINT; } } else Beeper_OFF; } } while( _NoSignal || !Switch); // no signal or switch is off // RX Signal is OK now // Wait 2 sec to allow enter of prog mode LedRed_OFF; LedYellow_ON; Delaysec(20); LedYellow_OFF; // die Variablen einlesen ReadEEdata(); // check for prog mode (max. throttle) if( IGas > _ProgMode ) { DoProgMode(); goto Restart; } // Just for safety: don't let motors start if throttle is open! // check if Gas is below _ThresStop DropoutCount = 1; while( IGas >= _ThresStop ) { if( _NoSignal ) goto Restart; if( _NewValues ) { OutSignals(); _NewValues = 0; if( --DropoutCount <= 0 ) { LedRed_TOG; // toggle red Led DropoutCount = 10; // to signal: THROTTLE OPEN } } ProcessComCommand(); } // ############### // ## MAIN LOOP ## // ############### // loop length is controlled by a programmable variable "TimeSlot" // which sets wait time in ms // standard ESCs will need at least 9 or 10 as TimeSlot. DropoutCount = 0; BlinkCount = 0; IntegralCount = 32; // do 32 cycles to find integral zero point while(Switch == 1) // as long as power switch is ON { // wait pulse pause delay time (TMR0 has 1024us for one loop) TMR0 = 0; T0IF = 0; T0IE = 1; // enable TMR0 RollSamples = NickSamples = 0; // zero gyros sum-up memory // sample gyro data and add everything up while waiting for timing delay GetGyroValues(); #ifdef BOARD_3_1 if( (BlinkCount & 0x03) == 0 ) // enter every 4th scan GetDirection(); // read compass sensor #endif while( TimeSlot > 0 ) { // Here is the place to insert own routines // It should consume as less time as possible! // ATTENTION: // Your routine must return BEFORE TimeSlot reaches 0 // or non-optimal flight behavior might occur!!! } T0IE = 0; // disable timer GetGyroValues(); nisampcnt = 2; // 2 samples done /* this section is no longer needed if( nisampcnt & 0x01 ) // odd value? { nisampcnt++; // one more sample to get even numbers GetGyroValues(); } */ ReadEEdata(); // re-sets TimeSlot // Setup Blink counter if( BlinkCount == 0 ) BlinkCount = BLINK_LIMIT; BlinkCount--; // get the gyro values and Batt status CalcGyroValues(); GetVbattValue(); // check for signal dropout while in flight if( _NoSignal && _Flying ) { DropoutCount++; if( DropoutCount < MAXDROPOUT ) { // use last Gas ALL_LEDS_OFF; IRoll = 0; INick = 0; ITurn = 0; goto DoPID; } break; // timeout, stop everything } // allow motors to run on low throttle // even if stick is at minimum for a short time if( _Flying && (IGas <= _ThresStop) ) { if( --LowGasCount > 0 ) goto DoPID; } if( _NoSignal || ( (_Flying && (IGas <= _ThresStop)) || (!_Flying && (IGas <= _ThresStart)) ) ) { // UFO is landed, stop all motors TimeSlot += 2; // to compensate PID() calc time! IntegralCount = 32; // do 32 cycles to find integral zero point InitArrays(); // resets _Flying flag! MidRoll = 0; // gyro neutral points MidNick = 0; MidTurn = 0; YawNeutral = RollNeutral = // stick neutral points NickNeutral = 0x7F; if( _NoSignal && Switch ) // _NoSignal set, but Switch is on? { break; // then RX signal was lost } ALL_LEDS_OFF; LedGreen_ON; #ifdef BOARD_3_0 if( !_SerEnabled ) { SPEN = 1; // enable RS232 CREN = 1; _SerEnabled = 1; } #endif ProcessComCommand(); } else { // UFO is flying! if( !_Flying ) // about to start { // set current gyro values as midpoints if( RollNeutral == 0x7F ) RollNeutral = IRoll; if( NickNeutral == 0x7F ) NickNeutral = INick; if( YawNeutral == 0x7F ) YawNeutral = ITurn; #ifdef BOARD_3_1 AbsDirection = COMPASS_INVAL; #endif #ifdef BOARD_3_0 // check if LISL Sensor is available if( _UseLISL && _SerEnabled ) { SPEN = 0; // disable RS232 to allow LISL sensor to work CREN = 0; TRISC.7 = 1; // RC7 is input (data) TRISC.6 = 0; // RC6 is output (clock) _SerEnabled = 0; } // if no LISL available, do COM commands also (important if you set ConfigParam wrong!) if( _SerEnabled ) #endif ProcessComCommand(); } _Flying = 1; DropoutCount = 0; LowGasCount = 100; #ifdef NADA // test ALL_LEDS_OFF; nii = IRoll - RollNeutral; if( (nii > 5) || (nii < -5) ) LedRed_ON; nii = INick - NickNeutral; if( (nii > 5) || (nii < -5) ) LedYellow_ON; nii = ITurn - YawNeutral; if( (nii > 5) || (nii < -5) ) LedBlue_ON; #endif // LED game #ifndef NOLEDGAME // do the LED game :-) ALL_LEDS_OFF; #define LED_SHOW_LIM 2 if( !_LowBatt ) { nii = IRoll-RollNeutral; if( nii > LED_SHOW_LIM ) { LedRed_ON; } if( nii < -LED_SHOW_LIM ) { LedGreen_ON; } x = INick-NickNeutral; if( nii > LED_SHOW_LIM ) { LedBlue_ON; } if( nii < -LED_SHOW_LIM ) { LedYellow_ON; } if( ARE_ALL_LEDS_OFF ) ALL_LEDS_ON; } #endif DoPID: // do the calculations Rp = 0; Np = 0; if( IntegralCount > 0 ) IntegralCount--; else { PID(); MixAndLimit(); } // remember old gyro values REp = RE; NEp = NE; TEp = TE; } if( _LowBatt ) { if( BlinkCount < BLINK_LIMIT/2 ) { Beeper_OFF; LedRed_OFF; } else { Beeper_ON; LedRed_ON; } } // Output the results to the speed controllers MixAndLimitCam(); OutSignals(); } // END NORMAL OPERATION WHILE LOOP // CPU kommt hierher wenn der Schalter ausgeschaltet wird Beeper_OFF; #ifdef BOARD_3_0 SPEN = 1; // enable RS232 CREN = 1; _SerEnabled = 1; #endif } ALL_OUTPUTS_OFF; }
void main(void) { int8 i; DisableInterrupts; InitPorts(); InitADC(); OpenUSART(USART_TX_INT_OFF&USART_RX_INT_OFF&USART_ASYNCH_MODE& USART_EIGHT_BIT&USART_CONT_RX&USART_BRGH_HIGH, _B38400); OpenTimer0(TIMER_INT_OFF&T0_8BIT&T0_SOURCE_INT&T0_PS_1_16); OpenTimer1(T1_8BIT_RW&TIMER_INT_OFF&T1_PS_1_8&T1_SYNC_EXT_ON&T1_SOURCE_CCP&T1_SOURCE_INT); OpenCapture1(CAPTURE_INT_ON & C1_EVERY_FALL_EDGE); // capture mode every falling edge CCP1CONbits.CCP1M0 = NegativePPM; OpenTimer2(TIMER_INT_ON&T2_PS_1_16&T2_POST_1_16); PR2 = TMR2_5MS; // set compare reg to 9ms INTCONbits.TMR0IE = false; // setup flags register for ( i = 0; i<16; i++ ) Flags[i] = false; _NoSignal = true; InitArrays(); ReadParametersEE(); ConfigParam = 0; ALL_LEDS_OFF; Beeper_OFF; LedBlue_ON; INTCONbits.PEIE = true; // enable peripheral interrupts EnableInterrupts; LedRed_ON; // red LED on Delay1mS(100); IsLISLactive(); #ifdef ICD2_DEBUG _UseLISL = 1; // because debugger uses RB7 (=LISL-CS) :-( #endif NewK1 = NewK2 = NewK3 = NewK4 =NewK5 = NewK6 = NewK7 = 0xFFFF; PauseTime = 0; InitBarometer(); InitDirection(); Delay1mS(COMPASS_TIME); // send hello text to serial COM Delay1mS(100); ShowSetup(true); Delay1mS(BARO_PRESS_TIME); while(1) { // turn red LED on of signal missing or invalid, green if OK // Yellow led to indicate linear sensor functioning. if( _NoSignal || !Switch ) { LedRed_ON; LedGreen_OFF; if ( _UseLISL ) LedYellow_ON; } else { LedGreen_ON; LedRed_OFF; LedYellow_OFF; } ProcessComCommand(); } } // main
// if a command is waiting, read and process it. // Do NOT call this routine while in flight! void ProcessComCommand(void) { int size1 *p; uns8 nireg; nireg = RecvComChar(); if( nireg.6 ) // 0x40..0x7F, a character nireg.5=0; switch( nireg ) { case '\0' : break; case 'L' : // List parameters SendComText(SerList); // must send it (UAVPset!) if( IK5 > _Neutral ) SendComChar('2'); else SendComChar('1'); ReadEEdata(); nireg = 1; for(p = &FirstProgReg; p <= &LastProgReg; p++) { SendComText(SerReg1); SendComValU(nireg); SendComText(SerReg2); SendComValS(*p); nireg++; } ShowPrompt(); break; case 'M' : // modify parameters LedBlue_ON; SendComText(SerReg1); nireg = RecvComNumU(); nireg--; SendComText(SerReg2); // = nival = RecvComNumS(); EEDATA = nival; if( IK5 > _Neutral ) nireg += _EESet2; EEADR = nireg; // prog values into data flash ProgRegister(); // if config register on set #1 is progged, // write through the transmitter config bits to set #2 if( nireg == 15 /* = &ConfigParam - &FirstProgReg */ ) { nival &= 0x12; // read the programmed value // mask only bits _FutabaMode and _NegativePPM EEADR += _EESet2; // goto set #2 // da gehts no RD = 1; // da niimer EEDATA &= 0xED; EEDATA |= nival; ProgRegister(); // write to set#2 config reg } LedBlue_OFF; ShowPrompt(); break; case 'S' : // show status ShowSetup(0); break; case 'N' : // neutral values SendComText(SerNeutralR); SendComValS(NeutralLR); SendComText(SerNeutralN); SendComValS(NeutralFB); SendComText(SerNeutralY); Tp -= 1024; // subtract 1g (vertical sensor) SendComValS(NeutralUD); ShowPrompt(); break; case 'R': // receiver values SendComText(SerRecvCh); SendComValU(IGas); SendComChar(','); SendComChar('R'); SendComChar(':'); SendComValS(IRoll); SendComChar(','); SendComChar('N'); SendComChar(':'); SendComValS(INick); SendComChar(','); SendComChar('Y'); SendComChar(':'); SendComValS(ITurn); SendComChar(','); SendComChar('5'); SendComChar(':'); SendComValU(IK5); SendComChar(','); SendComChar('6'); SendComChar(':'); SendComValU(IK6); SendComChar(','); SendComChar('7'); SendComChar(':'); SendComValU(IK7); ShowPrompt(); break; case 'B': // call bootloader #asm movlw 0x1f movwf PCLATH dw 0x2F00 #endasm // BootStart(); // never comes back! #ifndef TESTOUT case 'T': RE = 10; NE = 20; Rw = 30; Nw = 40; MatrixCompensate(); ShowPrompt(); break; #endif case '?' : // help SendComText(SerHelp); ShowPrompt(); } }