esError storageWrite( struct storageSpace * space, const void * buffer) { esError error; if ((error = storageClearSpace(space))) { return (error); } if ((error = flashWrite(STORAGE_DATA_ADDRESS(space->phy.base), buffer, space->data.size))) { return (error); } space->data.checksum = checksumParity8(buffer, space->data.size); space->checksum = 0; space->checksum = checksumParity8(space, sizeof(*space)); if ((error = flashWrite(space->phy.base, space, sizeof(*space)))) { return (error); } return (ES_ERROR_NONE); }
/****************************************************************************** Name: flashWriteCmd Description: Sends a command sequence to flash. Parameters: 1) command 2) address (for sector erase command only) Returns: none ******************************************************************************/ void flashWriteCmd(U8 cmd, U32 adr) { /* write unlock commands */ flashWrite(ADR_UNLOCK1, (U16)CMD_UNLOCK1); flashWrite(ADR_UNLOCK2, (U16)CMD_UNLOCK2); /* write command */ if (cmd == CMD_SECTOR_ERASE) flashWrite(adr, (U16)CMD_SECTOR_ERASE); else flashWrite(ADR_UNLOCK1, (U16)cmd); }
void write16(const u32 address, const u16 value) { switch (address >> 24) { case 8: if (address == 0x80000c4 || address == 0x80000c6 || address == 0x80000c8) { rtcWrite(address, value); } break; case 13: if (game.hasEEPROM()) { eepromWrite(address, (u8)value); } break; case 14: if (game.hasSRAM()) { sramWrite(address, (u8)value); } else if (game.hasFlash()) { flashWrite(address, (u8)value); } break; default: break; } }
/****************************************************************************** Name: GNDS_FL_Write Description: Writes to flash memory. Parameters: 1) start address (in flash memory space) 2) pointer to buffer 3) size = number of words to write Returns: GD_OK GD_ERR_FLASH_WRITE if device returns an error GD_ERR_TIMEOUT if custom timeout ******************************************************************************/ GERR GNDS_FL_Write(U32 address, U16* data, U32 size) { U16 rd; U32 i, timeout; GERR ferr; ferr = GD_OK; for (i = 0; i < size; i++) { flashWriteCmd(CMD_PROGRAM, 0); flashWrite(address, data[i]); /* wait until programming is finished */ ferr = GD_ERR_BAD_PARAMETER; timeout = TIMEOUT; while ((ferr == GD_ERR_BAD_PARAMETER)&&((timeout--) > 0)) { rd = flashRead(address); if ((rd&DQ7)==(data[i]&DQ7)) ferr = GD_OK; else if ((rd&DQ5)==DQ5) { /* check DQ7 again according to flash device specification */ rd = flashRead(address); if ((rd&DQ7)==(data[i]&DQ7)) ferr = GD_OK; else ferr = GD_ERR_FLASH_WRITE; } } if (timeout == 0) ferr = GD_ERR_TIMEOUT; if (ferr != GD_OK) return ferr; address++; } return ferr; }
/*----------------------------------------------------------------------- * Write a word to Flash, returns: * 0 - OK * 1 - write timeout * 2 - Flash not erased */ static int write_word (flash_info_t * info, ulong dest, ulong data) { flash_dev_t *dev = getFlashDevFromInfo (info); int addr = dest - info->start[0]; if (!dev) return 1; if (OK != flashWrite (dev, addr, (char *) &data, sizeof (ulong))) { printf ("ERROR: could not write to addr=0x%x, data=0x%x\n", (unsigned int) addr, (unsigned) data); return 1; } if ((addr % FLASH_SECTOR_SIZE) == 0) printf ("."); PRINTF ("write_word:0x%x, base=0x%x, addr=0x%x, data=0x%x\n", (unsigned) info->start[0], (unsigned) dest, (unsigned) (dest - info->start[0]), (unsigned) data); return (0); }
static void ram_to_rom(struct ParseState *Parser, struct Value *ReturnValue, struct Value **Param, int NumArgs) { (void) ReturnValue; (void) NumArgs; (void) Param; //delete flash page PlatformPrintf(Parser->pc, "erasing flash\n"); if (!flashErase(sector)) { //write data to flash PlatformPrintf(Parser->pc, "writing to flash\n"); if (!flashWrite((uint32_t *) flash_base, script_buffer, strlen(script_buffer) + 1)) { PlatformPrintf(Parser->pc, "done!\n"); } else { PlatformPrintf(Parser->pc, "!! writing error !!\n"); } } else { PlatformPrintf(Parser->pc, "!! flash erasing error !!\n"); } }
void eeprom_flush(void *arg) { (void)arg; flashErase(((uint32_t)&flash_area) / 1024, 1); flashWrite((uint8_t *)flash_backing, (const uint8_t *)&flash_area, sizeof(flash_backing)); flash_state = STATE_CLEAN; }
void writeToFlash(void) { flashState.version = FLASH_DATA_VERSION; scheduleMsg(&logger, "FLASH_DATA_VERSION=%d", flashState.version); crc result = flashStateCrc(&flashState); flashState.value = result; scheduleMsg(&logger, "Reseting flash=%d", FLASH_USAGE); flashErase(FLASH_ADDR, FLASH_USAGE); scheduleMsg(&logger, "Flashing with CRC=%d", result); time_t now = chTimeNow(); result = flashWrite(FLASH_ADDR, (const char *) &flashState, FLASH_USAGE); scheduleMsg(&logger, "Flash programmed in (ms): %d", chTimeNow() - now); scheduleMsg(&logger, "Flashed: %d", result); }
void CalibrationTable::createFastCal(void) { #ifdef NZS_FAST_CAL int32_t i; uint16_t cs=0; uint16_t data[256]; int32_t j; j=0; cs=0; LOG("setting fast calibration"); for (i=0; i<16384; i++) { uint16_t x; x=reverseLookup(i*4); data[j]=x; j++; if (j>=256) { flashWrite(&NVM->FastCal.angle[i-255],data,256*sizeof(uint16_t)); //LOG("Wrote fastcal at index %d-%d", i-255, i); j=0; } cs+=x; } //update the checksum flashWrite(&NVM->FastCal.checkSum,&cs,sizeof(uint16_t)); fastCalVaild=true; //this is a quick test /* for (i=0; i<16384; i++) { LOG("fast Cal %d,%d,%d",i,NVM->FastCal.angle[i],(uint32_t)reverseLookup(i*4)); } */ #endif }
// ------------------------------------- // Main function // ------------------------------------- void appMain(void) { uint16_t i; // timers (used to get an extra interrupt context) alarmInit(&timer, onTimer, NULL); alarmSchedule(&timer, 1000); // radio radioSetReceiveHandle(radioRecvCb); radioOn(); for (i = 0; i < BUFFER_SIZE; i++) { buffer[i] = i; } randomInit(); // SELECT_FLASH; // extFlashBulkErase(); // UNSELECT_FLASH; for (i = 0; ; i++) { uint32_t address = i * 64ul; SELECT_FLASH; if (IS_ALIGNED(address, EXT_FLASH_SECTOR_SIZE)) { PRINTF("erase address %lu\n", address); flashErase(address); } PRINTF("write address %lu\n", address); flashWrite(address); if (address > 0) { PRINTF("verify...\n"); flashRead(address - 64); } UNSELECT_FLASH; msleep(randomInRange(400, 1000)); PRINTF("send smth to radio...\n"); radioSend("hello world", sizeof("hello world")); greenLedToggle(); } }
void writeToFlash(void) { #if EFI_INTERNAL_FLASH persistentState.size = PERSISTENT_SIZE; persistentState.version = FLASH_DATA_VERSION; scheduleMsg(&logger, "flash compatible with %d", persistentState.version); crc_t result = flashStateCrc(&persistentState); persistentState.value = result; scheduleMsg(&logger, "Reseting flash: size=%d", PERSISTENT_SIZE); flashErase(FLASH_ADDR, PERSISTENT_SIZE); scheduleMsg(&logger, "Flashing with CRC=%d", result); efitimems_t nowMs = currentTimeMillis(); result = flashWrite(FLASH_ADDR, (const char *) &persistentState, PERSISTENT_SIZE); scheduleMsg(&logger, "Flash programmed in (ms): %d", currentTimeMillis() - nowMs); scheduleMsg(&logger, "Flashing result: %d", result); #endif /* EFI_INTERNAL_FLASH */ }
__attribute__((naked)) __attribute__((noreturn)) void write(uint8_t *work_area_p, uint8_t *fifo_end, uint8_t *target_address, uint32_t count) { uint32_t retval; volatile work_area_t *work_area = (work_area_t *) work_area_p; uint8_t *fifo_start = (uint8_t *) work_area->rp; while (count) { volatile int32_t fifo_linear_size; /* Wait for some data in the FIFO */ while (work_area->rp == work_area->wp) ; if (work_area->wp == 0) { /* Aborted by other party */ break; } if (work_area->rp > work_area->wp) { fifo_linear_size = fifo_end-work_area->rp; } else { fifo_linear_size = (work_area->wp - work_area->rp); if (fifo_linear_size < 0) fifo_linear_size = 0; } if (fifo_linear_size < 16) { /* We should never get here */ continue; } retval = flashWrite((uint32_t) target_address, (uint8_t **) &work_area->rp, fifo_linear_size); if (retval != SUCCESS) { work_area->rp = (uint8_t *)retval; break; } target_address += fifo_linear_size; if (work_area->rp >= fifo_end) work_area->rp = fifo_start; count -= fifo_linear_size; } __asm("bkpt 0"); }
void writeToFlashNow(void) { scheduleMsg(logger, " !!!!!!!!!!!!!!!!!!!! BE SURE NOT WRITE WITH IGNITION ON !!!!!!!!!!!!!!!!!!!!"); persistentState.size = PERSISTENT_SIZE; persistentState.version = FLASH_DATA_VERSION; scheduleMsg(logger, "flash compatible with %d", persistentState.version); crc_t crcResult = flashStateCrc(&persistentState); persistentState.value = crcResult; scheduleMsg(logger, "Reseting flash: size=%d", PERSISTENT_SIZE); flashErase(FLASH_ADDR, PERSISTENT_SIZE); scheduleMsg(logger, "Flashing with CRC=%d", crcResult); efitimems_t nowMs = currentTimeMillis(); int result = flashWrite(FLASH_ADDR, (const char *) &persistentState, PERSISTENT_SIZE); scheduleMsg(logger, "Flash programmed in %dms", currentTimeMillis() - nowMs); bool isSuccess = result == FLASH_RETURN_SUCCESS; if (isSuccess) { scheduleMsg(logger, FLASH_SUCCESS_MSG); } else { scheduleMsg(logger, "Flashing failed"); } maxLockTime = 0; }
int flashWriteBlock( void *dst, const void *src, int cb ) { uint32_t *d = dst; const uint32_t *s = src; int rc; // convert count of bytes to count of uint32_t int n = (cb >> 2); // round up if remainder if (cb & 0x02) n++; // copy block one uint32_t at a time while (n-- > 0) { rc = flashWrite(d++, *s++); if (rc != 0) return rc; } return 0; }
void write8(const u32 address, const u8 value) { switch (address >> 24) { case 13: if (game.hasEEPROM()) { eepromWrite(address, value); } break; case 14: if (game.hasSRAM()) { sramWrite(address, value); } else if (game.hasFlash()) { flashWrite(address, value); } break; default: break; } }
/** * reads the EEPROM common configuration area, if this area is invalid then * a default configuration is used and also stored in EEPROM for next start, * it also reads the backplane fru eeprom * * \return E_OK if configuration is valid, otherwise Errorcode */ int global_config(void) { unsigned int eeprom_valid = 0x00000000; #if defined(CFG_LAN) || defined(CFG_PEF_ENABLE) unsigned short i; #endif #ifdef CFG_ONCHIP_FLASH_GLOBAL_CONF unsigned char buf[] = { 0xEF, 0xBE, 0xAD, 0xDE, 0x00, 0x00, 0x00, 0x00 }; /* 0xDEADBEEF */ #endif #ifdef CFG_LAN unsigned short len; #endif /* read valid flag */ #ifndef CFG_ONCHIP_FLASH_GLOBAL_CONF fs_read(FILE_INTEGRITY_AREA1, 0, sizeof(unsigned int), &eeprom_valid); #else eeprom_valid = *(unsigned int *)OCFLH_GBLCFG_ADDR_BASE; #endif /* the EEPROM configuration is empty or invalid */ if (eeprom_valid != EEPROM_VALID_FLAG) { /* init global config with default values */ global_conf.allow_sdr_access = YES; global_conf.allow_coldreset = YES; global_conf.global_enables = CFG_GLOBAL_ENABLES; #ifdef CFG_MCMC global_conf.operation_mode = CFG_OPERATION_MODE; #endif #ifdef CFG_LAN /* load LAN configuration */ load_global_lan_config(); /* save the lan configuration to eeprom */ save_global_lan_config(); /* load user configuration */ load_global_user_config(); /* save the user configuration to eeprom */ save_global_user_config(); /* restore MC NC-SI MAC address from FRU */ custom_set_ncsi_mac(); #endif /* CFG_LAN */ /* load default oem configuration */ custom_load_oem_config_defaults(); /* save default configuration settings to eeprom */ save_oem_config(); #ifdef CFG_UART_MUX /* UART MUX setting needs to be updated */ custom_set_uart_mux(); #endif /* set event receiver address and lun, default */ event_receiver_addr = 0x20; event_receiver_lun = 0x00; /* init the SDR Repository */ sdr_repo_info.add_timestamp = 0xFFFFFFFF; sdr_repo_info.erase_timestamp = 0xFFFFFFFF; #ifdef CFG_PEF_ENABLE /* init PEF configuration */ pef_config.set_in_progress = 0x00; pef_config.control = DISABLE_PEF; pef_config.action_control = PEF_DEFAULT_ACTION; pef_config.startup_delay = PEF_DEFAULT_STARTUP_DELAY; pef_config.alert_startup_delay = PEF_DEFAULT_ALERT_STARTUP_DELAY; pef_config.number_event_filters = 0; pef_config.number_alert_policy = 0; memset(&pef_config.system_guid.node[0], 0x00, 16); pef_config.number_alert_strings = 0; pef_config.number_group_control = 0; /* init PEF event filters */ for (i = 0; i < MAX_EVENT_FILTERS; i++) { event_filter_table[i].config = DISABLE_FILTER; } #endif /* CFG_PEF_ENABLE */ #ifdef CFG_ONCHIP_FLASH_GLOBAL_CONF flashErase(OCFLH_GBLCFG_SECT_START, OCFLH_GBLCFG_SECT_END); flashWrite((void *)OCFLH_GBLCFG_ADDR_BASE, (void *)buf, sizeof(buf)); eeprom_valid = *(unsigned int *)OCFLH_GBLCFG_ADDR_BASE; #endif } else /* valid EEPROM configuration exists */ { /* init global config with default values */ global_conf.allow_sdr_access = YES; global_conf.allow_coldreset = YES; global_conf.global_enables = CFG_GLOBAL_ENABLES; #ifdef CFG_MCMC global_conf.operation_mode = CFG_OPERATION_MODE; #endif #if defined (CFG_ATCA) || defined (CFG_MCMC) /* set event receiver address and lun, default */ event_receiver_addr = 0x20; event_receiver_lun = 0x00; #endif /* CFG_ATCA || CFG_MCMC */ #ifdef CFG_LAN /* read lan interface specific parameter */ spi_eeprom_safe_area_read(LAN_CONFIGURATION_OFFSET, sizeof(global_lan_conf_t), &lan_conf); /* check CRC for lan configuration */ len = ((unsigned char *)(&(lan_conf.crc)) - (unsigned char *)(&lan_conf)); if (!_check_crc(&lan_conf, len, lan_conf.crc)) { uart_printf("Error Lan Config CRC\n"); } #ifdef CFG_HW_DEPENDENT_LAN_ADDRESS custom_set_hw_dependent_ip_mac_addr(); #endif /* set volatile privilege level to the non-volatile value */ lan_conf.priv_level_curr = lan_conf.priv_level; /* read user specific parameter */ spi_eeprom_safe_area_read(USER_CONFIGURATION_OFFSET, sizeof(global_user_conf_t), &global_user); /* check CRC for user configuration */ len = ((unsigned char *)(&(global_user.crc)) - (unsigned char *)(&global_user)); if (!_check_crc(&global_user, len, global_user.crc)) { uart_printf("Error User Config CRC\n"); } /* decrypt the passwords with the XTEA algorithm */ for (i = 0; i < configPRIV_MAX_USERS; i++) { if (xtea_decrypt_block((unsigned char *)(global_user.user[i].password), IPMI_PRIV_PW_MAX_LEN, pw_crypto_key) != 0) { uart_printf("Error User Config Decryption\n"); } } #endif /* CFG_LAN */ /* read oem configuration from eeprom */ load_oem_config(); /* load oem configuration defaults, if version number is different */ if (oem_config.version != OEM_CONFIG_VERSION) { uart_printf("Configuration setting EEPROM layout (version 0x%02X) " "updated to version 0x%02X\n", oem_config.version, OEM_CONFIG_VERSION); /* load default oem configuration */ custom_load_oem_config_defaults(); /* save default configuration settings to eeprom */ save_oem_config(); #ifdef CFG_UART_MUX /* UART MUX setting needs to be updated */ custom_set_uart_mux(); #endif } } return E_OK; }
void flashDelayedWrite(u32 address, u8 byte) { saveType = 2; cpuSaveGameFunc = flashWrite; flashWrite(address, byte); }
int flashIHexFile(FIL* file) { IHexRecord irec; flashsector_t sector; bool erasedSectors[FLASH_SECTOR_COUNT] = { FALSE }; flashaddr_t baseAddress = 0; flashaddr_t address = 0; while (Read_IHexRecord(&irec, file) == IHEX_OK) { switch (irec.type) { case IHEX_TYPE_00: /**< Data Record */ /* Compute the target address in flash */ address = baseAddress + irec.address; /* Erase the corresponding addresses if needed */ for (sector = flashSectorAt(address); sector <= flashSectorAt(address + irec.dataLen - 1); ++sector) { /* Check if the sector has been erased during this IHex flashing procedure to prevent erasing already written data */ if (erasedSectors[sector] == TRUE) continue; /* Check if the sector in flash needs to be erased */ if (flashIsErased(flashSectorBegin(sector), flashSectorSize(sector)) == FALSE) { /* Erase the sector */ if (flashSectorErase(sector) != FLASH_RETURN_SUCCESS) return BOOTLOADER_ERROR_BADFLASH; } /* Set the erased flag to prevent erasing the same sector twice during the IHex flashing procedure */ erasedSectors[sector] = TRUE; } /* Write the data in flash */ if (flashWrite(address, (const char*)irec.data, irec.dataLen) != FLASH_RETURN_SUCCESS) return BOOTLOADER_ERROR_BADFLASH; break; case IHEX_TYPE_04: /**< Extended Linear Address Record */ /* Compute the base address of the following data records */ baseAddress = irec.data[0]; baseAddress <<= 8; baseAddress += irec.data[1]; baseAddress <<= 16; break; case IHEX_TYPE_01: /**< End of File Record */ /* Check that the end of file record is at the end of the file... */ return f_eof(file) ? BOOTLOADER_SUCCESS : BOOTLOADER_ERROR_BADHEX; case IHEX_TYPE_05: /**< Start Linear Address Record */ /* Ignored */ break; case IHEX_TYPE_02: /**< Extended Segment Address Record */ case IHEX_TYPE_03: /**< Start Segment Address Record */ /* Not supported */ return BOOTLOADER_ERROR_BADHEX; } } return BOOTLOADER_ERROR_BADHEX; }
STATUS flashDiag (flash_dev_t * dev) { unsigned int *buf = 0; int i, len, sector; int rv = ERROR; if (flashCheck (dev) == ERROR) return ERROR; printf ("flashDiag: Testing device %d, " "base: 0x%x, %d sectors @ %d kB = %d kB\n", DEV_NO (dev), dev->base, dev->sectors, 1 << (dev->lgSectorSize - 10), dev->sectors << (dev->lgSectorSize - 10)); len = 1 << dev->lgSectorSize; printf ("flashDiag: Erasing\n"); if (flashErase (dev) == ERROR) { printf ("flashDiag: Erase failed\n"); goto done; } printf ("%d bytes requested ...\n", len); buf = malloc (len); printf ("allocated %d bytes ...\n", len); if (buf == 0) { printf ("flashDiag: Out of memory\n"); goto done; } /* * Write unique counting pattern to each sector */ for (sector = 0; sector < dev->sectors; sector++) { printf ("flashDiag: Write sector %d\n", sector); for (i = 0; i < len / 4; i++) buf[i] = sector << 24 | i; if (flashWrite (dev, sector << dev->lgSectorSize, (char *) buf, len) == ERROR) { printf ("flashDiag: Write failed (dev: %d, sector: %d)\n", DEV_NO (dev), sector); goto done; } } /* * Verify */ for (sector = 0; sector < dev->sectors; sector++) { printf ("flashDiag: Verify sector %d\n", sector); if (flashRead (dev, sector << dev->lgSectorSize, (char *) buf, len) == ERROR) { printf ("flashDiag: Read failed (dev: %d, sector: %d)\n", DEV_NO (dev), sector); goto done; } for (i = 0; i < len / 4; i++) { if (buf[i] != (sector << 24 | i)) { printf ("flashDiag: Verify error " "(dev: %d, sector: %d, offset: 0x%x)\n", DEV_NO (dev), sector, i); printf ("flashDiag: Expected 0x%08x, got 0x%08x\n", sector << 24 | i, buf[i]); goto done; } } } printf ("flashDiag: Erasing\n"); if (flashErase (dev) == ERROR) { printf ("flashDiag: Final erase failed\n"); goto done; } rv = OK; done: if (buf) free (buf); if (rv == OK) printf ("flashDiag: Device %d passed\n", DEV_NO (dev)); else printf ("flashDiag: Device %d failed\n", DEV_NO (dev)); return rv; }
void cmd_flash(BaseSequentialStream *chp, int argc, char *argv[]) { int j, blockoffset; int status, address; char readBufferBefore[32]; flashsector_t i; chprintf(chp, "Flash test UTIL\r\n"); /* Handle warnings: */ if (argc >= 1) { if (strncmp(argv[0], "write", sizeof("write")) == 0) { if (argc >= 3) { blockoffset = atoi(argv[1]); if (blockoffset < 0 || blockoffset > FLASH_BLOCK_TESTCASE_COUNT) { chprintf(chp, "Offset must between %d and %d. Actual one was: %d \r\n", 0, FLASH_BLOCK_TESTCASE_COUNT, blockoffset); return; } /* use the fourth memory block for the tests */ address = FLASH_BASEADDR + (blockoffset * FLASH_BLOCKSIZE); /* extract the new value to store into it */ readBufferBefore[0] = atoi(argv[2]); status = flashWrite(address, readBufferBefore, FLASH_BLOCKSIZE); if (status != FLASH_RETURN_SUCCESS) { chprintf(chp, "Writing returned %d \r\n", status); return; } chprintf(chp, "test sector %u : stored at 0x%x %d\r\n", flashSectorAt(address), address, readBufferBefore[0]); } else { chprintf(chp, "flash needs additional parameter\r\n"); } } else if (strncmp(argv[0], "read", sizeof("read")) == 0) { for (i = 0; i < FLASH_BLOCK_TESTCASE_COUNT; ++i) { address = FLASH_BASEADDR + (i * FLASH_BLOCKSIZE); chprintf(chp, "test sector %u\t: 0x%x -> 0x%x (%u bytes)\r\n", flashSectorAt(address), address, address + FLASH_BLOCKSIZE, FLASH_BLOCKSIZE); status = flashRead(address, readBufferBefore, FLASH_BLOCKSIZE); if (status != FLASH_RETURN_SUCCESS) { chprintf(chp, "Reading returned %d\r\n", status); return; } for (j = 0; j < FLASH_BLOCKSIZE; j++) { chprintf(chp, "%02X ", readBufferBefore[j]); } chprintf(chp, "\r\n"); } } } else { flash_usage(chp); } }
void evalOpcode(unsigned char opcode) { int i; int16 opr1, opr2, opr3; unsigned int16 genPurpose = 0; if (opcode & 0b10000000) { genPurpose = gblMemPtr + 2; gblMemPtr = ((((unsigned int16)opcode & 0b00111111) << 8) + 2*fetchNextOpcode()); opr1 = fetchNextOpcode(); if (opcode & 0b01000000) { for (i = 0; i < (opr1 + 3); i++) { inputPop(); } } for (i = 0; i < opr1; i++) { inputPush (stkPop()); } inputPush (gblStkPtr); inputPush (genPurpose); inputPush(gblInputStkPtr - (opr1 + 2)); return; } switch (opcode) { case CODE_END: gblLogoIsRunning = 0; output_low (RUN_LED); // clear thes variables just in case. gblLoopAddress = 0; gblRepeatCount = 0; break; case NUM8: int8 Hi3 = fetchNextOpcode(); stkPush(Hi3); break; case NUM16: int8 Hi2 = fetchNextOpcode(); int8 Lo2 = fetchNextOpcode(); unsigned int16 teste4 = Hi2 << 8; teste4 += Lo2; stkPush (teste4); break; case LIST: stkPush(gblMemPtr + 2); //incremento de 2 em 2 gblMemPtr += (2 * fetchNextOpcode()); break; case EOL: genPurpose = stkPop(); if (genPurpose > gblMemPtr) { //printf(usb_cdc_putc,"genPurpose >>>> gblMemPtr"); gblMemPtr = genPurpose; } else { //printf(usb_cdc_putc,"genPurpose <<<< gblMemPtr"); gblMemPtr = genPurpose; gblRepeatCount = stkPop(); // repeat count //printf(usb_cdc_putc," gblRepeatCount %Lu \n",genPurpose); if (gblRepeatCount > 1) gblRepeatCount--; if (gblRepeatCount != 1) { stkPush (gblRepeatCount); stkPush (gblMemPtr); } } break; case EOLR: if (stkPop()) { // if condition is true stkPop(); // throw away the loop address gblMemPtr = stkPop(); // fetch the next command address } else { // if condition if false -> keep on looping. gblMemPtr = stkPop(); stkPush (gblMemPtr); delay_ms(5); // this prevents the waituntil loop to execute too rapidly // which has proven to cause some problems when reading sensor values. } break; case LTHING: genPurpose = 2 * fetchNextOpcode(); // index of the input variable opr1 = inputPop(); // base address in the input stack inputPush(opr1); // push the base address back to the stack. stkPush (gblInputStack[opr1 + genPurpose]); break; case STOP: case OUTPUT: if (opcode == OUTPUT){ genPurpose = stkPop(); // this is the output value } opr1 = inputPop(); // this is the proc-input stack base address gblMemPtr = inputPop(); // this is the return address opr2 = inputPop(); // this is the data stack index; // remove any remaining data that belongs to the current procedure from the data stack // Usually this is important for the STOP opcode. while (gblStkPtr > opr2){ stkPop(); } // remove the procedure inputs from the input stack while (gblInputStkPtr > opr1){ inputPop(); } // Output will push the output to the stack if (opcode == OUTPUT){ stkPush (genPurpose); } break; case REPEAT: gblLoopAddress = stkPop(); gblRepeatCount = stkPop(); // these will be poped by EOL stkPush (gblMemPtr); // address after repeat is complete if (gblRepeatCount > 1) { stkPush (gblRepeatCount); stkPush (gblLoopAddress); // address while still repeating gblMemPtr = gblLoopAddress; } else if (gblRepeatCount == 1) { gblMemPtr = gblLoopAddress; } else { // if loop count = 0 gblMemPtr = stkPop(); } break; case COND_IF: opr1 = stkPop(); // if true pointer address opr2 = stkPop(); // condition if (opr2) { stkPush(gblMemPtr); gblMemPtr = opr1; } break; case COND_IFELSE: opr1 = stkPop(); // if false pointer address opr2 = stkPop(); // if true pointer address opr3 = stkPop(); // condition stkPush(gblMemPtr); if (opr3) { gblMemPtr = opr2; } else { gblMemPtr = opr1; } break; case BEEP: beep(); break; case WAITUNTIL: gblLoopAddress = stkPop(); // these will be poped by EOLR stkPush(gblMemPtr); // address after repeat is complete stkPush (gblLoopAddress); // address while still repeating gblMemPtr = gblLoopAddress; break; case LOOP: gblLoopAddress = stkPop(); // the begining of loop gblRepeatCount = 0; // disable this counter (loop forever) stkPush(0); // this distinguishes LOOP from Repeat. (see EOL) stkPush(gblLoopAddress); // push loop address back into the stack // so that EOL will loop gblMemPtr = gblLoopAddress; break; case WAIT: gblWaitCounter = stkPop() * 4; break; case TIMER: stkPush(gblTimer); // gblTimer increases every 1ms. See in RTCC interrupt break; case RESETT: gblTimer = 0; break; case SEND: genPurpose = stkPop(); break; case IR: stkPush (gblMostRecentlyReceivedByte); gblNewByteHasArrivedFlag = 0; break; case NEWIR: stkPush (gblNewByteHasArrivedFlag); break; case RANDOM: stkPush (rand()); break; case OP_PLUS: case OP_MINUS: case OP_MULTIPLY: case OP_DIVISION: case OP_REMAINDER: case OP_EQUAL: case OP_GREATER: case OP_LESS: case OP_AND: case OP_OR: case OP_XOR: opr2=stkPop(); // second operand opr1=stkPop();// first operand switch (opcode) { case OP_PLUS: opr1+=opr2; break; case OP_MINUS: opr1-=opr2; break; case OP_MULTIPLY: opr1*=opr2; break; case OP_DIVISION: opr1/=opr2; break; case OP_REMAINDER: opr1%=opr2; break; case OP_EQUAL: opr1=(opr1==opr2); break; case OP_GREATER: opr1=(opr1>opr2); break; case OP_LESS: opr1=(opr1<opr2); break; case OP_AND: opr1=(opr1&&opr2); break; case OP_OR: opr1=(opr1||opr2); break; case OP_XOR: opr1=(opr1^opr2); break; }; stkPush(opr1); break; case OP_NOT: stkPush(!stkPop()); break; case SETGLOBAL: genPurpose = stkPop();// this is the value globalVariables[stkPop()] = genPurpose; break; case GETGLOBAL: stkPush(globalVariables[stkPop()]); break; case ASET: opr2 = stkPop();// this is the value to be stored opr1 = stkPop() * 2;// this is the array index. Each entry is two bytes wide. genPurpose = ARRAY_BASE_ADDRESS + stkPop();// this is the base address of the array. flashSetWordAddress(genPurpose + opr1); flashWrite(opr2); break; case AGET: opr1 = stkPop() * 2;// this is the array index. Each entry is two bytes wide. genPurpose = ARRAY_BASE_ADDRESS + stkPop();// this is the base address of the array. opr2 = read_program_eeprom(genPurpose + opr1); stkPush(opr2); break; case RECORD: genPurpose = stkPop(); // PCM parts (14 bit PICs like the 16F877) uses an external EEPROM for data Logging storage flashSetWordAddress(RECORD_BASE_ADDRESS + gblRecordPtr++); flashWrite(genPurpose); // save current record pointer location flashSetWordAddress(MEM_PTR_LOG_BASE_ADDRESS); flashWrite(gblRecordPtr); break; case RECALL: genPurpose = read_program_eeprom(RECORD_BASE_ADDRESS + gblRecordPtr++); stkPush(genPurpose); break; case RESETDP: gblRecordPtr = 0; break; case SETDP: gblRecordPtr = stkPop() * 2; break; case ERASE: opr1 = stkPop() * 2; for (genPurpose=0; genPurpose<opr1; genPurpose++) { flashSetWordAddress(RECORD_BASE_ADDRESS + genPurpose); flashWrite(0); } gblRecordPtr = 0; break; case OPC_MOTORS_OFF: motors_off(); break; case OPC_MOTORS_THATWAY: motors_that_way(); break; case OPC_MOTORS_THISWAY: motors_this_way(); break; case OPC_MOTORS_REVERT: motors_reverse(); break; case OPC_MOTORS_ON_FOR: case OPC_MOTORS_ON: motors_on(); if (opcode == OPC_MOTORS_ON_FOR) { set_on_for(stkPop()*4); } break; case OPC_MOTORS_POWER: motors_power(stkPop()); break; case OPC_MOTORS_ANGLE: motors_angle(stkPop()); break; case OPC_ACTIVATE_MOTORS: mtrsActive = stkPop(); break; case REALLY_STOP: start_stop_logo_machine = 1; break; case EB: stkPush(read_program_eeprom(stkPop())); break; case DB: opr1 = stkPop(); opr2 = stkPop(); flashSetWordAddress(opr2); flashWrite(opr1); break; case LOW_BYTE: stkPush(stkPop() & 0xff); break; case HIGH_BYTE: stkPush(stkPop() >> 8); break; case SENSOR1: case SENSOR2: case SENSOR3: case SENSOR4: case SENSOR5: case SENSOR6: case SENSOR7: case SENSOR8: if (opcode < SENSOR3) { i = opcode - SENSOR1; } else { i = opcode - SENSOR3 + 2; } stkPush(readSensor(i)); break; case SWITCH1: case SWITCH2: case SWITCH3: case SWITCH4: case SWITCH5: case SWITCH6: case SWITCH7: case SWITCH8: if (opcode < SWITCH3) { i = opcode - SWITCH1; } else { i = opcode - SWITCH3 + 2; } stkPush(readSensor(i)>>9); break; case ULED_ON: output_high(USER_LED); break; case ULED_OFF: output_low(USER_LED); break; case CL_I2C_START: i2c_start(); break; case CL_I2C_STOP: i2c_stop(); break; case CL_I2C_WRITE: i2c_write(stkPop()); break; case CL_I2C_READ: stkPush(i2c_read(stkPop())); break; default: start_stop_logo_machine = 1; break; }; }
GERR GD_FL_Goke_Write(U32 address, U16* data, U32 size) { U32 cnt; U16 rd; U32 i, timeout; GERR ferr; if (size == 0) return GD_OK; ferr = GD_OK; if ( (size == 1) || (thisManufacturerCode == MANUFACTURER_CODE_MACRONIX) || (thisManufacturerCode == MANUFACTURER_CODE_EXELSEMI) ) // slow programming just for security, maybe not necessary { for (i=0; (i<size) && (ferr==GD_OK); i++) { flashWriteCmd(CMD_PROGRAM, 0); flashWrite(address, data[i]); /* it must be ensured that this loop is not optimized away */ for (cnt = 0; cnt < delayLoops; cnt++) _ASM("nop"); /* wait until programming is finished */ ferr = GD_ERR_BAD_PARAMETER; timeout = TIMEOUT; while ( (ferr == GD_ERR_BAD_PARAMETER) && ((timeout--) > 0) ) { rd = flashRead(address); if ( (rd & DQ7) == (data[i] & DQ7) ) { ferr = GD_OK; } else if ( (rd & DQ5) == DQ5 ) { /* check DQ7 again according to flash device specification */ rd = flashRead(address); if ( (rd & DQ7) == (data[i] & DQ7) ) { ferr = GD_OK; } else { ferr = GD_ERR_FLASH_WRITE; } } } if (timeout == 0) { ferr = GD_ERR_TIMEOUT; } address++; } } else { /* enter fast mode */ flashWriteCmd(CMD_SET_FAST_MODE, 0); for (i=0; (i<size) && (ferr==GD_OK); i++) { flashWrite(address, CMD_PROGRAM); flashWrite(address, data[i]); /* it must be ensured that this loop is not optimized away */ for (cnt = 0; cnt < delayLoops; cnt++) _ASM("nop"); /* wait until programming is finished */ ferr = GD_ERR_BAD_PARAMETER; timeout = TIMEOUT; while ((ferr == GD_ERR_BAD_PARAMETER)&&((timeout--) > 0)) { rd = flashRead(address); if ( (rd & DQ7) == (data[i] & DQ7) ) { ferr = GD_OK; } else if ( (rd & DQ5) == DQ5 ) { rd = flashRead(address); if ( (rd & DQ7) == (data[i] & DQ7) ) { ferr = GD_OK; } else { ferr = GD_ERR_FLASH_WRITE; } } } if (timeout == 0) { ferr = GD_ERR_TIMEOUT; } address++; } /* reset fast programming mode */ address--; flashWrite(address, CMD_RESET_FAST_MODE_1); flashWrite(address, CMD_RESET_FAST_MODE_2); } return ferr; }