bool eeCopyModel(uint8_t dst, uint8_t src)
{
eeCheck(true);
uint32_t eepromWriteSourceAddr = eepromHeader.files[src+1].zoneIndex * EEPROM_ZONE_SIZE;
uint32_t eepromWriteDestinationAddr = eepromHeader.files[dst+1].zoneIndex * EEPROM_ZONE_SIZE;
// erase blocks
eepromEraseBlock(eepromWriteDestinationAddr);
eepromEraseBlock(eepromWriteDestinationAddr+EEPROM_BLOCK_SIZE);
// write model
for (int pos=0; pos<EEPROM_ZONE_SIZE; pos+=EEPROM_BUFFER_SIZE) {
eepromRead(eepromWriteSourceAddr+pos, eepromWriteBuffer, EEPROM_BUFFER_SIZE);
eepromWrite(eepromWriteDestinationAddr+pos, eepromWriteBuffer, EEPROM_BUFFER_SIZE);
}
// write FAT
eepromHeader.files[dst+1].exists = 1;
eepromIncFatAddr();
eepromWriteState = EEPROM_WRITE_NEW_FAT;
eepromWriteWait();
modelHeaders[dst] = modelHeaders[src];
return true;
}
u32 read32(const u32 address)
{
switch (address >> 24)
{
case 8:
case 9:
case 10:
case 11:
case 12:
return READ32LE(((u32 *)&rom[address&0x1FFFFFC]));
break;
case 13:
if (game.hasEEPROM())
return eepromRead(address);
break;
case 14:
if (game.hasSRAM())
return sramRead(address);
else if (game.hasFlash())
return flashRead(address);
break;
default:
break;
}
return 0;
}
u16 read16(const u32 address)
{
switch (address >> 24)
{
case 8:
case 9:
case 10:
case 11:
case 12:
if (rtcIsEnabled() && (address == 0x80000c4 || address == 0x80000c6 || address == 0x80000c8))
return rtcRead(address);
else
return READ16LE(((u16 *)&rom[address & 0x1FFFFFE]));
break;
case 13:
if (game.hasEEPROM())
return eepromRead(address);
break;
case 14:
if (game.hasSRAM())
return sramRead(address);
else if (game.hasFlash())
return flashRead(address);
break;
default:
break;
}
return 0;
}
/*--------------------------------------------*/
void SaveLoad_Class::loadLastPatchFromEEPROM()
{
// currentLoad = EEPROM.read(lastPatch_pos);
currentLoad = eepromRead(lastPatch_pos, false);
if(currentLoad > totalLoads) currentLoad = 1;
load(false);
utils->processAllFeatures();
}
/*--------------------------------------------*/
void SaveLoad_Class::loadCalibrateDpots()
{
for(int i=0; i<4; i++)
{
byte val = eepromRead(cvCalibrators_pos + i, false);
utils->writeCVDpot(i, val);
}
}
uint32_t oscAutosendInterval()
{
if (osc.autosendPeriod == 0) { // uninitialized
osc.autosendPeriod = eepromRead(EEPROM_OSC_ASYNC_INTERVAL);
if (osc.autosendPeriod < 1 || osc.autosendPeriod > OSC_AUTOSEND_MAX_INTERVAL)
osc.autosendPeriod = OSC_AUTOSEND_DEFAULT_INTERVAL;
}
return osc.autosendPeriod;
}
int oscUdpListenPort()
{
if (osc.udpListenPort == 0) { // uninitialized
osc.udpListenPort = eepromRead(EEPROM_OSC_UDP_LISTEN_PORT);
if (osc.udpListenPort < 0 || osc.udpListenPort > 65536)
osc.udpListenPort = OSC_UDP_DEFAULT_PORT;
}
return osc.udpListenPort;
}
int oscUdpReplyPort()
{
if (osc.udpReplyPort == 0) { // uninitialized
osc.udpReplyPort = eepromRead(EEPROM_OSC_UDP_SEND_PORT);
if (osc.udpReplyPort < 0 || osc.udpReplyPort > 65536)
osc.udpReplyPort = OSC_UDP_DEFAULT_PORT;
}
return osc.udpReplyPort;
}
/*--------------------------------------------*/
void SaveLoad_Class::loadUserButtons()
{
for(uint8_t i = 0; i < 4; i++)
{
// uint8_t val = EEPROM.read(userButtons_pos + i);
uint8_t val = eepromRead(userButtons_pos + i, false);
utils->setUserButtonVal(i, val);
// utils->setUserButtonVal(i, 1);
}
}
bool eepromOpen()
{
int32_t bestFatAddr = -1;
uint32_t bestFatIndex = 0;
eepromFatAddr = 0;
while (eepromFatAddr < EEPROM_ZONE_SIZE) {
eepromRead(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader.mark) + sizeof(eepromHeader.index));
if (eepromHeader.mark == EEPROM_MARK && eepromHeader.index >= bestFatIndex) {
bestFatAddr = eepromFatAddr;
}
eepromFatAddr += EEPROM_FAT_SIZE;
}
if (bestFatAddr >= 0) {
eepromFatAddr = bestFatAddr;
eepromRead(eepromFatAddr, (uint8_t *)&eepromHeader, sizeof(eepromHeader));
return true;
}
else {
return false;
}
}
uint32_t readFile(int index, uint8_t * data, uint32_t size)
{
if (eepromHeader.files[index].exists) {
EepromFileHeader header;
uint32_t address = eepromHeader.files[index].zoneIndex * EEPROM_ZONE_SIZE;
eepromRead(address, (uint8_t *)&header, sizeof(header));
if (size < header.size) {
header.size = size;
}
if (header.size > 0) {
eepromRead(address + sizeof(header), data, header.size);
size -= header.size;
}
if (size > 0) {
memset(data + header.size, 0, size);
}
return header.size;
}
else {
return 0;
}
}
uint16_t eeModelSize(uint8_t index)
{
uint16_t result = 0;
if (eepromHeader.files[index+1].exists) {
uint32_t address = eepromHeader.files[index+1].zoneIndex * EEPROM_ZONE_SIZE;
EepromFileHeader header;
eepromRead(address, (uint8_t *)&header, sizeof(header));
result = header.size;
}
return result;
}
//EEPROM section is 0x31
void instrCall_EEPROM(char instruction, char* data, char dataLength)
{
switch (instruction)
{
case EEPROM_WRITE:
{
eepromWrite(data, dataLength); //only writes the first byte
break;
}
case EEPROM_READ:
{
eepromRead(data);
break;
}
}
}
OscChannel oscAutosendDestination()
{
if (osc.autosendDestination == 0) { // uninitialized
osc.autosendDestination = eepromRead(EEPROM_OSC_ASYNC_DEST);
bool valid = false;
#ifdef MAKE_CTRL_USB
if (osc.autosendDestination == USB)
valid = true;
#endif
#ifdef MAKE_CTRL_NETWORK
if (osc.autosendDestination == UDP)
valid = true;
#endif
if (!valid)
osc.autosendDestination = NONE;
}
return osc.autosendDestination;
}
static void dIMUReadCalib(void) {
#ifdef DIMU_HAVE_EEPROM
uint8_t *buf;
int size;
int p1 = 0;
buf = eepromOpenRead();
if (buf == 0) {
AQ_NOTICE("DIMU: cannot read EEPROM parameters!\n");
}
else {
while ((size = eepromRead(DIMU_EEPROM_BLOCK_SIZE)) != 0)
p1 = configParseParams((char *)buf, size, p1);
AQ_NOTICE("DIMU: read calibration parameters from EEPROM\n");
}
#endif
}
u8 read8(const u32 address)
{
switch (address >> 24)
{
case 8:
case 9:
case 10:
case 11:
case 12:
return rom[address & 0x1FFFFFF];
break;
case 13:
if (game.hasEEPROM())
return eepromRead(address);
break;
case 14:
if (game.hasSRAM())
return sramRead(address);
else if (game.hasFlash())
return flashRead(address);
/*if (game.hasMotionSensor())
{
switch (address & 0x00008f00)
{
case 0x8200:
return systemGetSensorX() & 255;
case 0x8300:
return (systemGetSensorX() >> 8)|0x80;
case 0x8400:
return systemGetSensorY() & 255;
case 0x8500:
return systemGetSensorY() >> 8;
}
}*/
break;
default:
break;
}
return 0;
}
//Function to enter password or reset password
void enterVault()
{
char display[8];
pass[0] = 0x00;
pass[1] = 0x00;
pass[2] = 0x00;
if(buttonPressed(BTN_ROTARY)) //Section for entering password
{
UINT8 mem[3];
eepromRead(0x0000, 3, mem); //Read stored password from eeprom
int y;
y = 0;
lcdInstruction("j");
lcdString(" Enter Key ");
lcdInstruction("1;0H");
lcdString(" ");
sprintf(display, "%2.2X-%2.2X-%2.2X", pass[0], pass[1], pass[2]);
lcdString(display);
while(TRUE)
{
int x;
x = 0;
if(buttonPressed(BTN_ROTARY))
y++;
x = readRotaryKnob();
if(x != 0 || y == 3)
{
if(switchState(SWITCH_ROTARY))
x = x*8;
pass[y] += x;
lcdInstruction("j");
lcdString(" Enter Key ");
lcdInstruction("1;0H");
lcdString(" ");
sprintf(display, "%2.2X-%2.2X-%2.2X", pass[0], pass[1], pass[2]);
lcdString(display);
if(y == 3)
{
lcdInstruction("j");
if(mem[0] == pass[0] && mem[1] == pass[1] && mem[2] == pass[2]) //Compare passwords
{
lcdString(" Key Correct! ");
while(!secondTick());
while(!secondTick());
vault(); //If correct go to data editing function
break;
}
else
{
lcdString(" Key Incorrect! "); //If incorrect print message and break
while(!secondTick());
while(!secondTick());
break;
}
}
}
}
}
else if(buttonPressed(BTN3)) //Section for resetting password
{
char data[17] = "abcdefghijklmnop"; //Used to reset data on eeprom
int y;
y = 0;
lcdInstruction("j");
lcdString(" Reset Key ");
lcdInstruction("1;0H");
lcdString(" ");
sprintf(display, "%2.2X-%2.2X-%2.2X", pass[0], pass[1], pass[2]);
lcdString(display);
while(TRUE)
{
int x;
x = 0;
if(buttonPressed(BTN_ROTARY))
y++;
x = readRotaryKnob();
if(x != 0 || y == 3)
{
if(switchState(SWITCH_ROTARY))
x = x*8;
pass[y] += x;
lcdInstruction("j");
lcdString(" Reset Key ");
lcdInstruction("1;0H");
lcdString(" ");
sprintf(display, "%2.2X-%2.2X-%2.2X", pass[0], pass[1], pass[2]);
lcdString(display);
if(y == 3)
{
lcdInstruction("j");
lcdString(" Key Reset! ");
eepromWrite(0x0000, 3, pass); //store new password
while(!secondTick());
while(!secondTick());
while(!secondTick());
eepromWrite(0x0003, 16, data); //reset data
vault();
break;
}
}
}
}
}
const pm_char * eeBackupModel(uint8_t i_fileSrc)
{
char *buf = reusableBuffer.modelsel.mainname;
FIL archiveFile;
DIR archiveFolder;
UINT written;
eeCheck(true);
if (!sdMounted()) {
return STR_NO_SDCARD;
}
// check and create folder here
strcpy(buf, STR_MODELS_PATH);
FRESULT result = f_opendir(&archiveFolder, buf);
if (result != FR_OK) {
if (result == FR_NO_PATH)
result = f_mkdir(buf);
if (result != FR_OK)
return SDCARD_ERROR(result);
}
else {
f_closedir(&archiveFolder);
}
buf[sizeof(MODELS_PATH)-1] = '/';
strcpy(strcat_modelname(&buf[sizeof(MODELS_PATH)], i_fileSrc), STR_MODELS_EXT);
result = f_open(&archiveFile, buf, FA_CREATE_ALWAYS | FA_WRITE);
if (result != FR_OK) {
return SDCARD_ERROR(result);
}
#if defined(PCBSKY9X)
strcpy(statusLineMsg, PSTR("File "));
strcpy(statusLineMsg+5, &buf[sizeof(MODELS_PATH)]);
#endif
uint16_t size = eeModelSize(i_fileSrc);
*(uint32_t*)&buf[0] = O9X_FOURCC;
buf[4] = g_eeGeneral.version;
buf[5] = 'M';
*(uint16_t*)&buf[6] = size;
result = f_write(&archiveFile, buf, 8, &written);
if (result != FR_OK || written != 8) {
f_close(&archiveFile);
return SDCARD_ERROR(result);
}
uint32_t address = eepromHeader.files[i_fileSrc+1].zoneIndex * EEPROM_ZONE_SIZE + sizeof(EepromFileHeader);
while (size > 0) {
uint16_t blockSize = min<uint16_t>(size, EEPROM_BUFFER_SIZE);
eepromRead(address, eepromWriteBuffer, blockSize);
result = f_write(&archiveFile, eepromWriteBuffer, blockSize, &written);
if (result != FR_OK || written != blockSize) {
f_close(&archiveFile);
return SDCARD_ERROR(result);
}
size -= blockSize;
address += blockSize;
}
f_close(&archiveFile);
#if defined(PCBSKY9X)
showStatusLine();
#endif
return NULL;
}
//Function to store and edit user data
void vault()
{
char cursor[5]; //used to format cursor
UINT8 data[17]; //used to store the user data
while(!secondTick());
while(!secondTick());
eepromRead(0x0003, 16, data);
lcdInstruction("j");
lcdString(" Edit Data: ");
lcdInstruction("1;0H");
lcdString(data);
lcdInstruction("1;0H");
lcdInstruction("1c");
int y;
y = 0;
while(TRUE)
{
int x;
x = 0;
if(buttonPressed(BTN_ROTARY))
{
y++;
if(y == 16)
y = 0;
sprintf(cursor, "1;%dH", y);
lcdInstruction(cursor);
}
x = readRotaryKnob();
if(x != 0) //To edit data
{
if(switchState(SWITCH_ROTARY))
x = x*8;
data[y] += x;
if((int)data[y] >= 123)
{
int k;
k = (int)data[y] -123;// = k; 97;
data[y] = 97 + k;
}
if((int)data[y] <= 96)
{
int k;
k = 96 - (int)data[y];
data[y] = 122 - k;
}
lcdInstruction("j");
lcdString(" Edit Data: ");
lcdInstruction("1c");
lcdInstruction("1;0H");
lcdString(data);
sprintf(cursor, "1;%dH", y);
lcdInstruction(cursor);
}
if(buttonPressed(BTN1)) //To exit data entry
{
lcdInstruction("j");
lcdInstruction("0c");
lcdString(" Data Saved ");
eepromWrite(0x0003, 16, data);
button1 = TRUE;
while(!secondTick());
while(!secondTick());
break;
}
}
}
