void Cartridge::ReadUnif(std::istream& stream,FavoredSystem favoredSystem,Profile& profile) { Log::Suppressor logSupressor; Ram prg, chr; ProfileEx profileEx; Unif::Load( stream, NULL, false, NULL, prg, chr, favoredSystem, profile, profileEx, NULL ); SetupBoard( prg, chr, NULL, NULL, profile, profileEx, NULL ); }
void Cartridge::ReadRomset(std::istream& stream,FavoredSystem favoredSystem,bool askSystem,Profile& profile) { Log::Suppressor logSupressor; Ram prg, chr; ProfileEx profileEx; Romset::Load( stream, NULL, false, NULL, prg, chr, favoredSystem, askSystem, profile, true ); SetupBoard( prg, chr, NULL, NULL, profile, profileEx, NULL, true ); }
main() { Dudes *Board[8][8]; CreateBoard(Board); SetupBoard(Board); while (1) { TakeTurn(Board); } }
void RunSpeedSimulation ( __global int* intStream, int* pCharPos, int cSimulations, int seed ) { //These are needed for FastRandom function calls unsigned long mt[N]; int mti=N+1; SimulationResults results; Board board; double averageResult = 0.0; double blackWinPercentage = 0; int x; SetupBoard(&board); init_genrand(seed, mt, &mti); results.blackPlays = 0; results.whitePlays = 0; for(x = 0; x < cSimulations; x++) { MonteCarloSimulate(&board, genrand_int32(mt, &mti), &results, mt, &mti); averageResult += results.scoreInFavourOfBlack; if(results.scoreInFavourOfBlack > 0) blackWinPercentage++; } WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)averageResult / cSimulations, 5); WriteStringToIntStream(intStream, pCharPos, ") <average result> with "); WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)blackWinPercentage / cSimulations, 5); WriteStringToIntStream(intStream, pCharPos, ") <average black win percentage>\n"); WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)results.blackPlays / cSimulations, 5); WriteStringToIntStream(intStream, pCharPos, ") <average black plays>\n"); WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)results.whitePlays / cSimulations, 5); WriteStringToIntStream(intStream, pCharPos, ") <average white plays>\n"); }
int main() { Setup(); SetupBoard(); while (!(key[KEY_ESC]) && RedLeft > 0 && BlackLeft > 0) { DrawBackGround(); Clicks(); CheckPlay(); Flip(); } destroy_bitmap(buffer2); destroy_bitmap(buffer); unload_datafile(data); }
void RunBasicSimulations ( __global int* intStream, int* pCharPos ) { int streamPos = 0; //These are needed for FastRandom function calls unsigned long mt[N]; int mti=N+1; Board board; SetupBoard(&board); Board_ToString(&board, intStream, pCharPos); WriteCharToIntStream(intStream, pCharPos, '\n'); Board_MetaToString(&board, intStream, pCharPos); WriteCharToIntStream(intStream, pCharPos, '\n'); Board_LibsToString(&board, intStream, pCharPos); WriteCharToIntStream(intStream, pCharPos, '\n'); { SimulationResults results; MonteCarloSimulate(&board, 20452, &results, mt, &mti); WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)results.scoreInFavourOfBlack, 0); WriteStringToIntStream(intStream, pCharPos, ") <1st black score>\n"); MonteCarloSimulate(&board, 3452, &results, mt, &mti); WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)results.scoreInFavourOfBlack, 0); WriteStringToIntStream(intStream, pCharPos, ") <2nd black score>\n"); MonteCarloSimulate(&board, 3422, &results, mt, &mti); WriteStringToIntStream(intStream, pCharPos, "("); WriteFloatToIntStream(intStream, pCharPos, (float)results.scoreInFavourOfBlack, 0); WriteStringToIntStream(intStream, pCharPos, ") <3rd black score>\n"); } }
int main(void) #endif { BYTE RecvdByte; initCDC(); // setup the CDC state machine SetupBoard(); //setup the hardware, customize for your hardware usb_init(cdc_device_descriptor, cdc_config_descriptor, cdc_str_descs, USB_NUM_STRINGS); // initialize USB. TODO: Remove magic with macro usb_start(); //start the USB peripheral // PIC18 INTERRUPTS // It is the users resposibility to set up high, low or legacy mode // interrupt operation. The following macros for high and low interrupt // setup have been removed: //#define EnableUsbHighPriInterrupt() do { RCONbits.IPEN = 1; IPR2bits.USBIP = 1; INTCONbits.GIEH = 1;} while(0) // JTR new //#define EnableUsbLowPriInterrupt() do { RCONbits.IPEN = 1; IPR2bits.USBIP = 0; INTCONbits.GIEL = 1;} while(0) // JTR new // By default, the interrupt mode will be LEGACY (ISR Vector 0x08) // (Same as high priority vector wise but the operation (latency) is // not the same. Consult the data sheet for details.) // If a priority mode is enabled then this affects ALL other interrupt // sources therefore it does not belong to the usb stack to be // doing this. It is a global, user application choice. #if defined USB_INTERRUPTS // See the prj_usb_config.h file. EnableUsbPerifInterrupts(USB_TRN + USB_SOF + USB_UERR + USB_URST); #if defined __18CXX //turn on interrupts for PIC18 INTCONbits.PEIE = 1; INTCONbits.GIE = 1; #endif EnableUsbGlobalInterrupt(); // Only enables global USB interrupt. Chip interrupts must be enabled by the user (PIC18) #endif // Wait for USB to connect do { #ifndef USB_INTERRUPTS usb_handler(); #endif } while (usb_device_state < CONFIGURED_STATE); usb_register_sof_handler(CDCFlushOnTimeout); // Register our CDC timeout handler after device configured // Main echo loop do { // If USB_INTERRUPT is not defined each loop should have at least one additional call to the usb handler to allow for control transfers. #ifndef USB_INTERRUPTS usb_handler(); #endif // Receive and send method 1 // The CDC module will call usb_handler each time a BULK CDC packet is sent or received. // If there is a byte ready will return with the number of bytes available and received byte in RecvdByte if (poll_getc_cdc(&RecvdByte)) putc_cdc(RecvdByte+1); // // Receive and send method 2 // Same as poll_getc_cdc except that byte is NOT removed from queue. // This function will wait for a byte and return and remove it from the queue when it arrives. if (peek_getc_cdc(&RecvdByte)) { RecvdByte = getc_cdc(); putc_cdc(RecvdByte+1); } // Receive and send method 3 // If there is a byte ready will return with the number of bytes available and received byte in RecvdByte // use CDC_Flush_In_Now(); when it has to be sent immediately and not wait for a timeout condition. if (poll_getc_cdc(&RecvdByte)) { putc_cdc(RecvdByte+1); // CDC_Flush_In_Now(); } } while (1); } //end main
int main ( void ) { /** pin buttons locals */ volatile bool regPinButton1; volatile bool regPinButton2; /** speed local */ short iRefSpeed; // Configure Oscillator to operate the device at 40Mhz // Fosc= Fin*M/(N1*N2), Fcy=Fosc/2 // Fosc= 8*40/(2*2)= 80Mhz for 8M input clock PLLFBD = 38; // M=40 CLKDIVbits.PLLPOST = 0; // N1=2 CLKDIVbits.PLLPRE = 0; // N2=2 // while(OSCCONbits.LOCK != 1) {}; // Wait for PLL to loc /** setup dsPIC ports */ SetupPorts(); /** init user parameters */ InitUserParms(); /** init user specified parms and stop on error */ if( SetupPeripherals() ) { /* Error */ return 0; } uGF.Word = 0; // clear flags while(1) { // init Mode eStateControl = CNTRL_STOP; iLockLoopCnt = 0; /** clear the variables other than STOP command */ uGF.bit.TLock = 0; uGF.bit.Btn1Pressed = 0; uGF.bit.Btn2Pressed = 0; uGF.bit.DoSnap = 0; uGF.bit.SnapDone = 0; /** ============= Open Loop ======================*/ OpenLoopParm.qVelMech = dqOL_VelMech; CtrlParm.qVelRef = OpenLoopParm.qVelMech; iRefSpeed = CtrlParm.qVelRef; InitOpenLoop(); /** Inital offsets for currents */ InitMeasCompCurr( 450, 730 ); // init board SetupBoard(); // Enable ADC interrupt and begin main loop timing IFS0bits.AD1IF = 0; IEC0bits.AD1IE = 1; /** Initialize private variables used by CalcVelIrp. */ InitCalcVel(); /** Initialize private variables used by CurrModel */ InitCurModel(); // zero out i sums PIParmD.qdSum = 0; PIParmQ.qdSum = 0; PIParmQref.qdSum = 0; // zero out i out PIParmD.qOut = 0; PIParmQ.qOut = 0; PIParmQref.qOut = 0; /** if state is stop */ if(eStateControl == CNTRL_STOP) { //wait here until button 1 is pressed or stop time elapsed while(uGF.bit.TStop){}; while(!pinButton1) { /** make sure that the STOP do not occur due to this loop */ iStopLoopCnt = 0; // Start offset accumulation //and accumulate current offset while waiting MeasCompCurr(); } while(pinButton1); //when button 1 is released eStateControl = CNTRL_OPEN_LOOP; //then start motor in open loop } // Run the motor uGF.bit.ChangeMode = 1; // Enable the driver IC on the motor control PCB pinPWMOutputEnable_ = 0; //Run Motor loop while(1) { /** algorithm was stopped before*/ if(uGF.bit.TStop) { /* break the while */ break; } /* for logic of this application 2 buttons are used S3 and S6. If both buttons are pressed the state of the application is commuted between OPEN_LOOP, CLOSED_LOOP and CLOSED_LOOP_DOUBLE_SPEED. The touch of only one button will increase the speed in one of the states enumerated above */ /* read the buttons state */ /* while no buttons are pushed */ do{ regPinButton1 = pinButton1; /* pin button 1 */ /* retain if pressed */ if(regPinButton1 == 1) { uGF.bit.Btn1Pressed=1; } regPinButton2 = pinButton2; /* pin button 2 */ /* retain if pressed */ if(regPinButton2 == 1) { uGF.bit.Btn2Pressed=1; } /** make sure that the STOP do not occur due to this loop */ iStopLoopCnt = 0; }while((!regPinButton1)&&(!regPinButton2)); /* while buttons are released */ do{ regPinButton1 = pinButton1; /* pin button 1 */ /* retain if pressed */ if(regPinButton1 == 1) { uGF.bit.Btn1Pressed=1; } regPinButton2 = pinButton2; /* pin button 2 */ /* retain if pressed */ if(regPinButton2 == 1) { uGF.bit.Btn2Pressed=1; } }while(pinButton1||pinButton2); /** the counter for STOP is cleared - if buttons released */ iStopLoopCnt = 0; /* check if one of the buttons is pressed */ /* check if both buttons are pressed */ if ((uGF.bit.Btn1Pressed)&&(uGF.bit.Btn2Pressed)) { /* if yes */ /* clear both flags indicating the buttons were pressed */ uGF.bit.Btn1Pressed = 0; uGF.bit.Btn2Pressed = 0; /* and command not locked */ /* check if command not locked */ if(!uGF.bit.TLock) { /* lock command for Tlock_multiple */ uGF.bit.TLock = 1; /* command locked */ iLockLoopCnt = 0; /* reset counter */ /* state machine for control algorithm */ switch(eStateControl) { /* the previous state was STOP */ case CNTRL_OPEN_LOOP: { /* swich the state machine */ eStateControl = CNTRL_CLOSED_LOOP; /* first switch the global flag */ uGF.bit.ChangeMode = 1; break; } case CNTRL_CLOSED_LOOP: { /* double the speed of the motor */ /* and swich the state machine */ eStateControl = CNTRL_CLOSED_LOOP_DBL_SPEED; /* double the speed */ iRefSpeed += iRefSpeed; #ifdef SNAPSHOT uGF.bit.DoSnap = 1; SnapCount = 0; #endif break; } case CNTRL_CLOSED_LOOP_DBL_SPEED: { /* divide by 2 the speed of the motor */ /* and swich the state machine */ eStateControl = CNTRL_CLOSED_LOOP; /* divide the speed by 2 */ iRefSpeed -= iRefSpeed/2; #ifdef SNAPSHOT uGF.bit.DoSnap = 1; SnapCount = 0; #endif break; } default: { /* undefined state, stop */ eStateControl = CNTRL_STOP; /* disable the PWM module */ pinPWMOutputEnable_ = 1; break; } } } } /* check which button was pressed */ /* perhaps button 1 was the one */ else if(uGF.bit.Btn1Pressed) { /* if yes */ /* clear the button flag for future usage */ uGF.bit.Btn1Pressed = 0; /* and command not locked */ /* check if command not locked */ if(!uGF.bit.TLock) { /* lock command for Tlock_multiple */ uGF.bit.TLock = 1; /* command locked */ iLockLoopCnt = 0; /* reset counter */ /* increase speed with SPEED_STEP */ iRefSpeed += SPEED_STEP; } } /* it was button 2, but checking */ else if(uGF.bit.Btn2Pressed) { /* if yes */ /* clear the button flag for future usage */ uGF.bit.Btn2Pressed = 0; /* and command not locked */ /* check if command not locked */ if(!uGF.bit.TLock) { /* lock command for Tlock_multiple */ uGF.bit.TLock = 1; /* command locked */ iLockLoopCnt = 0; /* reset counter */ /* decrease speed with SPEED_STEP */ iRefSpeed -= SPEED_STEP; } } /** limit the reference to 60Hz */ if( iRefSpeed > MAX_SPEED_UP ) { iRefSpeed = MAX_SPEED_UP; } /** limit the reference to 60Hz */ if((signed short)iRefSpeed < (signed short)MAX_SPEED_DOWN ) { iRefSpeed = MAX_SPEED_DOWN; } /** update the global speed reference */ CtrlParm.qVelRef = iRefSpeed; if( uGF.bit.SnapDone ) { uGF.bit.SnapDone=0; } } // End of Run Motor loop } // End of Main loop // should never get here while(1){} }
void main(void) { uint16_t v; uint8_t i; int16_t pad; uint32_t padsNow=0; uint32_t padsLast=0; int8_t lastKey; uint8_t cnt=0; uint16_t lastEncValue; uint8_t encStep; int16_t senseDelta; uint8_t easteregg; SetupBoard(); SetupCTMU(); encStep=1; encValue=0; lastEncValue=0; octave=3; encMin=0; encMax=14; senseDelta=99; OpenTimer4(TIMER_INT_ON & T4_PS_1_1 & T4_POST_1_1); // Timer4 - Rotary Encoder polling WriteTimer4(0xFF); TMR4IF=0; OpenTimer2(TIMER_INT_ON & T2_PS_1_4 & T2_POST_1_8); // Timer2 = Display Refresh WriteTimer2(0xFF); TMR2IF=0; GIE=1; PEIE=1; ei(); disp[0]=0x00; disp[1]=0x00; disp[2]=0x00; keys=0; easteregg=0; leds=0x7fff; __delay_ms(25); leds=0x0000; CalibratePads(); leds=0x7fff; __delay_ms(25); leds=0x0000; // // encMin=1; // encMax=24; // encValue=1; // for (;;) { // pad=ReadPad(encValue); // DispValue(pad); // leds=0; // if ((encValue>=1) && (encValue<=9)) {setbit(leds,encValue-1); setbit(leds,10);} // if ((encValue>=10) && (encValue<=19)) {setbit(leds,encValue-10);setbit(leds,11);} // if ((encValue>=20) && (encValue<=29)) {setbit(leds,encValue-20);setbit(leds,12);} // __delay_ms(25); // } for (;;) { // Check for tones H+A+D if (padsLast==0b000000000000101000000100) EasterEgg(1); if (padsLast==0b101000000100000000000000) EasterEgg(2); padsNow=0; for (i=0; i<PADS; i++) { pad=ReadPad(i); if (GetPadBaseValue(i)-pad>senseDelta) { setbit(padsNow,i); } } for (i=0; i<PADS; i++) { if (testbit(padsNow,i) != testbit(padsLast,i)) { if (testbit(padsNow,i)) { SendNoteOn(octave*12+i); } else { SendNoteOff(octave*12+i); } } } padsLast=padsNow; for (i=0; i<KEYS; i++) { if (testbit(keys,i)) { disp[0]=charmap[butSettings[i].txt[0]-32]; disp[1]=charmap[butSettings[i].txt[1]-32]; disp[2]=charmap[butSettings[i].txt[2]-32]; lastKey=i; encMin=butSettings[i].min; encMax=butSettings[i].max; encValue=butSettings[i].value; encStep=butSettings[i].stepSize; lastEncValue=encValue; break; } } if ((encValue!=lastEncValue) && (lastKey!=-1)) { lastEncValue=encValue; if (butSettings[lastKey].cc==127) { // OCTAVE DispValue(encValue*encStep); octave=encValue; butSettings[lastKey].value=encValue; DispValue(encValue*encStep); } else if (butSettings[lastKey].cc==126) { // SENSE DELTA senseDelta=encValue; butSettings[lastKey].value=senseDelta; DispValue(senseDelta); if (senseDelta&1) setbit(leds,0); else clrbit(leds,0); } else { SendCC(butSettings[lastKey].cc, encValue*encStep); DispValue(encValue*encStep); } } __delay_ms(10); } }
void main(void) { static BYTE ledtrig; BYTE OutByte; SetupBoard(); //setup the hardware, USB SetupRC5(); usb_init(cdc_device_descriptor, cdc_config_descriptor, cdc_str_descs, USB_NUM_STRINGS); // TODO: Remove magic with macro initCDC(); // JTR this function has been highly modified It no longer sets up CDC endpoints. usb_start(); //usbbufflush(); //flush USB input buffer system ledtrig = 1; //only shut LED off once // Never ending loop services each task in small increments while (1) { do { // if (!TestGlobalUsbInterruptEnabled()) //JTR3 added usb_handler(); ////service USB tasks Guaranteed one pass in polling mode even when usb_device_state == CONFIGURED_STATE if ((usb_device_state < DEFAULT_STATE)) { // JTR2 no suspendControl available yet || (USBSuspendControl==1) ){ LedOff(); } else if (usb_device_state < CONFIGURED_STATE) { LedOff(); } else if ((ledtrig == 1) && (usb_device_state == CONFIGURED_STATE)) { // LedOn(); ledtrig = 0; } } while(usb_device_state < CONFIGURED_STATE); //TRISB &= 0x7f; //TRISB |= 0x40; //LATB |= 0x40; //mode = IRWIDGET; //irWidgetservice(); #ifdef UARTONLY //mode = USB_UART; Usb2UartService(); // Never returns #endif // Test for commands: 0, 1, 2 (Entry to SUMP MODE.) // Do not remove from input buffer, just take a PEEK. // SUMPLogicCommand will remove from input buffer // (Standardized coding) if (peek_getc_cdc(&OutByte)) { switch (OutByte) { case 0: //SUMP clear case 1: //SUMP run case 2: //SUMP ID mode = IR_SUMP; //put IR Toy in IR_SUMP mode irSUMPservice(); // Fully self contained, does not return until exited via 0x00 command. cdc_In_len = 0; mode = IR_DECODER; SetupRC5(); break; case 'r': //IRMAN decoder mode case 'R': OutByte = getc_cdc(); // now ok to remove byte from the USB buffer SetupRC5(); mode = IR_DECODER; putc_cdc('O'); putc_cdc('K'); CDC_Flush_In_Now(); break; case 'S': //IRs Sampling Mode case 's': OutByte = getc_cdc(); // now ok to remove byte from the USB buffer mode = IR_S; irsService(); // Fully self contained, does not return until exited via 0x00 command. cdc_In_len = 0; mode = IR_DECODER; SetupRC5(); break; case 'U': case 'u': OutByte = getc_cdc(); // now ok to remove byte from the USB buffer mode = USB_UART; Usb2UartService(); break; case 'P': case 'p':// IR Widget mode OutByte = getc_cdc(); // now ok to remove byte from the USB buffer mode = IRWIDGET; GetPulseFreq(); // Never returns //GetPulseTime(); break; case 'T': case 't'://self test OutByte = getc_cdc(); // now ok to remove byte from the USB buffer SelfTest(); //run the self-test break; case 'V': case 'v':// Acquire Version OutByte = getc_cdc(); // now ok to remove byte from the USB buffer GetUsbIrToyVersion(); break; case '$'://bootloader jump OutByte = getc_cdc(); // now ok to remove byte from the USB buffer BootloaderJump(); break; default: OutByte = getc_cdc(); }//switch(OutByte } // if peek OutByte == 1 ProcessIR(); //increment IR decoder state machine }//end while(1) }//end main
Cartridge::Cartridge(Context& context) : Image(CARTRIDGE), board(NULL), vs(NULL), favoredSystem(context.favoredSystem) { try { ProfileEx profileEx; switch (Stream::In(&context.stream).Peek32()) { case INES_ID: Ines::Load ( context.stream, context.patch, context.patchBypassChecksum, context.patchResult, prg, chr, context.favoredSystem, profile, profileEx, context.database ); break; case UNIF_ID: Unif::Load ( context.stream, context.patch, context.patchBypassChecksum, context.patchResult, prg, chr, context.favoredSystem, profile, profileEx, context.database ); break; default: Romset::Load ( context.stream, context.patch, context.patchBypassChecksum, context.patchResult, prg, chr, context.favoredSystem, context.askProfile, profile ); break; } if (profile.dump.state == Profile::Dump::BAD) context.result = RESULT_WARN_BAD_DUMP; else context.result = RESULT_OK; const Result result = SetupBoard( prg, chr, &board, &context, profile, profileEx, &prgCrc ); if (NES_FAILED(result)) throw result; board->Load( savefile ); switch (profile.system.type) { case Profile::System::VS_UNISYSTEM: vs = VsSystem::Create ( context.cpu, context.ppu, static_cast<PpuModel>(profile.system.ppu), prgCrc ); profile.system.ppu = static_cast<Profile::System::Ppu>(vs->GetPpuModel()); break; case Profile::System::VS_DUALSYSTEM: throw RESULT_ERR_UNSUPPORTED_VSSYSTEM; } if (Cartridge::QueryExternalDevice( EXT_DIP_SWITCHES )) Log::Flush( "Cartridge: DIP Switches present" NST_LINEBREAK ); } catch (...) { Destroy(); throw; } }