int16_t main(void) { initRobotBase(); powerON(); setLEDs(0b111111); mSleep(1000); setLEDs(0b000000); mSleep(500); uint8_t runningLight = 1; for (uint8_t i = 0; i < 6; i++){ for (uint8_t j = 0; j< 3;j++) destination[j] = destinationarray[i][j]; //mainloopOpen(); mainloopClosed(); fancyled(&runningLight); /*for (uint8_t j = 0; j< 3;j++) source[j] = destination[j];*/ mSleep(2000); } task_RP6System(); while(true) { fancyled(&runningLight); if (motioncomplete == 0) moveAtSpeed(0,0); mSleep(200); task_RP6System(); } return 0; }
uint32 copyMem(volatile uint32 *src, volatile uint32 *target, uint32 len){ uint32 *STORE2 = (uint32 *)0x40900030; uint32 i,j; uint32 checkSum = 0; j=0; setLEDs(GREEN); for(i=0;i<len;i+=4){ *STORE2 = i; //store how far got if it dies *target = *src; if( *target != *src ){ error(7, 0); readUInt(i); readUInt(*target); readUInt(*src); } src++; checkSum += *target++; j++; if(j==20000) setLEDs(BLUE); else if(j >= 40000){ setLEDs(GREEN); j=0; } } return checkSum; }
int main(void) { initRobotBase(); setLEDs(0b111111); mSleep(1500); setLEDs(0b000000); // Set Bumpers state changed event handler: BUMPERS_setStateChangedHandler(bumpersStateChanged); powerON(); // Turn Encoders, Motor Current Sensors // ATTENTION: Automatic Motor control will not work without this! /* RP6 SAGAN GENERATED COMMANDS START */ /*{SAGAN1_COMMANDS_HERE}*/ /* RP6 SAGAN GENERATED COMMANDS STOP */ stop(); moveAtSpeed(0, 0); BUMPERS_setStateChangedHandler(BUMPERS_stateChanged_empty); setLEDs(0b000000); while (true) { statusLEDs.LED2 = !statusLEDs.LED2; // Toggle LED bit in LED shadow register... statusLEDs.LED5 = !statusLEDs.LED5; updateStatusLEDs(); mSleep(500); task_RP6System(); } return 0; }
int main(void) { initRP6M256(); initLCD(); writeString_P_WIFI("\n\nRP6 CONTROL M256 I2C Master Example Program!\n"); // IMPORTANT: I2CTWI_initMaster(100); // Initialize the TWI Module for Master operation // with 100kHz SCL Frequency // Register the event handlers: I2CTWI_setTransmissionErrorHandler(I2C_transmissionError); setLEDs(0b1111); // Turn all LEDs on! showScreenLCD("################", "################"); mSleep(500); showScreenLCD("I2C-Master", "Example Program 1"); mSleep(1000); // --------------------------------------- setLEDs(0b0000); // All LEDs off! uint8_t counter = 1; // The command and register used here - in the next example we define them all. #define CMD_SET_ACS_POWER 9 #define ACS_PWR_MED 2 // Set ACS to medium power (you can see the ACS value changes in the raw registers): I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_ACS_POWER, ACS_PWR_MED); while(true) { // Increment a counter and send value to LEDs of the // Slave Controller: setLEDs(0b0001); showScreenLCD("INCREMENT", "COUNTER"); setCursorPosLCD(1, 11); writeIntegerLengthLCD(counter, DEC, 3); I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, 3, counter); counter++; // Read and display ALL registers of the slave controller: setLEDs(0b0010); readAllRegisters(); // Read the light sensors: setLEDs(0b0100); readLightSensors(); mSleep(250); } return 0; }
int main(void) { initRobotBase(); setLEDs(0b111111); mSleep(500); setLEDs(0b000000); writeString_P("\nJust a simple counter program\n\n"); uint16_t counter = 0; while(true) { timer = 0; if(counter < 100) { writeString_P("Counter: "); writeInteger(counter, BIN); writeString_P("(BIN) | "); writeInteger(counter, OCT); writeString_P("(OCT) | "); writeInteger(counter, DEC); writeString_P("(DEC) | "); writeInteger(counter, HEX); writeString_P("(HEX) "); } else { writeString_P("Counter L: "); writeIntegerLength(counter, BIN, 16); writeString_P("(BIN) | "); writeIntegerLength(counter, OCT, 6); writeString_P("(OCT) | "); writeIntegerLength(counter, DEC, 6); writeString_P("(DEC) | "); writeIntegerLength(counter, HEX, 4); writeString_P("(HEX) "); } writeChar(' '); writeInteger(timer,DEC); writeString(" *100us"); writeChar('\n'); counter++; mSleep(100); } return 0; }
//Blink LEDs for Debugging void blinkLEDs(unsigned int numTimes) { volatile unsigned int i = 0; if (numTimes > 5) numTimes = 5; //We Don't have all day man setLEDs(OFF); for (i = 0; i < numTimes * 2; i++) { setLEDs(LOGIC_TOGGLE); _delay_cycles(MCU_CLOCK / 2); //half second delay } }
void showStatus(uint8_t verdieping, uint16_t hoogte, uint8_t motor) { // "rechtsom aan", "Hoogte: 100 " showScreenLCD(" ", "H: V: "); setCursorPosLCD(0, 13); writeStringLCD_P("aan"); // motor status switch (motor) { case MOTOR_IDLE: setCursorPosLCD(0, 13); writeStringLCD_P("uit"); break; case MOTOR_LEFT: setCursorPosLCD(0, 0); writeStringLCD_P("Linksom"); break; case MOTOR_RIGHT: setCursorPosLCD(0, 0); writeStringLCD_P("Rechtsom"); break; } setCursorPosLCD(1, 3); writeIntegerLCD(hoogte, DEC); setCursorPosLCD(1, 15); writeIntegerLCD(verdieping, DEC); setLEDs(1 << verdieping); }
void KeyboardManager::serviceIRQ(void) { send_cmd(0xAD); // disable the keyboard kb_wait(); uint8 scancode = inportb(0x60); if (extended_scancode == 0xE0) { if (scancode == 0x2A || scancode == 0x36 || scancode >= E0_BASE) { extended_scancode = 0; send_cmd(0xAE); // enable the keyboard return; } scancode = E0_KEYS[scancode]; } else if (extended_scancode == 0xE1 && scancode == 0x1D) { extended_scancode = 0x100; send_cmd(0xAE); // enable the keyboard return; } else if (extended_scancode == 0x100 && scancode == 0x45) scancode = E1_PAUSE; extended_scancode = 0; if (scancode == 0xFF || scancode == 0xFA || scancode == 0xFE || scancode == 0x00) // non parsable codes, ACK and keyb. buffer errors { debug(A_KB_MANAGER, "Non-parsable scancode %X \n", scancode); send_cmd(0xAE); // enable the keyboard return; } if (scancode == 0xE0 || scancode == 0xE1) { extended_scancode = scancode; send_cmd(0xAE); // enable the keyboard return; } modifyKeyboardStatus(scancode); setLEDs(); // setting the leds if ((scancode & 0200)) // if a key was released just ignore it { send_cmd(0xAE); // enable the keyboard return; } if (main_console) { keyboard_buffer_.put(scancode); // put it inside the buffer main_console->addJob(); } send_cmd(0xAE); // enable the keyboard }
void PS2KeyboardManager::processKey(PS2Keyboard::Key key) { int index = key.code() / 8; int bit = key.code() % 8; if (key.type() == PS2Keyboard::KEY_PRESSED) { pressed_[index] |= 1 << bit; } else { pressed_[index] &= ~(1 << bit); // Handle LEDs. byte mask = 0; switch (key.code()) { case PS2Keyboard::KC_SCROLL_LOCK: mask = LED_SCROLL_LOCK; break; case PS2Keyboard::KC_KP_NUM_LOCK: mask = LED_NUM_LOCK; break; case PS2Keyboard::KC_CAPS_LOCK: mask = LED_CAPS_LOCK; break; default: break; } if (mask != 0) setLEDs(mask, ~leds_); } }
void RGBWLamp::setColor(HSIColor &color) { std::vector<float> LEDs = _colorspace->Hue2LEDs(color); for (int i=0; i<LEDs.size(); i++) { LEDs[i] = _maxvalues[i] * LEDs[i]; } setLEDs(LEDs, _pins); }
/** * Here we do a small LED test * (a running light with direction changing)! * For timing we use Stopwatch #1. */ void runningLight(void) { static uint8_t runLight = 1; static uint8_t dir; // Moving direction for running light // The "static" keyword in front of these two local variables means that they // are NOT cleared when leaving this function. Their content is kept and they // act just like global variables (but they are only accessible within // this function)! You already saw this on RP6 Robot Base Examples... // We want a 100ms delay between the calls, which results in 10Hz refresh rate of // the running light. // ATTENTION: DO NOT USE "==" to compare to the stopwatch values, // use only ">" or "<" or ">=" because you could miss the point where the stopwatch // has the exact value! if(getStopwatch1() > 100) // 100ms { // Set status LEDs to the value of the variable testLEDs: setLEDs(runLight); // Shift the LED bit left or right depending on direction: if(dir == 0) runLight <<= 1; else runLight >>= 1; // Change the direction if we reached one of the two outer LEDs: if(runLight > 7 ) dir = 1; else if (runLight < 2 ) dir = 0; // Reset Stopwatch1: setStopwatch1(0); }
int main(void) { initRP6M256(); initLCD(); // --------------------------------------- WDT_setRequestHandler(watchDogRequest); // --------------------------------------- I2CTWI_initMaster(100); I2CTWI_setRequestedDataReadyHandler(I2C_requestedDataReady); I2CTWI_setTransmissionErrorHandler(I2C_transmissionError); setLEDs(0b1111); mSleep(1000); setLEDs(0b0000); // --------------------------------------- // Setup ACS power: I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_ACS_POWER, ACS_PWR_OFF); // Enable Watchdog for Interrupt requests: I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_WDT, true); // Enable timed watchdog requests: I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_WDT_RQ, true); startStopwatch1(); startStopwatch2(); startStopwatch3(); while(true) { /* mSleep(600); warnForObs(); mSleep(600); task_checkINT(); mSleep(600); light_detection(); mSleep(600); task_I2CTWI(); mSleep(600);*/ writeIntegerLength_WIFI(adcBat,DEC,4); behaviourController(); } return 0; }
void fancyled(uint8_t *runningLight) { setLEDs(*runningLight); *runningLight <<= 1; if(*runningLight > 32) *runningLight = 1; }
void ApplePS2Keyboard::setDevicePowerState( UInt32 whatToDo ) { switch ( whatToDo ) { case kPS2C_DisableDevice: // // Disable keyboard. // setKeyboardEnable( false ); break; case kPS2C_EnableDevice: // // Reset the keyboard to its default state. // PS2Request * request = _device->allocateRequest(); if (request) { request->commands[0].command = kPS2C_WriteDataPort; request->commands[0].inOrOut = kDP_SetDefaults; request->commands[1].command = kPS2C_ReadDataPortAndCompare; request->commands[1].inOrOut = kSC_Acknowledge; request->commandsCount = 2; _device->submitRequestAndBlock(request); _device->freeRequest(request); } // // Initialize the keyboard LED state. // setLEDs(_ledState); // // Enable the keyboard clock (should already be so), the keyboard // IRQ line, and the keyboard Kscan -> scan code translation mode. // setCommandByte( kCB_EnableKeyboardIRQ | kCB_TranslateMode, kCB_DisableKeyboardClock ); // // Finally, we enable the keyboard itself, so that it may start // reporting key events. // setKeyboardEnable( true ); break; } }
void KeyboardManager::serviceIRQ(void) { uint8 scancode = kmi->data; #if QEMU_SENDS_SCANCODE_SET2 if(scancode == 0xf0) next_is_up_ = 1; #endif // left shift release (0xAA) and right shift release (0xB6) must not be ignored when scancode set 1 is sent by qemu: if (scancode > 0x80 && scancode != 0xAA && scancode != 0xB6) return; #if QEMU_SENDS_SCANCODE_SET2 scancode = SET1_SCANCODES[scancode]; if(next_is_up_) { next_is_up_ = 0; modifyKeyboardStatus(scancode | 0x80); return; } #endif if (extended_scancode == 0xE0) { if (scancode == 0x2A || scancode == 0x36 || scancode >= E0_BASE) { extended_scancode = 0; } scancode = E0_KEYS[scancode]; } else if (extended_scancode == 0xE1 && scancode == 0x1D) { extended_scancode = 0x100; } else if (extended_scancode == 0x100 && scancode == 0x45) scancode = E1_PAUSE; extended_scancode = 0; if (scancode == 0xFF || scancode == 0xFA || scancode == 0xFE || scancode == 0x00) // non parsable codes, ACK and keyb. buffer errors { debug(A_KB_MANAGER, "Non-parsable scancode %X \n", scancode); } if (scancode == 0xE0 || scancode == 0xE1) { extended_scancode = scancode; } modifyKeyboardStatus(scancode); setLEDs(); // setting the leds if (main_console) { keyboard_buffer_.put(scancode); // put it inside the buffer } }
int main(void) { initRobotBase(); setLEDs(0b111111); mSleep(2500); setLEDs(0b100100); BUMPERS_setStateChangedHandler(bumpersStateChanged); powerON(); while(true) { behaviourController(); task_RP6System(); } return 0; }
void setup(void) { initRP6Control(); setLEDs(0b0000); dischargePeakDetector(); initLCD(); clearLCD(); }
// Declare Global variables int main(void) { // Set up Create and module initializeCommandModule(); powerOnRobot(); // Is the Robot on byteTx(CmdStart); // Start the create baud(Baud57600); // Set the baud rate for the Create and Command Module defineSongs(); // Define some songs so that we know the robot is on. byteTx(CmdControl); // Deprecated form of safe mode. I use it because it will // turn of all LEDs, so it's essentially a reset. byteTx(CmdFull); // We are operating in FULL mode. // Play the reset song and wait while it plays. byteTx(CmdPlay); byteTx(RESET_SONG); delayMs(750); // Turn the power button on to something. turnOnPowerButtonLight(); delayMs(20); // Infinite operation loop int timerLoop = 0; const int timerLimit = 15; initializeUSBBuffer(); initializeRobotBuffer(); initializeSensorArray(); setLEDs(BOTHLED, FULL); enableReports(); enableSensors(); while(1) { pollSensors(); if(timerLoop == timerLimit){ compileReport(); sendUSBBuffer(); timerLoop = 0; delayMs(1); } timerLoop++; pollRemoteSensors(); pollRemote(); executeCommand(); delayMs(5); } }
void ApplePS2Keyboard::setNumLockFeedback(bool locked) { // // Set the keyboard LEDs to reflect the state of num lock. // // It is safe to issue this request from the interrupt/completion context. // _ledState = locked ? (_ledState | kLED_NumLock):(_ledState & ~kLED_NumLock); setLEDs(_ledState); }
// Declare Global variables int main(void) { // Set up Create and module initializeCommandModule(); powerOnRobot(); // Is the Robot on byteTx(CmdStart); // Start the create baud(Baud57600); // Set the baud rate for the Create and Command Module defineSongs(); // Define some songs so that we know the robot is on. byteTx(CmdControl); // Deprecated form of safe mode. I use it because it will // turn of all LEDs, so it's essentially a reset. byteTx(CmdFull); // We are operating in FULL mode. // Play the reset song and wait while it plays. byteTx(CmdPlay); byteTx(RESET_SONG); delayMs(750); // Turn the power button on to something. delayMs(20); initializeUSBBuffer(); initializeRobotBuffer(); initializeSensorArray(); setLEDs(BOTHLED, FULL); enableReports(); enableSensors(); int fakeTimer = 0; // Infinite operation loop while(1) { if (fakeTimer == 4) { compileReport(); sendUSBBuffer(); fakeTimer = 0; } pollSensors(); delayMs(250); fakeTimer++; } }
void KeyboardManager::serviceIRQ(void) { uint8 scancode = kmi->data; if(scancode == 0xf0) next_is_up_ = 1; if (scancode > 0x80) return; scancode = SET1_SCANCODES[scancode]; if(next_is_up_) { next_is_up_ = 0; modifyKeyboardStatus(scancode | 0x80); return; } if (extended_scancode == 0xE0) { if (scancode == 0x2A || scancode == 0x36 || scancode >= E0_BASE) { extended_scancode = 0; } scancode = E0_KEYS[scancode]; } else if (extended_scancode == 0xE1 && scancode == 0x1D) { extended_scancode = 0x100; } else if (extended_scancode == 0x100 && scancode == 0x45) scancode = E1_PAUSE; extended_scancode = 0; if (scancode == 0xFF || scancode == 0xFA || scancode == 0xFE || scancode == 0x00) // non parsable codes, ACK and keyb. buffer errors { debug(A_KB_MANAGER, "Non-parsable scancode %X \n", scancode); } if (scancode == 0xE0 || scancode == 0xE1) { extended_scancode = scancode; } modifyKeyboardStatus(scancode); setLEDs(); // setting the leds if (main_console) { keyboard_buffer_.put(scancode); // put it inside the buffer } }
//control passed here from bootTestCrt.S after creating stack int boot(){ uint32 *STORE1 = (uint32 *)0x4090002c; //Use RTC alarms as uint32 *STORE2 = (uint32 *)0x40900030; // storage for debugging int i,j; *STORE1 = 0x98765; setupLEDs(); setLEDs(GREEN); uint32 *kernel = (uint32 *)(RAM_START + KERNEL_OFFSET); uint32 *tags = (uint32 *)(RAM_START + TAGS_OFFSET); uint32 cs; setLEDs(GREEN); //now we need to copy the kernel code to where it likes to be cs = copyMem((uint32*)kernel_start,kernel, (kernel_end - kernel_start)); if(cs != KERN_CHECKSUM) error(5,0); setup_tags(tags); setLEDs(BLUE); uint32 mtype = MACH_TYPE_HPIPAQ214; void (*theKernel)(uint32 zero, uint32 mtype, uint32 *tags); theKernel = (void (*)(uint32, uint32, uint32 *))kernel; /* set the kernel address */ theKernel(0, mtype, tags); /* jump to kernel with register set */ death: __asm("nop"); goto death; }
/* called by timer every 20ms */ void adjustLights() { if (!pauseLED) { if (stepIndex<stepCount) { stepIndex++; float v[LEDS]; morph(v); for (int i=0; i<LEDS; i++) { v[i]+=offset[i]; } setLEDs(v); } } }
void procData() { procTimer2.stop(); //Stop the delay timer String response = thisFrame.getResponseString(); if (response.length() <1) Serial.println("Sensor value wasn't returned."); // Split the response into elements using ":" as a separator character (ascii 58) int a = splitString(response, 58, colours); // Calculate and scale colour values normaliseValues(); // Set the PWM values setLEDs(); }
void testLPABallon( void ) { initLCD(); // Initialize the LC-Display (LCD) showScreenLCD("################", "################"); mSleep(500); showScreenLCD("Tst LPA BallonLIB", "versie 29jun15"); mSleep(500); // --------------------------------------- setLEDs(0b0000); // All LEDs off! // This text is fixed on the LCD. Only the // key and ADC values are changed later on! showScreenLCD("hoogte: ", "VS: BS:"); while(true) { // read some simulations parameter values and display them on teh LCD showSimParams(); // Check if a key is pressed: uint8_t key = getPressedKeyNumber(); // This function returns a 0 if no key is pressed and the key number from 1 to 5 otherwise. if(key) // If a key is pressed... (key != 0) { // ... and depending on which key was pressed, we // call some library functions related to the burner and the valve. switch(key) { case 1: Balloon_set_burner(ON); break; case 2: Balloon_set_burner(OFF); break; case 3: Balloon_set_valve(OPEN); break; case 4: Balloon_set_valve(CLOSED); break; case 5: break; } // ... wait until the key is released again... while(getPressedKeyNumber()) { showSimParams(); // use busy waiting for polling keys } } } }
/** * A small running light that uses Stopwatch 1 for timing. * The running light is updated every 100ms (= refresh frequency of 10Hz) */ void task_LEDs(void) { static uint16_t runningLight = 1; if(getStopwatch1() > 100) // have we reached AT LEAST 100ms = 0.1s? { // Update chaselight: setLEDs(runningLight); runningLight <<= 1; if(runningLight > 32) runningLight = 1; // Don't forget to reset the stopwatch to 0 again: setStopwatch1(0); } }
int main(void) { initRP6M256(); initLCD(); writeString_P_WIFI("\n\nRP6 CONTROL M32 I2C Master Example Program!\n"); writeString_P_WIFI("\nMoving...\n"); // --------------------------------------- WDT_setRequestHandler(watchDogRequest); // --------------------------------------- // Init TWI Interface: I2CTWI_initMaster(100); I2CTWI_setRequestedDataReadyHandler(I2C_requestedDataReady); I2CTWI_setTransmissionErrorHandler(I2C_transmissionError); setLEDs(0b1111); showScreenLCD("################", "################"); mSleep(1000); showScreenLCD("I2C-Master", "Movement..."); mSleep(1000); setLEDs(0b0000); // --------------------------------------- I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_ACS_POWER, ACS_PWR_MED); I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_WDT, true); I2CTWI_transmit3Bytes(I2C_RP6_BASE_ADR, 0, CMD_SET_WDT_RQ, true); while(true) { setLEDs(0b1001); showScreenLCD("MOVE", "FWD"); writeString_P_WIFI("\nMoving Forwards...\n"); move(70, FWD, DIST_MM(300), BLOCKING); setLEDs(0b1000); showScreenLCD("ROTATE", "LEFT"); writeString_P_WIFI("\nRotating Left...\n"); rotate(60, LEFT, 180, BLOCKING); setLEDs(0b1001); showScreenLCD("MOVE", "FWD"); writeString_P_WIFI("\nMoving Forwards...\n"); move(70, FWD, DIST_MM(300), BLOCKING); setLEDs(0b0001); showScreenLCD("ROTATE", "RIGHT"); writeString_P_WIFI("\nRotating Right...\n"); rotate(60, RIGHT, 180, BLOCKING); } return 0; }
void ApplePS2Keyboard::initKeyboard() { // // Reset the keyboard to its default state. // PS2Request * request = _device->allocateRequest(); if (request) { request->commands[0].command = kPS2C_WriteDataPort; request->commands[0].inOrOut = kDP_SetDefaults; request->commands[1].command = kPS2C_ReadDataPortAndCompare; request->commands[1].inOrOut = kSC_Acknowledge; request->commandsCount = 2; _device->submitRequestAndBlock(request); _device->freeRequest(request); } // start out with all keys up bzero(_keyBitVector, sizeof(_keyBitVector)); // // Initialize the keyboard LED state. // setLEDs(_ledState); // // Enable the keyboard clock (should already be so), the keyboard IRQ line, // and the keyboard Kscan -> scan code translation mode. // setCommandByte(kCB_EnableKeyboardIRQ | kCB_TranslateMode, kCB_DisableKeyboardClock); // // Finally, we enable the keyboard itself, so that it may start reporting // key events. // setKeyboardEnable(true); }
/** * Here we react on any obstacle that we may hit. * If any of the bumpers detects an obstacle, we stop the motors and start * LED blink. */ void bumpersStateChanged(void) { if (bumper_left || bumper_right) { stop(); moveAtSpeed(0, 0); // stop moving! setLEDs(0b111111); updateStatusLEDs(); mSleep(500); while (true) { statusLEDs.LED2 = !statusLEDs.LED2; // Toggle LED bit in LED shadow register... statusLEDs.LED5 = !statusLEDs.LED5; updateStatusLEDs(); mSleep(500); task_RP6System(); } } }
/** * Show a running light... */ void runningLight(void) { static uint8_t runLight = 1; static uint8_t dir; if(getStopwatch1() > 100) { setLEDs(runLight); if(dir == 0) runLight <<= 1; else runLight >>= 1; if(runLight > 7 ) dir = 1; else if (runLight < 2 ) dir = 0; setStopwatch1(0); }