int main(void) { CPU_PRESCALE(0); GBA_DDR &= ~(1<<MISO_BIT); GBA_DDR |= (1<<MOSI_BIT) | (1<<CLK_BIT); CLK_HIGH(); usb_init(); while (!usb_configured()); _delay_ms(1000); INIT_TIMER(); while (1) { if (usb_serial_available() >= 4) { uint32_t data = 0; data |= (uint32_t)usb_serial_getchar()<<24; data |= (uint32_t)usb_serial_getchar()<<16; data |= (uint32_t)usb_serial_getchar()<<8; data |= (uint32_t)usb_serial_getchar(); xfer(&data); usb_serial_putchar((data>>24) & 0xff); usb_serial_putchar((data>>16) & 0xff); usb_serial_putchar((data>>8) & 0xff); usb_serial_putchar(data & 0xff); usb_serial_flush_output(); } }
void handle_erase_block() { int8_t res; uint16_t i; int16_t in_data; for (i = 0; i < BUF_SIZE_ADDR; i++) { if ((in_data = usb_serial_getchar()) != -1) buf_addr[i] = in_data; else break; } if (i < BUF_SIZE_ADDR) { // if receiving timeout, send FAIL! usb_serial_putchar('R'); return; } res = spi_erase_block(); if (res > 0) usb_serial_putchar('K'); else if (res < 0) usb_serial_putchar('P'); else usb_serial_putchar('V'); }
// Receive a string from the USB serial port. The string is stored // in the buffer and this function will not exceed the buffer size. // A carriage return or newline completes the string, and is not // stored into the buffer. // The return value is the number of characters received, or 255 if // the virtual serial connection was closed while waiting. // uint8_t recv_str(char *buf, uint8_t size) { int16_t r; uint8_t count=0; while (count < size) { r = usb_serial_getchar(); if (r != -1) { if (r == '\r' || r == '\n') return count; if (r >= ' ' && r <= '~') { *buf++ = r; usb_serial_putchar(r); count++; } } else { if (!usb_configured() || !(usb_serial_get_control() & USB_SERIAL_DTR)) { // user no longer connected return 255; } // just a normal timeout, keep waiting } } return count; }
int8_t hwspi_write_block() { uint8_t i; uint16_t k; int16_t in_data; int8_t ret = 1; if (SPI_USE_3B_CMDS && SPI_ADDRESS_LENGTH == 4) { HWSPI_CS_LOW; SPI_SendByte(SPI_COMMAND_EN4B); HWSPI_CS_HIGH; } HWSPI_WP_HIGH; for (i = 0; i < BUF_SIZE_RW/256; ++i) { // set write enable bit HWSPI_WREN; /* Serial Data Input command */ HWSPI_CS_LOW; if (SPI_USE_3B_CMDS || SPI_ADDRESS_LENGTH == 3) SPI_SendByte(SPI_COMMAND_3B_PAGEPROG); else SPI_SendByte(SPI_COMMAND_4B_PAGEPROG); /* address */ if (SPI_ADDRESS_LENGTH == 4) SPI_SendByte(buf_addr[0]); SPI_SendByte(buf_addr[1]); SPI_SendByte(buf_addr[2] | i); SPI_SendByte(buf_addr[3]); for (k = 0; k < 256; ++k) { if ((in_data = usb_serial_getchar()) != -1) { SPI_SendByte(in_data); } else { ret = -1; break; } } HWSPI_CS_HIGH; // wait for the internal controller to finish the program command SPI_BUSY_WAIT; if (ret == -1) break; if ((maker_code == 0xC2) && (device_code0 == 0x18)) { if (hwspi_security() & SPI_SECURITY_P_FAIL) { ret = 0; } } } HWSPI_WP_LOW; return ret; }
void handle_write_block() { int8_t res; uint16_t i; int16_t in_data; for (i = 0; i < BUF_SIZE_ADDR; i++) { if ((in_data = usb_serial_getchar()) != -1) buf_addr[i] = in_data; else break; } if (i < BUF_SIZE_ADDR) { // timeout usb_serial_putchar('R'); return; // and exit } res = spi_write_block(); if (res > 0) usb_serial_putchar('K'); else if (res < 0) usb_serial_putchar('R'); else usb_serial_putchar('V'); }
int main(void) { configure_teensy(); configure_LEDs(); configure_usb(); int16_t lastcmd = '\0', cmd = '\0'; while (1) { wait_for_usb_connection(); while (1) { cmd = usb_serial_getchar(); if(is_valid_control_key(cmd)) { if(cmd == '+') adjust_speed(-10); // Speed up == less time. else if(cmd == '-') adjust_speed(10); } if( is_valid_cmd(cmd) ) { lastcmd = cmd; } if(lastcmd == 'k') knight_rider(); else if(lastcmd == 's') step(); else if(lastcmd == 'f') follow(); else if(lastcmd == '0') nop(); else demo(); } } }
void enter_breakpoint(unsigned long line_num) { // Display Debug message. send_debug_string("Entered breakpoint @ line #. Press b to continue..."); // Halt the program until the 'b' character is pressed. while (usb_serial_getchar() != 'b') { debug = 0; }; send_debug_string("exited breakpoint..."); }
static int mygetchar(FILE *stream) { int16_t c; (void)stream; // just poll for now, don't care about errors/timeouts while ((c = usb_serial_getchar()) == -1) ; return c; }
// USB Get Character from input buffer inline int Output_getchar() { #if enableVirtualSerialPort_define == 1 // XXX Make sure to check output_availablechar() first! Information is lost with the cast (error codes) (AVR) return (int)usb_serial_getchar(); #else return 0; #endif }
// Very simple character echo test int main(void) { CPU_PRESCALE(0); usb_init(); while (1) { int n = usb_serial_getchar(); if (n >= 0) usb_serial_putchar(n); } }
int8_t spi_write_block() { return hwspi_write_block(); uint16_t i; uint16_t k; int16_t in_data; int8_t ret = 1; //spi_enable(); for (i = 0; i < SPI_BLOCK_SIZE/64; ++i) { // set write enable bit SPI_CS_LOW; SPI_COMMAND(SPI_COMMAND_WREN); SPI_CS_HIGH; /* Serial Data Input command */ SPI_CS_LOW; SPI_COMMAND(SPI_COMMAND_4B_PAGEPROG); /* address */ //buf_addr[2] = i; SPI_IO_SET(buf_addr[0]); SPI_IO_SET(buf_addr[1]); SPI_IO_SET(i); SPI_IO_SET(buf_addr[3]); for (k = 0; k < 256; ++k) { if ((in_data = usb_serial_getchar()) != -1) { SPI_IO_SET(in_data); } else { break; } } SPI_CS_HIGH; /* wait for the internal controller to finish the program command TBD - up to 200us */ SPI_BUSY_WAIT; if (spi_security() & SPI_SECURITY_P_FAIL) { ret = 0; } } /* Page Program confirm command */ //SPI_COMMAND(SPI_COMMAND_PAGEPROG2); if (i < SPI_BLOCK_SIZE/64) { // timeout return -1; // and exit } return ret; //!(spi_security() & SPI_SECURITY_P_FAIL); }
int getkey() { while (!kbhit()) ; // return the next character from the console input device // return usb_serial_getchar(); if(USB_SERIAL_ON && (usb_serial_available() != 0)) { return usb_serial_getchar(); } #ifdef USE_UART return serial_getchar(); #endif return 0; }
/* * UART receive char routine MUST return exactly and only the received char; * it should not translate \n to \r\n. * This is because the interactive interface uses binary transfers. */ PmReturn_t plat_getByte(uint8_t *b) { PmReturn_t retval = PM_RET_OK; int c = usb_serial_getchar(); if(c == -1) { PM_RAISE(retval, PM_RET_EX_IO); return retval; } *b = c; return retval; }
void handle_read_block() { uint16_t i; int16_t in_data; for (i = 0; i < BUF_SIZE_ADDR; i++) { if ((in_data = usb_serial_getchar()) != -1) buf_addr[i] = in_data; else break; } if (i < BUF_SIZE_ADDR) { // timeout usb_serial_putchar('R'); return; // and exit } usb_serial_putchar('K'); spi_read_block(); }
uint8_t serial_read_line(char* buf, uint8_t max_len) { int ret; uint8_t num_chars = 0; //char out_buffer[32]; while(num_chars < max_len) { ret = usb_serial_getchar(); if(ret == -1) { //strcpy(out_buffer,"getchar returns -1\r\n"); //usb_serial_write(out_buffer, strlen(out_buffer)); //yield(); } else { if(ret == '\r' || ret == '\n') { // We've read the whole line so return //strcpy(out_buffer, "found EOL, returning\r\n"); //usb_serial_write(out_buffer,strlen(out_buffer)); return num_chars; } else { //strcpy(out_buffer, "Got character: "); //usb_serial_write(out_buffer,strlen(out_buffer)); //usb_serial_putchar(ret); //usb_serial_putchar('\r'); //usb_serial_putchar('\n'); buf[num_chars] = ret; num_chars++; } } } return num_chars; }
/** * Main - Run through the steps of configuring, greeting, getting a name, thanking, * and then quitting */ int main(void) { char buff[BUFF_LENGTH]; // Setup the hardware init_hardware(); // Wait until the USB port is configured and ready to go draw_centred(17, "Waiting for"); draw_centred(24, "computer..."); show_screen(); while (!usb_configured() || !usb_serial_get_control()); // Prompt the user for their name, and wait until they enter it clear_screen(); draw_centred(17, "Waiting for"); draw_centred(24, "username..."); show_screen(); send_line("Hello!"); send_line("Could you please tell me your name:"); recv_line(buff, BUFF_LENGTH); usb_serial_putchar('\n'); // Display their name on the Teensy and prompt them to exit char buff2[BUFF_LENGTH + 8]; sprintf(buff2, "Thanks %s!", buff); clear_screen(); draw_centred(21, buff2); show_screen(); send_line("Press 'q' to exit..."); while (usb_serial_getchar() != 'q'); // Display the finished information clear_screen(); draw_centred(21, "Goodbye!"); show_screen(); send_line("\r"); send_line("Done! Goodbye!"); while (1); // We'll never get here... return 0; }
void recv_line(char* buff, unsigned char max_length) { // Loop over storing characters until the buffer is full or a newline character is received unsigned char char_count = 0; int16_t curr_char; do { // BLOCK here until a character is received do { curr_char = usb_serial_getchar(); } while (curr_char == -1); // Add to the buffer if it wasn't a newline (accepts other gibberish that may not necessarily be a character!) if (curr_char != '\n' && curr_char != '\r') { buff[char_count] = curr_char; char_count++; } } while (curr_char != '\n' && curr_char != '\r' && char_count < max_length - 1); // Add the null terminator to the end of the string buff[char_count] = '\0'; }
int16_t VncServerGetData(uint8_t * buffer, uint16_t maxsize) { uint16_t size = 0; if(lastControlState != usb_serial_get_control()) { lastControlState = usb_serial_get_control(); if(usb_serial_get_control() & USB_SERIAL_DTR) usb_serial_set_control(USB_SERIAL_DSR); else usb_serial_set_control(0); // return error if a disconnect from the VNC server is detected if(lastControlState == 0) return -1; } while(debugcounter > 64) { DDRF |= (1 << 0); PORTF |= (1 << 0); debugcounter -= 64; PORTF &= ~(1 << 0); } while ( size < maxsize ) { int n = usb_serial_getchar(); if(n < 0) break; buffer[size++] = (uint8_t)n; debugcounter++; } return size; }
uint16_t usb_serial_readline(char *buffer, const uint16_t buffer_size, const bool obscure_input) { uint16_t end = 0; char c; while(true) { if(usb_serial_available() > 0) { c = (char)usb_serial_getchar(); switch((char) c) { case '\r': // enter buffer[end] = 0; usb_serial_putchar('\n'); usb_serial_putchar('\r'); return end; break; case '\b': // ^H case 127: // backspace end--; usb_serial_write("\b \b"); // remove the last char from the display //usb_serial_readline_refresh(buffer, end, obscure_input); break; default: if(end < buffer_size-1) { buffer[end++] = c; if(obscure_input) usb_serial_putchar('*'); else usb_serial_putchar(c); } break; } } usb_tasks(); service_button(); _delay_ms(10); } return 0; // never reached }
static int uart_getc(FILE *stream) { int c = usb_serial_getchar(); return (c == -1) ? _FDEV_ERR : c; }
int main(void) { char cmd; char param1; char param2; char param3; cmd = 0; param1 = 0; param2 = 0; param3 = 0; DDRB = 0x00; PORTB |= 0x01; // set for 16 MHz clock, and make sure the LED is off CPU_PRESCALE(0); LED_CONFIG; LED_ON; SPI_SlaveInit(); ACK_CONFIG; ACK_HIGH; TEST_CONFIG; usb_init(); _delay_ms(1000); usb_serial_flush_input(); int flashCounter = 0; char LEDstate = 1; while (1) { idle: TEST_HIGH; ACK_HIGH; SPDR = 0xff; if(ATT_PIN) { timeoutCounter++; if(timeoutCounter >= 30000)//we've been disconnected { mode = 0x41; motorSetting1 = 0xff; motorSetting2 = 0xff; analogEnabled = 0; configMode = 0; timeoutCounter = 0; flashCounter++; if(flashCounter > 5) { if(LEDstate == 1) { LED_OFF; LEDstate = 0; } else { LED_ON; LEDstate = 1; } flashCounter = 0; } } if(usb_serial_available()) { LED_ON; int c = usb_serial_getchar(); if (c >= 0) { switch(parseIndex) { case 0: if(c == 0x5A) parseIndex++; else usb_serial_putchar('x'); break; case 1: buttons1 &= c;//combine this with any pending presses buttons1postReportState = c; parseIndex++; break; case 2: buttons2 &= c;//combine this with any pending presses buttons2postReportState = c; parseIndex++; break; case 3: joyRX = c; parseIndex++; break; case 4: joyRY = c; parseIndex++; break; case 5: joyLX = c; parseIndex++; break; case 6: joyLY = c; parseIndex = 0; recievedUpdate = 1; break; } } else { parseIndex = 0; usb_serial_putchar('x'); } } _delay_us(1); goto idle; } timeoutCounter = 0; if((buttons1 & 0x10) == 0) upPressure = 0xFF; else upPressure = 0x00; if((buttons1 & 0x20) == 0) rightPressure = 0xFF; else rightPressure = 0x00; if((buttons1 & 0x40) == 0) downPressure = 0xFF; else downPressure = 0x00; if((buttons1 & 0x80) == 0) leftPressure = 0xFF; else leftPressure = 0x00; if((buttons2 & 0x01) == 0) L2Pressure = 0xFF; else L2Pressure = 0x00; if((buttons2 & 0x02) == 0) R2Pressure = 0xFF; else R2Pressure = 0x00; if((buttons2 & 0x04) == 0) L1Pressure = 0xFF; else L1Pressure = 0x00; if((buttons2 & 0x08) == 0) R1Pressure = 0xFF; else R1Pressure = 0x00; if((buttons2 & 0x10) == 0) trianglePressure = 0xFF; else trianglePressure = 0x00; if((buttons2 & 0x20) == 0) circlePressure = 0xFF; else circlePressure = 0x00; if((buttons2 & 0x40) == 0) crossPressure = 0xFF; else crossPressure = 0x00; if((buttons2 & 0x80) == 0) squarePressure = 0xFF; else squarePressure = 0x00; cli();//disable usb interrupts LED_ON; TEST_LOW; cmd = SPI_SlaveReceive(0xff,1); TEST_HIGH; if(cmd != 0x01) goto finish; if(configMode) { cmd = SPI_SlaveReceive(0xF3,1); SPI_SlaveReceive(0x5A,1); switch(cmd) { case 0x40: param1 = SPI_SlaveReceive(0x00,1); // if(param1 == 0) //lots on param1 but the reponses are all the same? { SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x02,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x5A,0); } break; case 0x41://check response data if(analogEnabled==1) { //button pressures byte mask, appears after 0x44 is called SPI_SlaveReceive(0xFF,1);//use mask instead? SPI_SlaveReceive(0xFF,1); SPI_SlaveReceive(0x03,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x5A,0); } else { SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,0); } break; case 0x43://exit config mode param1 = SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,0); if(param1 == 0) { configMode = 0; } break; case 0x44://turn on analog mode param1 = SPI_SlaveReceive(0x00,1); param2 = SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,0); if(param1 == 1) { mode = 0x73;//no analog button pressures analogEnabled = 1; } else { mode = 0x41; analogEnabled = 0; } break; case 0x45://query model param1 = SPI_SlaveReceive(0x03,1); param2 = SPI_SlaveReceive(0x02,1); if(analogEnabled==1) SPI_SlaveReceive(0x01,1); else SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x02,1); SPI_SlaveReceive(0x01,1); SPI_SlaveReceive(0x00,0); break; case 0x46: param1 = SPI_SlaveReceive(0x00,1); if(param1 == 0) { param2 = SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x01,1); SPI_SlaveReceive(0x02,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x0F,0); } if(param1 == 1) { param2 = SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x01,1); SPI_SlaveReceive(0x01,1); SPI_SlaveReceive(0x01,1); SPI_SlaveReceive(0x0F,0); } break; case 0x47: SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x02,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x01,1); SPI_SlaveReceive(0x00,0); break; case 0x4C: param1 = SPI_SlaveReceive(0x00,1); if(param1 == 0) { SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x04,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,0); } if(param1 == 1) { SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x07,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,0); } break; case 0x4D://setup motors motorSetting1 = SPI_SlaveReceive(motorSetting1,1); motorSetting2 = SPI_SlaveReceive(motorSetting2,1); SPI_SlaveReceive(0xFF,1); SPI_SlaveReceive(0xFF,1); SPI_SlaveReceive(0xFF,1); SPI_SlaveReceive(0xFF,0); break; case 0x4F://set pressure byte mask, extended pressures mode = 0x79;//analog button pressures param1 = SPI_SlaveReceive(0x00,1); param2 = SPI_SlaveReceive(0x00,1); param3 = SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x00,1); SPI_SlaveReceive(0x5A,0); break; } } else { TEST_LOW; cmd = SPI_SlaveReceive(mode,1); SPI_SlaveReceive(0x5A,1); if(mode == 0x41)//digital only { param1 = SPI_SlaveReceive(buttons1,1); param2 = SPI_SlaveReceive(buttons2,0); } if(mode == 0x73)//digital buttons, analog joysticks { param1 = SPI_SlaveReceive(buttons1,1); if(param1 ==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(buttons2,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyRX,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyRY,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyLX,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyLY,0)==TIME_OUT_ERROR_CODE) goto finish; } if(mode == 0x79)//analog joysticks, analog buttons { param1 = SPI_SlaveReceive(buttons1,1); if(param1 ==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(buttons2,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyRX,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyRY,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyLX,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(joyLY,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(rightPressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(leftPressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(upPressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(downPressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(trianglePressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(circlePressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(crossPressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(squarePressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(L1Pressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(R1Pressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(L2Pressure,1)==TIME_OUT_ERROR_CODE) goto finish; if(SPI_SlaveReceive(R2Pressure,0)==TIME_OUT_ERROR_CODE) goto finish; } //cmd should usually be 0x42 for polling if(cmd == 0x43) { if(param1 == 0x01) configMode = 1; } } finish: TEST_HIGH; ACK_HIGH; if((buttons1 == 0xff)&&(buttons2 == 0xff)) { LED_OFF; } //copy queued releases into button state buttons1 = buttons1postReportState; buttons2 = buttons2postReportState; sei();//renable usb interrupts if(recievedUpdate == 1) { //ack the update was sent to the console usb_serial_putchar('k'); recievedUpdate = 0; } while(!ATT_PIN) { _delay_us(20); //conservative so we aren't still in ATT low at the top of the loop } counter++; } }
int main(void) { int16_t command = -1; uint16_t freemem; // set for 8 MHz clock because of 3.3v regulator CPU_PRESCALE(1); // set for 16 MHz clock //CPU_PRESCALE(0); //disable JTAG MCUCR = (1<<JTD) | (1<<IVCE) | (0<<PUD); MCUCR = (1<<JTD) | (0<<IVSEL) | (0<<IVCE) | (0<<PUD); // set all i/o lines to input releaseports(); //Init SPI SPI_Init(SPI_SPEED_FCPU_DIV_2 | SPI_ORDER_MSB_FIRST | SPI_SCK_LEAD_RISING | SPI_SAMPLE_LEADING | SPI_MODE_MASTER); hwspi_init(); // Initialize the USB, and then wait for the host to set configuration. // If the Teensy is powered without a PC connected to the USB port, // this will wait forever. usb_init(); while (!usb_configured()) /* wait */ ; // Wait an extra second for the PC's operating system to load drivers // and do whatever it does to actually be ready for input _delay_ms(1000); while (1) { // discard anything that was received prior. Sometimes the // operating system or other software will send a modem // "AT command", which can still be buffered. usb_serial_flush_input(); while (usb_configured()) { // is user still connected? command = usb_serial_getchar(); if (command == -1) continue; switch (command) { case CMD_PING1: usb_serial_putchar(VERSION_MAJOR); break; case CMD_PING2: freemem = freeRam(); usb_serial_putchar(VERSION_MINOR); usb_serial_putchar((freemem >> 8) & 0xFF); usb_serial_putchar(freemem & 0xFF); break; case CMD_BOOTLOADER: bootloader(); break; case CMD_IO_LOCK: break; case CMD_IO_RELEASE: break; case CMD_PULLUPS_DISABLE: IO_PULLUPS = 0; break; case CMD_PULLUPS_ENABLE: IO_PULLUPS = 0xFF; break; case CMD_SPI_ID: handle_read_id(); break; case CMD_SPI_READBLOCK: handle_read_block(); break; case CMD_SPI_WRITESECTOR: handle_write_block(); break; case CMD_SPI_ERASEBLOCK: handle_erase_block(); break; case CMD_SPI_ERASECHIP: handle_erase_chip(); break; case CMD_SPI_3BYTE_ADDRESS: SPI_ADDRESS_LENGTH = 3; break; case CMD_SPI_4BYTE_ADDRESS: SPI_ADDRESS_LENGTH = 4; break; case CMD_SPI_3BYTE_CMDS: SPI_USE_3B_CMDS = 1; break; case CMD_SPI_4BYTE_CMDS: SPI_USE_3B_CMDS = 0; break; default: break; } } } }
//void parse_CIM_protocol(unsigned char actbyte) void parse_CIM_protocol(void) { uint32_t checksum=0; static uint8_t transmission_mode; static uint8_t reply_status_code; static uint8_t last_serial; uint8_t actbyte; while (usb_serial_available()) { //PORTD |= (1<<6); actbyte=usb_serial_getchar(); switch (readstate) { case 0: // first sync byte reply_status_code=0; if (actbyte=='@') readstate++; break; case 1: // second sync byte if (actbyte=='T') readstate++; else readstate=0; break; // packet in sync ! case 2: // ARE-ID: SW-version low byte ARE_frame.are_id=actbyte; readstate++; break; case 3: // ARE-ID: SW-version high byte ARE_frame.are_id+=((uint16_t)actbyte)<<8; if (ARE_frame.are_id < ARE_MINIMAL_VERSION) // outdated ARE ? reply_status_code |= CIM_ERROR_INVALID_ARE_VERSION; readstate++; break; case 4: // data length low byte ARE_frame.data_size=actbyte; readstate++; break; case 5: // data length high byte ARE_frame.data_size+=((uint16_t)actbyte)<<8; if (ARE_frame.data_size > DATABUF_SIZE) { // dismiss packets of excessive length readstate=0; //ARE_frame.data_size=0; //reply_status_code |= CIM_ERROR_INVALID_FEATURE; } else readstate++; break; case 6: // serial_number ARE_frame.serial_number = actbyte; if (first_packet) // don't check first serial first_packet=0; else if (actbyte != (last_serial+1)%0x80) // check current serial number reply_status_code |= CIM_ERROR_LOST_PACKETS; last_serial=actbyte; readstate++; break; case 7: // CIM-feature low byte ARE_frame.cim_feature= actbyte; readstate++; break; case 8: // CIM-feature high byte ARE_frame.cim_feature+=((int)actbyte)<<8; readstate++; break; case 9: // Request code low byte ( command ) ARE_frame.request_code=actbyte; readstate++; break; case 10:// Request code high byte (transmission mode) transmission_mode=actbyte; // bit 0: CRC enable // reply_status_code|=(actbyte & CIM_STATUS_CRC); // remember CRC state for reply if (ARE_frame.data_size>0) { readstate++; datapos=0; } else { // no data in packet if (transmission_mode & CIM_STATUS_CRC) readstate+=2; // proceed with CRC else readstate=FRAME_DONE; // frame is finished here ! } break; case 11: // read out data ARE_frame.data[datapos]=actbyte; datapos++; if (datapos==ARE_frame.data_size) { if (transmission_mode & CIM_STATUS_CRC) // with CRC: get checksum readstate++; else readstate=FRAME_DONE; // no CRC: frame is finished here ! } break; case 12: // checksum byte 1 checksum=actbyte; readstate++; break; case 13: // checksum byte 2 checksum+=((long)actbyte)<<8; readstate++; break; case 14: // checksum byte 3 checksum+=((long)actbyte)<<16; readstate++; break; case 15: // checksum byte 4 checksum+=((long)actbyte)<<24; // check CRC now (currently not used): // if (checksum != crc32(ARE_frame.data, ARE_frame.data_size)) reply_status_code |= CIM_ERROR_CRC_MISMATCH; // frame finished here ! readstate=FRAME_DONE; break; default: readstate=0; break; } if (readstate==FRAME_DONE) { // frame finished: store command in ringbuffer process_ARE_frame(reply_status_code); readstate=0; } } }
/*! \fn main(void) * \brief Main function */ int main(void) { RET_TYPE flash_init_result = RETURN_NOK; RET_TYPE card_detect_ret; RET_TYPE temp_rettype; uint8_t temp_buffer[200]; char temp_string[20]; CPU_PRESCALE(0); // Set for 16MHz clock _delay_ms(500); // Let the power settle initPortSMC(); // Init smart card Port initIRQ(); // Init interrupts usb_init(); // Init USB controller while(!usb_configured()); // Wait for host to set configuration initOLED(); // Init OLED screen after enum flash_init_result = initFlash(); // Init flash memory //#define TEST_HID_AND_CDC #ifdef TEST_HID_AND_CDC //Show_String("Z",FALSE,2,0); //usb_keyboard_press(KEY_S, 0); while(1) { int n = usb_serial_getchar(); if (n >= 0) { usb_serial_putchar(n); Show_String((char*)&n,FALSE,2,0); //usb_keyboard_press(n,0); } } #endif /* TEST_HID_AND_CDC */ //lcd_display_grayscale(); if(flash_init_result == RETURN_OK) Show_String("Flash init ok", FALSE, 2, 0); else Show_String("Problem flash init", FALSE, 2, 250); //display_picture(HACKADAY_BMP, 20, 0); //draw_screen_frame(); //Show_String("Mooltipass", FALSE, 32, 10); Show_String("No card detected", FALSE, 25, 45); //If no card is inserted at boot time while(1) { card_detect_ret = isCardPlugged(); if(card_detect_ret == RETURN_JDETECT) // Card just detected { temp_rettype = cardDetectedRoutine(); if(temp_rettype == RETURN_MOOLTIPASS_INVALID) // Invalid card { _delay_ms(3000); printSMCDebugInfoToScreen(); removeFunctionSMC(); // Shut down card reader } else if(temp_rettype == RETURN_MOOLTIPASS_PB) // Problem with card { _delay_ms(3000); printSMCDebugInfoToScreen(); removeFunctionSMC(); // Shut down card reader } else if(temp_rettype == RETURN_MOOLTIPASS_BLOCKED) // Card blocked { _delay_ms(3000); printSMCDebugInfoToScreen(); removeFunctionSMC(); // Shut down card reader } else if(temp_rettype == RETURN_MOOLTIPASS_BLANK) // Blank mooltipass card { // Here we should ask the user to setup his mooltipass card _delay_ms(3000); printSMCDebugInfoToScreen(); removeFunctionSMC(); // Shut down card reader } else if(temp_rettype == RETURN_MOOLTIPASS_USER) // Configured mooltipass card { // Here we should ask the user for his pin and call mooltipassdetect _delay_ms(3000); printSMCDebugInfoToScreen(); removeFunctionSMC(); // Shut down card reader } /*read_credential_block_within_flash_page(2,1,temp_buffer); for(i = 0; i < 10; i++) { hexachar_to_string(temp_buffer[i], temp_string); Show_String(temp_string, FALSE, 2+i*5, 0); } temp_buffer[3] = 0x0A; write_credential_block_within_flash_page(2,1, temp_buffer); read_credential_block_within_flash_page(2,1,temp_buffer); for(i = 0; i < 10; i++) { hexachar_to_string(temp_buffer[i], temp_string); Show_String(temp_string, FALSE, 2+i*5, 8); }*/ } else if(card_detect_ret == RETURN_JRELEASED) //card just released { removeFunctionSMC(); clear_screen(); Show_String("Please insert card", FALSE, 2, 8); } } }
/*! \fn afterFlashInitTests(void) * \brief Test functions launched after flash init */ void afterFlashInitTests(void) { //#define TEST_NODE #ifdef TEST_NODE nodeTest(); // spin while(1); #endif //#define TEST_HID_AND_CDC #ifdef TEST_HID_AND_CDC //Show_String("Z",FALSE,2,0); //usbKeyboardPress(KEY_S, 0); while(1) { int n = usb_serial_getchar(); if (n >= 0) { usb_serial_putchar(n); oledSetXY(2,0); oledPutch((char)n); //usbKeyboardPress(n,0); } } #endif /* TEST_HID_AND_CDC */ //#define NESSIE_TEST_VECTORS #ifdef NESSIE_TEST_VECTORS while(1) { // msg into oled display oledSetXY(2,0); printf_P(PSTR("send s to start nessie test")); int input0 = usb_serial_getchar(); nessieOutput = &usb_serial_putchar; // do nessie test after sending s or S chars if (input0 == 's' || input0 == 'S') { nessieTest(1); nessieTest(2); nessieTest(3); nessieTest(4); nessieTest(5); nessieTest(6); nessieTest(7); nessieTest(8); } } #endif //#define CTR_TEST_VECTORS #ifdef CTR_TEST_VECTORS while(1) { // msg into oled display oledSetXY(2,0); printf_P(PSTR("send s to start CTR test")); int input1 = usb_serial_getchar(); ctrTestOutput = &usb_serial_putchar; // do ctr test after sending s or S chars if (input1 == 's' || input1 == 'S') { aes256CtrTest(); } } #endif //#define TEST_CTR_SPEED #ifdef TEST_CTR_SPEED // msg into oled display oledSetXY(2,0); usbPrintf_P(PSTR("CTR speed TEST with 1000 encryptions\n")); usbPrintf_P(PSTR("Time:")); usbPrintf_P(PSTR("%lu ms"), aes256CtrSpeedTest()); while(1); #endif //#define TEST_RNG #ifdef TEST_RNG while(1) { // init avrentropy library EntropyInit(); // msg into oled display oledSetXY(2,0); printf_P(PSTR("send s to start entropy")); int input2 = usb_serial_getchar(); uint32_t randomNumCtr; // do nessie test after sending s or S chars if (input2 == 's' || input2 == 'S') { while(EntropyAvailable() < 2); EntropyRandom8(); usb_serial_putchar(EntropyBytesAvailable()); for(randomNumCtr=0; randomNumCtr<25; randomNumCtr++) { usb_serial_putchar(EntropyRandom8()); } } } #endif }
/** The MAIN loop. */ int main(void) { // Turn off the CPU prescale. CLKPR = 0x80; CLKPR = 0x00; // PORTA are general purpose inputs. DDRA = 0x00; PORTA = 0xff; // pull-ups all enabled PORTD = 0xff; DDRD = 0x00; // pull-ups all enabled DDRF = 0x00; // These are ADC lines. PORTF = 0x00; usb_init(); // Set up Timer 0 to match compare every 1ms. OCR0A = 250; TCCR0A = 0x02; // CTC TCCR0B = 0x03; // CK/64 (64 * 250 == 16000) sei(); char line_buf[128] = {}; uint8_t line_len = 0; uint8_t usb_ready = 0; while (1) { wdt_reset(); g_main_loop_count++; if (usb_configured() && (usb_serial_get_control() & USB_SERIAL_DTR)) { if (!usb_ready) { usb_ready = 1; strcpy_P(line_buf, PSTR("!GNR WELCOME " DEV_VERSION EOL)); usb_serial_write((uint8_t*)line_buf, strlen(line_buf)); line_len = 0; } } else { stream_stop_all(); usb_serial_flush_input(); usb_ready = 0; line_len = 0; g_arm_code = 0; } if (usb_serial_available()) { int16_t c = usb_serial_getchar(); if (c == '\r' || c == '\n') { line_buf[line_len] = 0; handle_line(line_buf); if (g_arm_code) { g_arm_timer = ARM_TIMEOUT_MS; } line_len = 0; } else { line_buf[line_len++] = c & 0xff; if ((line_len + 1) >= sizeof(line_buf)) { /* Clobber the first byte so that this line will be reported as an error. */ line_buf[0] = MAGIC_OVERRUN_CODE; line_len--; } } } if (TIFR0 & (1 << OCF0A)) { TIFR0 |= (1 << OCF0A); g_timer++; stream_timer_update(); hit_timer_update(); g_main_loop_count = (uint16_t) (((uint32_t) g_main_loop_count) * 7 / 8); } stream_poll(); usb_poll(); hit_poll(); } }
// USB Get Character from input buffer inline int Output_getchar() { // XXX Make sure to check output_availablechar() first! Information is lost with the cast (error codes) (AVR) return (int)usb_serial_getchar(); }
/** * Main - Run the game which repeatedly loops through trying to find the gold */ int main() { // Setup the hardware set_clock_speed(CPU_8MHz); init_hardware(); // Wait until the 'player' is attached... draw_centred(17, "Waiting for"); draw_centred(24, "the player..."); show_screen(); while(!usb_configured() || !usb_serial_get_control()); // Run the main game loop unsigned int seed = 0; while (1) { // Game start screen clear_screen(); draw_centred(16, "--- LUCKY DIP ---"); draw_centred(25, "'s' to start..."); show_screen(); send_line("--- LUCKY DIP ---"); send_line("Press 's' to start..."); // Wait until the key has been pressed (perform seeding only if first run) unsigned int seed_temp = 0; int16_t curr_char; do { curr_char = usb_serial_getchar(); seed_temp++; } while (curr_char != 's'); if (seed == 0) { seed = seed_temp; srand(seed); } usb_serial_write("\r\n", 2); // Set the gold location bury_gold(); // Present the 9 closed boxes clear_screen(); for (unsigned char i = 0; i<BOXES_W*BOXES_H; i++) { draw_box(i, 0); } show_screen(); // Prompt the user to pick a box by pressing a number key until they find the gold send_line("Please enter a number between 1 and 9 to select a box..."); int dinner = 0; while (!dinner) { // Get the users input. int16_t input = usb_serial_getchar(); // Convert the input to an intager to be used as an id. int box = (input == '1') ? 0 : (input == '2') ? 1 : (input == '3') ? 2 : (input == '4') ? 3 : (input == '5') ? 4 : (input == '6') ? 5 : (input == '7') ? 6 : (input == '8') ? 7 : (input == '9') ? 8 : -1; if (box != -1) { // Debugging - Display selected box (once it's converted to an id from the users input). char buff[20]; sprintf(buff, "User has selected box #%d", box); (debug) ? send_debug_string(buff) : 0; // Is the selected box open? I should probably open it is it's not... if (is_open[box] == 1) { send_line(" - That box is already open!"); } else { is_open[box] = 1; draw_box(box, 1); } // Did that box contain gold!? if (is_gold[box] == 1) { show_screen(); dinner = 1; } } show_screen(); } // Winner, winner, chicken dinner send_line("You found the $$$!"); for (unsigned char i = 0; i<10; i++) { PORTB ^= (1 << PB2); PORTB ^= (1 << PB3); _delay_ms(250); } } // We'll never get here... return 0; }