void NodeInstanceClientProxy::informationChanged(const InformationChangedCommand &command) { writeCommand(QVariant::fromValue(command)); }
void PICadillo35t::displayOn() { writeCommand(HX8357_DISPLAYON); }
//============================================================== // Initialise HX8357 LCD Driver IC //============================================================== void PICadillo35t::initializeDevice() { PMCONbits.ON = 0; asm volatile("nop"); PMCONbits.PTWREN = 1; PMCONbits.PTRDEN = 1; PMCONbits.CSF = 0; PMAEN = 0x0001; // Enable PMA0 pin for RS pin and CS1 as CS PMMODEbits.MODE16 = 1; PMMODEbits.MODE = 0b10; PMMODEbits.WAITB = 0; PMMODEbits.WAITM = 0; PMMODEbits.WAITE = 0; //PMADDR = 0; // Set current address to 0 PMADDR = 0x0000; // Set current address to 0, CS1 Active PMCONbits.ON = 1; _width = PICadillo35t::Width; _height = PICadillo35t::Height; colstart = 0; //NEED TO CONFIRM rowstart = 0; //NEED TO CONFIRM writeCommand(HX8357_EXIT_SLEEP_MODE); //Sleep Out delay(150); writeCommand(HX8357_ENABLE_EXTENSION_COMMAND); writeData(0xFF); writeData(0x83); writeData(0x57); delay(1); writeCommand(HX8357_SET_POWER_CONTROL); writeData(0x00); writeData(0x12); writeData(0x12); writeData(0x12); writeData(0xC3); writeData(0x44); delay(1); writeCommand(HX8357_SET_DISPLAY_MODE); writeData(0x02); writeData(0x40); writeData(0x00); writeData(0x2A); writeData(0x2A); writeData(0x20); writeData(0x91); delay(1); writeCommand(HX8357_SET_VCOM_VOLTAGE); writeData(0x38); delay(1); writeCommand(HX8357_SET_INTERNAL_OSCILLATOR); writeData(0x68); writeCommand(0xE3); //Unknown Command writeData(0x2F); writeData(0x1F); writeCommand(0xB5); //Set BGP writeData(0x01); writeData(0x01); writeData(0x67); writeCommand(HX8357_SET_PANEL_DRIVING); writeData(0x70); writeData(0x70); writeData(0x01); writeData(0x3C); writeData(0xC8); writeData(0x08); delay(1); writeCommand(0xC2); // Set Gate EQ writeData(0x00); writeData(0x08); writeData(0x04); delay(1); writeCommand(HX8357_SET_PANEL_CHARACTERISTIC); writeData(0x09); delay(1); writeCommand(HX8357_SET_GAMMA_CURVE); writeData(0x01); writeData(0x02); writeData(0x03); writeData(0x05); writeData(0x0E); writeData(0x22); writeData(0x32); writeData(0x3B); writeData(0x5C); writeData(0x54); writeData(0x4C); writeData(0x41); writeData(0x3D); writeData(0x37); writeData(0x31); writeData(0x21); writeData(0x01); writeData(0x02); writeData(0x03); writeData(0x05); writeData(0x0E); writeData(0x22); writeData(0x32); writeData(0x3B); writeData(0x5C); writeData(0x54); writeData(0x4C); writeData(0x41); writeData(0x3D); writeData(0x37); writeData(0x31); writeData(0x21); writeData(0x00); writeData(0x01); delay(1); writeCommand(HX8357_SET_PIXEL_FORMAT); //COLMOD RGB888 writeData(0x55); writeCommand(HX8357_SET_ADDRESS_MODE); writeData(0x00); writeCommand(HX8357_SET_TEAR_ON); //TE ON writeData(0x00); delay(10); writeCommand(HX8357_SET_DISPLAY_ON); //Display On delay(10); writeCommand(HX8357_WRITE_MEMORY_START); //Write SRAM Data _cacheState = cacheInvalid; clearClipping(); }
int TextLCD::_getc() { int a = address(_column, _row); writeCommand(a); return (readData()); }
bool Bluetooth_HC05::probe(unsigned long timeout) { startOperation(timeout); writeCommand(0); return readOperationResult(); }
void ESP8266wifi::disconnectFromServer(){ flags.connectedToServer = false; flags.serverConfigured = false;//disable reconnect writeCommand(CIPCLOSE); readCommand(2000, OK); //fire and forget in this case.. }
void TextLCD::character(int column, int row, int c) { int a = address(column, row); writeCommand(a); writeData(c); }
void NodeInstanceClientProxy::debugOutput(const DebugOutputCommand &command) { writeCommand(QVariant::fromValue(command)); }
void NodeInstanceClientProxy::puppetAlive(const PuppetAliveCommand &command) { writeCommand(QVariant::fromValue(command)); }
void NodeInstanceClientProxy::componentCompleted(const ComponentCompletedCommand &command) { writeCommand(QVariant::fromValue(command)); }
void NodeInstanceClientProxy::token(const TokenCommand &command) { writeCommand(QVariant::fromValue(command)); }
void NodeInstanceClientProxy::statePreviewImagesChanged(const StatePreviewImageChangedCommand &command) { writeCommand(QVariant::fromValue(command)); }
void NodeInstanceClientProxy::childrenChanged(const ChildrenChangedCommand &command) { writeCommand(QVariant::fromValue(command)); }
void NodeInstanceClientProxy::pixmapChanged(const PixmapChangedCommand &command) { writeCommand(QVariant::fromValue(command)); }
/** * @brief Setzt den Display Curser an die erste Spalte, erste Zeile * */ void setCursorToHome() { writeCommand(0x02); _delay_ms(2); }
int HMC5883L::SetMeasurementMode(uint8_t mode) { writeCommand(ModeRegister, mode); return 0; }
bool ESP8266wifi::isConnectedToAP(){ writeCommand(CIFSR, EOL); byte code = readCommand(350, NO_IP, ERROR); readCommand(10, OK); //cleanup return (code == 0); }
/** The actual implemenation code for @a createServiceFile. */ bool createServiceFileCore(char **ppachTemplate, struct SERVICEPARAMETERS *pParameters) { /* The size of the template data we have read. */ size_t cchTemplate = 0; /* The size of the buffer we have allocated. */ size_t cbBuffer = 0; /* How much of the template data we have written out. */ size_t cchWritten = 0; int rc = VINF_SUCCESS; /* First of all read in the file. */ while (rc != VINF_EOF) { size_t cchRead; if (cchTemplate == cbBuffer) { cbBuffer += READ_SIZE; *ppachTemplate = (char *)RTMemRealloc((void *)*ppachTemplate, cbBuffer); } if (!*ppachTemplate) { RTStrmPrintf(g_pStdErr, "Out of memory.\n"); return false; } rc = RTStrmReadEx(g_pStdIn, *ppachTemplate + cchTemplate, cbBuffer - cchTemplate, &cchRead); if (RT_FAILURE(rc)) { RTStrmPrintf(g_pStdErr, "Error reading input: %Rrc\n", rc); return false; } if (!cchRead) rc = VINF_EOF; cchTemplate += cchRead; } while (true) { /* Find the next '%' character if any and write out up to there (or the * end if there is no '%'). */ char *pchNext = (char *) memchr((void *)(*ppachTemplate + cchWritten), '%', cchTemplate - cchWritten); size_t cchToWrite = pchNext ? pchNext - *ppachTemplate - cchWritten : cchTemplate - cchWritten; rc = RTStrmWrite(g_pStdOut, *ppachTemplate + cchWritten, cchToWrite); if (RT_FAILURE(rc)) { RTStrmPrintf(g_pStdErr, "Error writing output: %Rrc\n", rc); return false; } cchWritten += cchToWrite; if (!pchNext) break; /* And substitute any of our well-known strings. We favour code * readability over efficiency here. */ if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, COMMAND, sizeof(COMMAND) - 1)) { if (!pParameters->pcszCommand) { RTStrmPrintf(g_pStdErr, "--command not specified.\n"); return false; } if (!writeCommand(pParameters->enmFormat, pParameters->pcszCommand)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, ARGUMENTS, sizeof(ARGUMENTS) - 1)) { if ( pParameters->pcszArguments && !writeQuoted(pParameters->enmFormat, pParameters->pcszArguments)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, DESCRIPTION, sizeof(DESCRIPTION) - 1)) { if (!pParameters->pcszDescription) { RTStrmPrintf(g_pStdErr, "--description not specified.\n"); return false; } if (!writePrintableString(pParameters->enmFormat, pParameters->pcszDescription)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, SERVICE_NAME, sizeof(SERVICE_NAME) - 1)) { if ( !pParameters->pcszCommand && !pParameters->pcszServiceName) { RTStrmPrintf(g_pStdErr, "Neither --command nor --service-name specified.\n"); return false; } if (pParameters->pcszServiceName) { if (!writePrintableString(pParameters->enmFormat, pParameters->pcszServiceName)) return false; } else { const char *pcszFileName = RTPathFilename(pParameters->pcszCommand); const char *pcszSuffix = RTPathSuffix(pParameters->pcszCommand); char *pszName = RTStrDupN(pcszFileName, pcszSuffix ? pcszSuffix - pcszFileName : RTPATH_MAX); bool fRc; if (!pszName) { RTStrmPrintf(g_pStdErr, "Out of memory.\n"); return false; } fRc = writePrintableString(pParameters->enmFormat, pszName); RTStrFree(pszName); if (!fRc) return false; } } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, HAVE_ONESHOT, sizeof(HAVE_ONESHOT) - 1)) { if (!pParameters->fOneShot) skipLine(*ppachTemplate, cchTemplate, &cchWritten); } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, HAVE_DAEMON, sizeof(HAVE_DAEMON) - 1)) { if (pParameters->fOneShot) skipLine(*ppachTemplate, cchTemplate, &cchWritten); } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, STOP_COMMAND, sizeof(STOP_COMMAND) - 1)) { if ( pParameters->pcszStopCommand && !writeCommand(pParameters->enmFormat, pParameters->pcszStopCommand)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, STOP_ARGUMENTS, sizeof(STOP_ARGUMENTS) - 1)) { if ( pParameters->pcszStopArguments && !writeQuoted(pParameters->enmFormat, pParameters->pcszStopArguments)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, HAVE_STOP_COMMAND, sizeof(HAVE_STOP_COMMAND) - 1)) { if (!pParameters->pcszStopCommand) skipLine(*ppachTemplate, cchTemplate, &cchWritten); } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, NO_STOP_COMMAND, sizeof(NO_STOP_COMMAND) - 1)) { if (pParameters->pcszStopCommand) skipLine(*ppachTemplate, cchTemplate, &cchWritten); } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, STATUS_COMMAND, sizeof(STATUS_COMMAND) - 1)) { if ( pParameters->pcszStatusCommand && !writeCommand(pParameters->enmFormat, pParameters->pcszStatusCommand)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, STATUS_ARGUMENTS, sizeof(STATUS_ARGUMENTS) - 1)) { if ( pParameters->pcszStatusArguments && !writeQuoted(pParameters->enmFormat, pParameters->pcszStatusArguments)) return false; } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, HAVE_STATUS_COMMAND, sizeof(HAVE_STATUS_COMMAND) - 1)) { if (!pParameters->pcszStatusCommand) skipLine(*ppachTemplate, cchTemplate, &cchWritten); } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, NO_STATUS_COMMAND, sizeof(NO_STATUS_COMMAND) - 1)) { if (pParameters->pcszStatusCommand) skipLine(*ppachTemplate, cchTemplate, &cchWritten); } else if (getSequence(*ppachTemplate, cchTemplate, &cchWritten, "%%", 2)) { rc = RTStrmPutCh(g_pStdOut, '%'); if (RT_FAILURE(rc)) { RTStrmPrintf(g_pStdErr, "Error writing output: %Rrc\n", rc); return false; } } else { RTStrmPrintf(g_pStdErr, "Unknown substitution sequence in input at \"%.*s\"\n", RT_MIN(16, cchTemplate - cchWritten), *ppachTemplate + cchWritten); return false; } } return true; }
void Adafruit_SSD1351::begin(void) { WyzBeeGpio_InitOut(GPIO_PWM2,GPIO_HIGH); //DC FM4_GPIO->ADE=0; WyzBeeGpio_Put(GPIO_SPI2CS,GPIO_LOW);// P53 CS LOW WyzBeeGpio_Init(GPIO_PWM1,GPIO_OUTPUT,GPIO_HIGH);//P41 reset WyzBeeGpio_Put(GPIO_PWM1,GPIO_HIGH); delay(500); WyzBeeGpio_Put(GPIO_PWM1,GPIO_LOW); delay(500); WyzBeeGpio_Put(GPIO_PWM1,GPIO_HIGH); delay(500); // Initialization Sequence writeCommand(SSD1351_CMD_COMMANDLOCK); // set command lock writeData(0x12); writeCommand(SSD1351_CMD_COMMANDLOCK); // set command lock writeData(0xB1); writeCommand(SSD1351_CMD_DISPLAYOFF); // 0xAE writeCommand(SSD1351_CMD_CLOCKDIV); // 0xB3 writeCommand(0xF1); // 7:4 = Oscillator Frequency, 3:0 = CLK Div Ratio (A[3:0]+1 = 1..16) writeCommand(SSD1351_CMD_MUXRATIO); writeData(127); writeCommand(SSD1351_CMD_SETREMAP); writeData(0x74); writeCommand(SSD1351_CMD_SETCOLUMN); writeData(0x00); writeData(0x7F); writeCommand(SSD1351_CMD_SETROW); writeData(0x00); writeData(0x7F); writeCommand(SSD1351_CMD_STARTLINE); // 0xA1 if (SSD1351HEIGHT == 96) { writeData(96); } else { writeData(0); } writeCommand(SSD1351_CMD_DISPLAYOFFSET); // 0xA2 writeData(0x0); writeCommand(SSD1351_CMD_SETGPIO); writeData(0x00); writeCommand(SSD1351_CMD_FUNCTIONSELECT); writeData(0x01); // internal (diode drop) writeCommand(SSD1351_CMD_PRECHARGE); // 0xB1 writeCommand(0x32); writeCommand(SSD1351_CMD_VCOMH); // 0xBE writeCommand(0x05); writeCommand(SSD1351_CMD_NORMALDISPLAY); // 0xA6 writeCommand(SSD1351_CMD_CONTRASTABC); writeData(0xC8); writeData(0x80); writeData(0xC8); writeCommand(SSD1351_CMD_CONTRASTMASTER); writeData(0x0F); writeCommand(SSD1351_CMD_SETVSL ); writeData(0xA0); writeData(0xB5); writeData(0x55); writeCommand(SSD1351_CMD_PRECHARGE2); writeData(0x01); writeCommand(SSD1351_CMD_DISPLAYON); //--turn on oled panel }
//*************************************************** // Unlock the block associated with the address //*************************************************** void unlockBlock(struct FLContext *handle, u32 block){ writeCommand(handle, block, 0x60); // Confirm the unlock. writeCommand(handle, block, 0xD0); }
void TextLCD::cls() { writeCommand(0x01); // cls, and set cursor to 0 locate(0, 0); }
//*************************************************************** // Read a word of 16 bits from the flash at the given address // Then returns this word //*************************************************************** u16 readWord(struct FLContext *handle, u32 address){ writeCommand(handle, address, 0xFF); u16 word = readCommand(handle, address); return word; }
/** Move to the specified row and column * * @param row the row number to move to (0 to LINES - 1) * @param col the column number to move to (0 to WIDTH - 1) */ static void setPosition(uint8_t row, uint8_t col) { writeCommand(0xB0 | (row % LINES)); writeCommand(0x00 | ((col % WIDTH) & 0x0f)); writeCommand(0x10 | ((col % WIDTH) >> 4)); }
/** * @brief Setzt den Display Curser an die erste Spalte, zweite Zeile * */ void setCursor2Line() { writeCommand(0xc0); _delay_ms(1); }
void PICadillo35t::invertDisplay(boolean i) { writeCommand(i ? HX8357_INVON : HX8357_INVOFF); }
/** * @brief Setzt den Display Curser um eins nach Rechts * */ void shiftCursorRight() { writeCommand(0x14); }
void PICadillo35t::displayOff() { writeCommand(HX8357_DISPLAYOFF); }
/** * @brief Löscht den Displayinhalt * * */ void clearDisplay() { writeCommand(0x0); _delay_ms(3); writeCommand(0x1); _delay_ms(3); }
void Adafruit_SSD1351::begin(void) { // set pin directions pinMode(_rs, OUTPUT); if (_sclk) { pinMode(_sclk, OUTPUT); pinMode(_sid, OUTPUT); } else { // using the hardware SPI SPI.begin(); SPI.setDataMode(SPI_MODE3); } // Toggle RST low to reset; CS low so it'll listen to us pinMode(_cs, OUTPUT); digitalWrite(_cs, LOW); if (_rst) { pinMode(_rst, OUTPUT); digitalWrite(_rst, HIGH); delay(500); digitalWrite(_rst, LOW); delay(500); digitalWrite(_rst, HIGH); delay(500); } // Initialization Sequence writeCommand(SSD1351_CMD_COMMANDLOCK); // set command lock writeData(0x12); writeCommand(SSD1351_CMD_COMMANDLOCK); // set command lock writeData(0xB1); writeCommand(SSD1351_CMD_DISPLAYOFF); // 0xAE writeCommand(SSD1351_CMD_CLOCKDIV); // 0xB3 writeCommand(0xF1); // 7:4 = Oscillator Frequency, 3:0 = CLK Div Ratio (A[3:0]+1 = 1..16) writeCommand(SSD1351_CMD_MUXRATIO); writeData(127); writeCommand(SSD1351_CMD_SETREMAP); writeData(0x74); writeCommand(SSD1351_CMD_SETCOLUMN); writeData(0x00); writeData(0x7F); writeCommand(SSD1351_CMD_SETROW); writeData(0x00); writeData(0x7F); writeCommand(SSD1351_CMD_STARTLINE); // 0xA1 if (SSD1351HEIGHT == 96) { writeData(96); } else { writeData(0); } writeCommand(SSD1351_CMD_DISPLAYOFFSET); // 0xA2 writeData(0x0); writeCommand(SSD1351_CMD_SETGPIO); writeData(0x00); writeCommand(SSD1351_CMD_FUNCTIONSELECT); writeData(0x01); // internal (diode drop) //writeData(0x01); // external bias // writeCommand(SSSD1351_CMD_SETPHASELENGTH); // writeData(0x32); writeCommand(SSD1351_CMD_PRECHARGE); // 0xB1 writeCommand(0x32); writeCommand(SSD1351_CMD_VCOMH); // 0xBE writeCommand(0x05); writeCommand(SSD1351_CMD_NORMALDISPLAY); // 0xA6 writeCommand(SSD1351_CMD_CONTRASTABC); writeData(0xC8); writeData(0x80); writeData(0xC8); writeCommand(SSD1351_CMD_CONTRASTMASTER); writeData(0x0F); writeCommand(SSD1351_CMD_SETVSL ); writeData(0xA0); writeData(0xB5); writeData(0x55); writeCommand(SSD1351_CMD_PRECHARGE2); writeData(0x01); writeCommand(SSD1351_CMD_DISPLAYON); //--turn on oled panel }
int main(void) { /* Initialise hardware timers and ports. All start off as inputs */ /* PD0 is RxD PD1 is TxD */ /** PORTB is set as outputs on bits 0,3,4 to set controls. The SPI output ports SCK and MOSI stay as inputs until ready to program. Set the Ports PB0-2 as outputs and set high to turn off all LEDs PB0 = programming mode LED PB3 = programming completed LED (and serial comms switch over) PB4 = programming active LED (and reset out) PB5 = MOSI PB6 = MISO PB7 = SCK */ sbi(ACSR,7); // Turn off Analogue Comparator initbootuart(); // Initialize UART. uint8_t sigByte1=0; // Target Definition defaults uint8_t sigByte2=0; uint8_t sigByte3=0; uint8_t fuseBits=0; uint8_t highFuseBits=0; uint8_t extendedFuseBits=0; uint8_t lockBits=0; /*---------------------------------------------------------------------------*/ /* Main loop. We exit this only with an "E" command. */ { for(;;) { command=recchar(); // Loop and wait for command character. /** 'a' Check autoincrement status. This allows a block of data to be uploaded to consecutive addresses without specifying the address each time */ if (command=='a') { sendchar('Y'); // Yes, we will autoincrement. } /** 'A' Set address. This is stored and incremented for each upload/download. NOTE: Flash addresses are given as word addresses, not byte addresses. */ else if (command=='A') // Set address { address = (recchar()<<8); // Set address high byte first. address |= recchar(); // Then low byte. sendchar('\r'); // Send OK back. } /** 'b' Check block load support. This returns the allowed block size. We will not buffer anything so we will use the FLASH page size to limit the programmer's blocks to those that will fit the target's page. This then avoids the long delay when the page is committed, that may cause incoming data to be lost. This should not be called before the P command is executed, and the target device characteristics obtained. The fPageSize characteristic should be non zero.*/ else if (command=='b') { uint16_t blockLength = ((uint16_t)fPageSize<<1); if (fPageSize > 0) sendchar('Y'); // Report block load supported. else sendchar('N'); sendchar(high(blockLength)); // MSB first. sendchar(low(blockLength)); // Report FLASH pagesize (bytes). } /** 'p' Get programmer type. This returns just 'S' for serial. */ else if (command=='p') { sendchar('S'); // Answer 'SERIAL'. } /** 'S' Return programmer identifier. Always 7 digits. We call it AVRSPRG */ else if (command=='S') { sendchar('A'); sendchar('V'); // ID always 7 characters. sendchar('R'); sendchar('S'); sendchar('P'); sendchar('R'); sendchar('G'); } /** 'V' Return software version. */ else if (command=='V') { sendchar('0'); sendchar('0'); } /** 't' Return supported device codes. This returns a list of devices that can be programmed. This is only used by AVRPROG so we will not use it - we work with signature bytes instead. */ else if(command=='t') { sendchar( 0 ); // Send list terminator. } /** 'x' Set LED. */ else if ((command=='x') || (command=='y') || (command=='T')) { // if (command=='x') sbi(PORTB,LED); // else if (command=='y') cbi(PORTB,LED); recchar(); // Discard sent value sendchar('\r'); // Send OK back. } /** 'P' Enter programming mode. This starts the programming of the device. Pulse the reset line high while SCK is low. Send the command and ensure that the echoed second byte is correct, otherwise redo. With this we get the device signature and search the table for its characteristics. A timeout is provided in case the device doesn't respond. This will allow fall through to an ultimate error response. The reset line is held low until programming mode is exited. */ else if (command=='P') { outb(DDRB,(inb(DDRB) | 0xB9)); // Setup SPI output ports outb(PORTB,(inb(PORTB) | 0xB9)); // SCK and MOSI high, and LEDs off uint8_t retry = 10; uint8_t result = 0; while ((result != 0x53) && (retry-- > 0)) { cbi(PORTB,SCK); // Set serial clock low sbi(PORTB,RESET); // Pulse reset line off _delay_us(100); // Delay to let CPU know that programming will occur cbi(PORTB,RESET); // Pulse reset line on _delay_us(25000); // 25ms delay writeCommand(0xAC,0x53,0x00,0x00); // "Start programming" command result=buffer[2]; } /** Once we are in programming mode, grab the signature bytes and extract all information about the target device such as its memory sizes, page sizes and capabilities. */ writeCommand(0x30,0x00,0x00,0x00); sigByte1 = buffer[3]; writeCommand(0x30,0x00,0x01,0x00); sigByte2 = buffer[3]; writeCommand(0x30,0x00,0x02,0x00); // Signature Bytes sigByte3 = buffer[3]; /* Check for device support. If the first signature byte is not 1E, then the device is either not an Atmel device, is locked, or is not responding.*/ uint8_t found=FALSE; // Indicates if the target device is supported uint8_t partNo = 0; if (sigByte1 == 0x1E) { while ((partNo < NUMPARTS) && (! found)) { found = ((part[partNo][0] == sigByte2) && (part[partNo][1] == sigByte3)); partNo++; } } if (found) { partNo--; sendchar('\r'); fPageSize = part[partNo][2]; ePageSize = part[partNo][3]; canCheckBusy = part[partNo][4]; lfCapability = part[partNo][5]; buffer[3] = 0; // In case we cannot read these if (lfCapability & 0x08) writeCommand(0x50,0x08,0x00,0x00); // Read Extended Fuse Bits extendedFuseBits = buffer[3]; if (lfCapability & 0x04) writeCommand(0x58,0x08,0x00,0x00); // Read High Fuse Bits highFuseBits = buffer[3]; if (lfCapability & 0x02) writeCommand(0x50,0x00,0x00,0x00); // Read Fuse Bits fuseBits = buffer[3]; if (lfCapability & 0x01) writeCommand(0x58,0x00,0x00,0x00); // Read Lock Bits lockBits = buffer[3]; } else // Not found? { sbi(PORTB,RESET); // Lift reset line sendchar('?'); // Device cannot be programmed outb(DDRB,(inb(DDRB) & ~0xA0)); // Set SPI ports to inputs } } /** 'L' Leave programming mode. */ else if(command=='L') { sbi(PORTB,RESET); // Turn reset line off sendchar('\r'); // Answer OK. outb(DDRB,(inb(DDRB) & ~0xA0)); // Set SPI ports to inputs } /** 'e' Chip erase. This requires several ms. Ensure that the command has finished before acknowledging. */ else if (command=='e') { writeCommand(0xAC,0x80,0x00,0x00); // Erase command pollDelay(FALSE); sendchar('\r'); // Send OK back. } /** 'R' Read program memory */ else if (command=='R') { /** Send high byte, then low byte of flash word. Send each byte from the address specified (note address variable is modified).*/ lsbAddress = low(address); msbAddress = high(address); writeCommand(0x28,msbAddress,lsbAddress,0x00); // Read high byte sendchar(buffer[3]); writeCommand(0x20,msbAddress,lsbAddress,0x00); // Read low byte sendchar(buffer[3]); address++; // Auto-advance to next Flash word. } /** 'c' Write to program memory page buffer, low byte. NOTE: Always use this command before sending the high byte. It is written to the page but the address is not incremented.*/ else if (command=='c') { received = recchar(); writeCommand(0x40,0x00,address & 0x7F,received); // Low byte sendchar('\r'); // Send OK back. } /** 'C' Write to program memory page buffer, high byte. This will cause the word to be written to the page and the address incremented. It is the responsibility of the user to issue a page write command.*/ else if (command=='C') { received = recchar(); writeCommand(0x48,0x00,address & 0x7F,received); // High Byte address++; // Auto-advance to next Flash word. sendchar('\r'); // Send OK back. } /** 'm' Issue Page Write. This writes the target device page buffer to the Flash. The address is that of the page, with the lower bits masked out. This requires several ms. Ensure that the command has finished before acknowledging. We could check for end of memory here but that would require storing the Flash capacity for each device. The calling program will know in any case if it has overstepped.*/ else if (command== 'm') { writeCommand(0x4C,(address>>8) & 0x7F,address & 0xE0,0x00); // Write Page pollDelay(TRUE); // Short delay sendchar('\r'); // Send OK back. } /** 'D' Write EEPROM memory This writes the byte directly to the EEPROM at the specified address. This requires several ms. Ensure that the command has finished before acknowledging.*/ else if (command == 'D') { lsbAddress = low(address); msbAddress = high(address); writeCommand(0xC0,msbAddress,lsbAddress,recchar()); // EEPROM byte address++; // Auto-advance to next EEPROM byte. pollDelay(FALSE); // Long delay sendchar('\r'); // Send OK back. } /** 'd' Read EEPROM memory */ else if (command == 'd') { lsbAddress = low(address); msbAddress = high(address); writeCommand(0xA0,msbAddress,lsbAddress, 0x00); sendchar(buffer[3]); address++; // Auto-advance to next EEPROM byte. } /** 'B' Start block load. The address must have already been set otherwise it will be undefined. */ else if (command=='B') { tempInt = (recchar()<<8); // Get block size high byte first. tempInt |= recchar(); // Low Byte. sendchar(BlockLoad(tempInt,recchar(),&address)); // Block load. } /** 'g' Start block read. The address must have already been set otherwise it will be undefined.*/ else if (command=='g') { tempInt = (recchar()<<8); // Get block size high byte first. tempInt |= recchar(); // Low Byte. command = recchar(); // Get memory type BlockRead(tempInt,command,&address); // Block read } /** 'r' Read lock bits. */ else if (command=='r') { sendchar(lockBits); } /** 'l' Write lockbits. */ else if (command=='l') { if (lfCapability & 0x10) writeCommand(0xAC,0xE0,0x00,recchar()); sendchar('\r'); // Send OK back. } /** 'F' Read fuse bits. */ else if (command=='F') { sendchar(fuseBits); } /** 'f' Write fuse bits. */ else if (command=='f') { if (lfCapability & 0x20) writeCommand(0xAC,0xA0,0x00,recchar()); // Fuse byte sendchar('\r'); // Send OK back. } /** 'N' Read high fuse bits. */ else if (command=='N') { sendchar(highFuseBits); } /** 'n' Write high fuse bits. */ else if (command=='n') { if (lfCapability & 0x40) writeCommand(0xAC,0xA8,0x00,recchar()); // High Fuse byte sendchar('\r'); // Send OK back. } /** 'Q' Read extended fuse bits. */ else if (command=='Q') { sendchar(extendedFuseBits); } /** 'q' Write extended fuse bits. */ else if (command=='q') { if (lfCapability & 0x80) writeCommand(0xAC,0xA4,0x00,recchar()); // Extended Fuse byte sendchar('\r'); // Send OK back. } /** 's' Return signature bytes. Sent Most Significant Byte first. */ else if (command=='s') { sendchar(sigByte3); sendchar(sigByte2); sendchar(sigByte1); } /** 'E' Exit bootloader. At this command we enter serial passthrough and don't return from it until a hardware reset occurs. At the same time we should lift the reset from the target. Spin endlessly so we don't interpret serial data, and wait for our own hard reset.*/ else if (command=='E') { sendchar('\r'); sbi(PORTB,RESET); // Pulse reset line off cbi(PORTB,PASSTHROUGH); // Change to serial passthrough outb(DDRB,(inb(DDRB) & ~0xA0)); // Set SPI ports to inputs for (;;); // Spin endlessly } /** The last command to accept is ESC (synchronization). This is used to abort any command by filling in remaining parameters, after which it is simply ignored. Otherwise, the command is not recognized and a "?" is returned.*/ else if (command!=0x1b) sendchar('?'); // If not ESC, then it is unrecognized }