public MachineCreateForm()
{
InitializeComponent();
foreach (var devType in DeviceTypeRegistry.GetRegisteredDeviceTypes(out string[] types))
{
var attr = devType.GetCustomAttribute <DeviceComponentAttribute>();
var icon = DeviceTypeRegistry.GetDeviceTypeIcon(devType.Name.ToLower());
icons.Images.Add(devType.Name.ToLower(), icon);
}
machineComp = Machine.CreateDevice <MachineComponent>();
eeprom = Machine.CreateDevice <EEPROM>();
scr = Machine.CreateDevice <Screen>();
gpu = Machine.CreateDevice <GPU>();
devices.Items.Add(new ListViewItem()
{
Text = machineComp.GetComponentAttribute().UserFriendlyName, Tag = machineComp, ImageKey = machineComp.GetType().Name.ToLower()
});
devices.Items.Add(new ListViewItem()
{
Text = eeprom.GetComponentAttribute().UserFriendlyName, Tag = eeprom, ImageKey = eeprom.GetType().Name.ToLower()
});
devices.Items.Add(new ListViewItem()
{
Text = scr.GetComponentAttribute().UserFriendlyName, Tag = scr, ImageKey = scr.GetType().Name.ToLower()
});
devices.Items.Add(new ListViewItem()
{
Text = gpu.GetComponentAttribute().UserFriendlyName, Tag = gpu, ImageKey = gpu.GetType().Name.ToLower()
});
}
/// <summary>
/// Writes data to the EEPROM
/// </summary>
/// <param name="address">The EEPROM address</param>
/// <param name="data">The data to write</param>
/// <returns>Total amount of data transferred</returns>
private int writeEEPROM(EEPROM address, byte[] data)
{
byte[] wrtieBuffer = new byte[data.Length + 1];
wrtieBuffer[0] = (byte)(0x40 | (int)address);
Array.Copy(data, 0, wrtieBuffer, 1, data.Length);
return(write(wrtieBuffer));
}
public override double ReadDmiVcc()
{
lock (syncRoot)
{
return(EEPROM.readdmivcc(TestPlanParaByPN.DUT_USB_Port, 0xA0, 26));
}
}
public byte[] WriteDriverSFP(int deviceIndex, int deviceAddress, int StartAddress, int regAddress, byte Length, byte chipset, int dataToWrite, bool LittleEndian)
{
lock (syncRoot)
{
byte[] ReturnArray = new byte[1];
try
{
byte[] WriteDacByteArray;
if (chipset == 4)
{
WriteDacByteArray = Algorithm.ObjectTOByteArray(dataToWrite, 2, LittleEndian);
EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress, 0x02, chipset, WriteDacByteArray);
}
else
{
WriteDacByteArray = Algorithm.ObjectTOByteArray(dataToWrite, Length, LittleEndian);
for (int i = Length - 1; i > -1; i--)
{
byte[] WriteData = Algorithm.ObjectTOByteArray(WriteDacByteArray[i], 2, LittleEndian);
EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress + i, 0x02, chipset, WriteData);
}
}
ReturnArray[0] = 0xAA;
return(ReturnArray);
}
catch
{
return(ReturnArray);
}
}
}
public override double ReadDmiTemp()
{
lock (syncRoot)
{
return(EEPROM.readdmitemp(TestPlanParaByPN.DUT_USB_Port, 0xA0, 22));
}
}
private void EEPROMClassRead(EEPROM e)
{
pixelHoriNum = e.activePixelsHoriz;
pixelVertNum = e.activePixelsVert;
for (int i = 0; i < e.badPixels.Length; i++)
{
if (e.badPixels[i] >= 0)
{
dataGridViewBadPixel.Rows[i].Cells[0].Value = i;
dataGridViewBadPixel.Rows[i].Cells[1].Value = e.badPixels[i];
}
}
wavelength = wavenum=ramanShift=new double[pixelHoriNum];
wavelength = s.wavelengths;
String[] elements = (s.model).Split('-');
foreach (string item in elements)
{
if (float.TryParse(item, out centralWavelength))
break;
}
wavenum = Util.wavelengthsToWavenumbers(centralWavelength,wavelength);
for (int i = 0; i < wavelength.Length; i++)
{
ramanShift[i] = (1 / centralWavelength - 1 / wavelength[i]) * 10000000;
}
serialNumber = e.serialNumber;
maxIntegrationTimeMS = e.maxIntegrationTimeMS;
numericUpDownIntegrationTime.Maximum = maxIntegrationTimeMS;
minIntegrationTimeMS = e.minIntegrationTimeMS;
numericUpDownIntegrationTime.Minimum = minIntegrationTimeMS;
numericUpDownIntegrationTime.Value = minIntegrationTimeMS;
IfHasLaser(s.hasLaser);
}
public byte[] StoreDriverSFP_old(int deviceIndex, int deviceAddress, int StartAddress, int regAddress, int Length, byte chipset, byte[] dataToWrite)
{
lock (syncRoot)
{
byte[] ReturnArray = new byte[1];
try
{
for (int i = 0; i < Length; i++)
{
byte[] WriteDacByteArray = Algorithm.ObjectTOByteArray(dataToWrite[i], DriverStruct[i].Length, DriverStruct[i].Endianness);
EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress, 0x06, chipset, dataToWrite);
}
ReturnArray[0] = 0xAA;
return(ReturnArray);
}
catch
{
return(ReturnArray);
}
}
// return EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress, 0x06, chipset, dataToWrite);
}
private void SyncState(Serializer ser)
{
byte[] core = null;
if (ser.IsWriter)
{
var ms = new MemoryStream();
ms.Close();
core = ms.ToArray();
}
Cpu.SyncState(ser);
ser.BeginSection("SMS");
Vdp.SyncState(ser);
PSG.SyncState(ser);
ser.Sync("RAM", ref SystemRam, false);
ser.Sync("RomBank0", ref RomBank0);
ser.Sync("RomBank1", ref RomBank1);
ser.Sync("RomBank2", ref RomBank2);
ser.Sync("RomBank3", ref RomBank3);
ser.Sync("Port01", ref Port01);
ser.Sync("Port02", ref Port02);
ser.Sync("Port3E", ref Port3E);
ser.Sync("Port3F", ref Port3F);
ser.Sync("Paddle1High", ref Paddle1High);
ser.Sync("Paddle2High", ref Paddle2High);
ser.Sync("LatchLightPhaser", ref LatchLightPhaser);
if (SaveRAM != null)
{
ser.Sync("SaveRAM", ref SaveRAM, false);
ser.Sync("SaveRamBank", ref SaveRamBank);
}
if (ExtRam != null)
{
ser.Sync("ExtRAM", ref ExtRam, true);
}
if (HasYM2413)
{
YM2413.SyncState(ser);
}
if (EEPROM != null)
{
EEPROM.SyncState(ser);
}
ser.Sync("Frame", ref _frame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("IsLag", ref _isLag);
ser.EndSection();
if (ser.IsReader)
{
SyncAllByteArrayDomains();
}
}
/// <summary>
/// Reads a segment of the EEPROM
/// </summary>
/// <param name="address">The EEPROM address</param>
/// <param name="readBuffer">The buffer to read the data into (almost always 3 bytes in length)</param>
/// <returns>The data read from the EEPROM</returns>
public byte[] readEEPROM(EEPROM address, byte[] readBuffer)
{
write(new byte[] { (byte)address, 0x00, 0x00 });
Thread.Sleep(5);
read(readBuffer);
_status = readBuffer[0] >> 6;
_EEPROM_Response = readBuffer[0] & 0x3;
_EEPROM_daignostic = (readBuffer[0] >> 2) & 0x15;
return(readBuffer);
}
public override string ReadFW()
{
lock (syncRoot)
{
string fwrev = "";
EnterEngMode(4);
fwrev = EEPROM.ReadFWRev(TestPlanParaByPN.DUT_USB_Port, 0xA0, 128);
return(fwrev.ToUpper());
}
}
public override string ReadSN()
{
lock (syncRoot)
{
string SN = "";
EnterEngMode(0);
SN = EEPROM.ReadSn(TestPlanParaByPN.DUT_USB_Port, 0xA0, 196);
return(SN.Trim());
}
}
public EEPROM_UC()
{
InitializeComponent();
eepromFields = new Dictionary <string, object>();
version = EEPROM_Version.GetInstance();
version.ReadEEPROMVersion();
MessageBox.Show(Encoding.UTF8.GetString(version.EEPROM_Version_Number.value));
_eeprom = EEPROM.GetInstance();
//DisplayEEPROM();
}
public static EEPROM Create()
{
EEPROM result = new EEPROM();
result.Metadata = Metadata.Create();
result.Settings = Settings.Create();
result.Profiles = new Profile[PROFILES_COUNT];
for (int i = 0; i < PROFILES_COUNT; i++) result.Profiles[i] = Profile.Create();
result.Months = new Month[MONTHS_COUNT];
for (int i = 0; i < MONTHS_COUNT; i++) result.Months[i] = Month.Create();
return result;
}
private void SpectrometerClassRead(Spectrometer s)
{
tecStatus = s.detectorTECEnabled;
double detectorTECSetpointDegC = s.detectorTECSetpointDegC;
if (!s.hasLaser)
{
laserStatus = false;
}
else
excitationWavelengthNM = s.excitationWavelengthNM;
integrationTimeMS = s.integrationTimeMS;
eEPROM = s.eeprom;
}
public SpectrometerSettingsView()
{
InitializeComponent();
viewableSettingsEEPROM = new ObservableCollection <ViewableSetting>();
EEPROM eeprom = EEPROM.getInstance();
if (eeprom != null)
{
eeprom.viewableSettings = viewableSettingsEEPROM;
}
listViewEEPROM.ItemsSource = viewableSettingsEEPROM;
ssvm = (SpectrometerSettingsViewModel)BindingContext;
}
public override ushort ReadADC(NameOfADC enumName, int channel)
{
lock (syncRoot)
{
try
{
string name = enumName.ToString();
DUTCoeffControlByPN.CoeffInfo coeffInfo = dataTable_DUTCoeffControlByPN.GetOneInfoFromTable(name, channel);
EnterEngMode(coeffInfo.Page);
UInt16 valueADC = EEPROM.readadc(TestPlanParaByPN.DUT_USB_Port, 0xA0, coeffInfo.StartAddress);
Log.SaveLogToTxt("Current TXPOWERADC is " + valueADC);
return(valueADC);
}
catch (Exception ex)
{
Log.SaveLogToTxt(ex.ToString());
return(Algorithm.MyNaN);
}
}
}
public XboxEEPROM(byte[] pbEEPROM)
{
if (Equals(null, pbEEPROM) || pbEEPROM.Length != EEPROM_SIZE)
{
IsValid = false;
return;
}
//bring data into struct
e = (EEPROM)ToStruct(pbEEPROM, typeof(EEPROM));
//validate factory settings
byte[] buffer = new byte[0x2C];
Array.Copy(e.SerialNumber, 0, buffer, 0, 0xC);
Array.Copy(e.MAC_Address, 0, buffer, 0xC, 0x6);
Array.Copy(e.Unk_1, 0, buffer, 0x12, 0x2);
Array.Copy(e.OnlineKey, 0, buffer, 0x14, 0x10);
Array.Copy(e.VideoStandard, 0, buffer, 0x24, 0x4);
Array.Copy(e.Unk_2, 0, buffer, 0x28, 0x2);
byte[] result;
CRC(out result, buffer, 0x2C);
if (!CompareTo(e.CRC_MFR_Data, result)) //invalid factory settings CRC - should never happen unless bad eeprom image
{
IsValid = false;
return;
}
//validate user settings
CRC(out result, e.User_Data, 0x9C);
//invalid user settings CRC - could happen if suddenly lost power during writing settings, in this case the crc would be set to 0xFFFFFFFF and user data zeroed to reset settings
if (!CompareTo(e.CRC_User_Data, result))
{
IsValid = false;
return;
}
IsValid = true;
}
public override string GetCoeff(Coeff coeff, int channel)
{
lock (syncRoot)
{
string coeffName = coeff.ToString();
try
{
DUTCoeffControlByPN.CoeffInfo coeffInfo = dataTable_DUTCoeffControlByPN.GetOneInfoFromTable(coeffName, channel);
EnterEngMode(coeffInfo.Page);
string value = EEPROM.ReadCoef(TestPlanParaByPN.DUT_USB_Port, 0xA0, coeffInfo.StartAddress, coeffInfo.Format);
Log.SaveLogToTxt("Get " + coeffName + " is " + value);
return(value);
}
catch
{
Log.SaveLogToTxt("Failed to get value of " + coeffName);
return(Algorithm.MyNaN.ToString());
}
}
}
public int ReadDriverSFP(int deviceIndex, int deviceAddress, int StartAddress, int regAddress, byte Length, byte chipset)// 有问题,但是需要确认,默认写长度为2符合FW接口协议 Leo 2016-10-25
{
lock (syncRoot)
{
int[] ReturnArray = new int[Length];
int ReadData = 0;
try
{
if (chipset == 4)
{
byte[] ReadArray = EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress, 0x01, chipset, new byte[2]);
ReadData = ReadArray[0] * 256 + ReadArray[1];
}
else
{
for (int i = 0; i < Length; i++)
{
byte[] ReadArray = EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress + i, 0x01, chipset, new byte[2]);
ReturnArray[i] = ReadArray[0] * 256 + ReadArray[1];
}
for (int i = Length - 1; i > -1; i--)
{
ReadData += Convert.ToInt16(ReturnArray[i] * Math.Pow(256, Length - 1 - i));
}
}
return(ReadData);
}
catch
{
return(ReadData);
}
}
// return EEPROM.ReadWriteDriverSFP(DUT.deviceIndex, deviceAddress, StartAddress, regAddress, 0x01, chipset, new byte[2]);
}
public override bool SetCoeff(Coeff coeff, int channel, string value)
{
lock (syncRoot)
{
try
{
string coeffName = coeff.ToString();
DUTCoeffControlByPN.CoeffInfo coeffInfo = dataTable_DUTCoeffControlByPN.GetOneInfoFromTable(coeffName, channel);
EnterEngMode(coeffInfo.Page);
bool result = EEPROM.SetCoef(TestPlanParaByPN.DUT_USB_Port, 0xA0, coeffInfo.StartAddress, value, coeffInfo.Format);
Log.SaveLogToTxt("Set " + coeffName + " to " + value);
return(result);
}
catch (Exception ex)
{
Log.SaveLogToTxt(ex.ToString());
return(false);
}
}
}
public void writeToEEPROMTest()
{
int AN_ADRESS = 10;
int AN_INTEGER = 123;
//ARRANGE
var memoryMock = new Mock <IMemory>();
memoryMock.Setup(p => p.getFile(0x09)).Returns(AN_ADRESS);
memoryMock.Setup(p => p.getFile(0x08)).Returns(AN_INTEGER);
var classUnderTest = new EEPROM();
classUnderTest.init(memoryMock.Object);
classUnderTest.setStateMachineTriggered();
//ACT
classUnderTest.writeToEEPROM();
//ASSERT
Assert.AreEqual(AN_INTEGER, classUnderTest.getEeprom()[AN_ADRESS]);
}
public override double ReadDmiRxP(int channel)
{
lock (syncRoot)
{
try
{
double dmirxp = 0.0;
switch (channel)
{
case 1:
dmirxp = EEPROM.readdmirxp(TestPlanParaByPN.DUT_USB_Port, 0xA0, 34);
break;
case 2:
dmirxp = EEPROM.readdmirxp(TestPlanParaByPN.DUT_USB_Port, 0xA0, 36);
break;
case 3:
dmirxp = EEPROM.readdmirxp(TestPlanParaByPN.DUT_USB_Port, 0xA0, 38);
break;
case 4:
dmirxp = EEPROM.readdmirxp(TestPlanParaByPN.DUT_USB_Port, 0xA0, 40);
break;
default:
break;
}
return(dmirxp);
}
catch (Exception ex)
{
Log.SaveLogToTxt(ex.ToString());
return(Algorithm.MyNaN);
}
}
}
private void BtnWriteRom_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(tbUidH.Text) || string.IsNullOrEmpty(tbUidL.Text))
{
MessageBox.Show("UIDの設定が適切ではありません。", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
var role = (byte)(Enum.Parse(typeof(FlocRole), comboRole.SelectedItem.ToString()));
var mode = (byte)(Enum.Parse(typeof(FlocMode), comboMode.SelectedItem.ToString()));
var uid_h = Convert.ToByte(tbUidH.Text, 16);
var uid_l = Convert.ToByte(tbUidL.Text, 16);
var msg = "この情報を登録します。よろしいですか？\n";
msg += "Role: " + comboRole.SelectedItem.ToString() + "\n";
msg += $"UID: {uid_h:X2}.{uid_l:X2}\n";
msg += "Mode: " + comboMode.SelectedItem.ToString();
var ret = MessageBox.Show(msg, this.Text, MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (ret == DialogResult.Yes)
{
var rom = new EEPROM();
rom.Set(0x01, role, uid_h, uid_l, mode);
try
{
m_cmdBlock.WriteRom(m_avrdude, rom);
MessageBox.Show("EEPROMへの書き込みに成功しました。", this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), this.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
private void SyncState(Serializer ser)
{
byte[] core = null;
if (ser.IsWriter)
{
using var ms = new MemoryStream();
ms.Close();
core = ms.ToArray();
}
ser.BeginSection(nameof(SMS));
Cpu.SyncState(ser);
Vdp.SyncState(ser);
PSG.SyncState(ser);
ser.Sync("RAM", ref SystemRam, false);
ser.Sync(nameof(RomBank0), ref RomBank0);
ser.Sync(nameof(RomBank1), ref RomBank1);
ser.Sync(nameof(RomBank2), ref RomBank2);
ser.Sync(nameof(RomBank3), ref RomBank3);
ser.Sync(nameof(Bios_bank), ref Bios_bank);
ser.Sync(nameof(Port01), ref Port01);
ser.Sync(nameof(Port02), ref Port02);
ser.Sync(nameof(Port03), ref Port03);
ser.Sync(nameof(Port04), ref Port04);
ser.Sync(nameof(Port05), ref Port05);
ser.Sync(nameof(Port3E), ref Port3E);
ser.Sync(nameof(Port3F), ref Port3F);
ser.Sync(nameof(Controller1SelectHigh), ref Controller1SelectHigh);
ser.Sync(nameof(Controller2SelectHigh), ref Controller2SelectHigh);
ser.Sync(nameof(LatchLightPhaser), ref LatchLightPhaser);
ser.Sync(nameof(start_pressed), ref start_pressed);
ser.Sync(nameof(cntr_rd_0), ref cntr_rd_0);
ser.Sync(nameof(cntr_rd_1), ref cntr_rd_1);
ser.Sync(nameof(cntr_rd_2), ref cntr_rd_2);
ser.Sync(nameof(p3_write), ref p3_write);
ser.Sync(nameof(p4_read), ref p4_read);
ser.Sync(nameof(stand_alone), ref stand_alone);
ser.Sync(nameof(disablePSG), ref disablePSG);
ser.Sync(nameof(sampleclock), ref sampleclock);
ser.Sync(nameof(old_s_L), ref old_s_L);
ser.Sync(nameof(old_s_R), ref old_s_R);
if (SaveRAM != null)
{
ser.Sync(nameof(SaveRAM), ref SaveRAM, false);
}
ser.Sync(nameof(SaveRamBank), ref SaveRamBank);
if (ExtRam != null)
{
ser.Sync("ExtRAM", ref ExtRam, true);
}
if (HasYM2413)
{
YM2413.SyncState(ser);
}
EEPROM?.SyncState(ser);
ser.Sync("Frame", ref _frame);
ser.Sync("LagCount", ref _lagCount);
ser.Sync("IsLag", ref _isLag);
ser.EndSection();
if (ser.IsReader)
{
SyncAllByteArrayDomains();
}
}
private static byte[] StoreDriver40g(int deviceIndex, int deviceAddress, int StartAddress, int regAddress, byte channel, byte chipset, byte[] dataToWrite, bool Switch)
{
return(EEPROM.ReadWriteDriverQSFP(deviceIndex, deviceAddress, StartAddress, regAddress, channel, 0x06, chipset, dataToWrite, Switch));
}
private static byte[] ReadDriver40g(int deviceIndex, int deviceAddress, int StartAddress, int regAddress, byte channel, byte chipset, int readLength, bool Switch)
{
return(EEPROM.ReadWriteDriverQSFP(deviceIndex, deviceAddress, StartAddress, regAddress, channel, 0x01, chipset, new byte[readLength], Switch));
}
public static EEPROM Parse(byte[] EEPROMData, byte[] XboxEEPROMKey)
{
if (EEPROMData == null || EEPROMData.Length != 256)
{
throw new Exception("Invalid EEPROM data");
}
byte[] EncryptedData = new byte[256];
byte[] DecryptedData = new byte[256];
Array.Copy(EEPROMData, 0, EncryptedData, 0, 256); //make a copy of the encrypted (original) EEPROM data
//create RC4 key from current XboxEEPROMKey and EncryptedSettings checksum
byte[] RC4Key;
XcHMAC(XboxEEPROMKey, EEPROMData, 0, 0x14, null, 0, 0, out RC4Key);
//decrypt EncryptedSection
RC4(EEPROMData, 0x14, 0x1C, RC4Key);
//create hash of the EncryptedSettings section that was decrypted
byte[] EncryptedSectionChecksum;
XcHMAC(XboxEEPROMKey, EEPROMData, 0x14, 0x1C, null, 0, 0, out EncryptedSectionChecksum);
//compare hash to the EncryptedSettings checksum
if (!Compare(EEPROMData, 0, EncryptedSectionChecksum, 0, 0x14))
{
throw new Exception("Failed to decrypt EEPROM");
}
Array.Copy(EEPROMData, 0, DecryptedData, 0, 256); //make a copy of the decrypted EEPROM data
try
{
//start pulling data out
EEPROM EEPROM = new EEPROM();
using (BinaryReader stream = new BinaryReader(new MemoryStream(EEPROMData)))
{
//EncryptedSettings
EEPROM.EncryptedSettings = new EncryptedSection
{
Checksum = stream.ReadBytes(0x14),
Confounder = stream.ReadBytes(8),
XboxHDKey = stream.ReadBytes(0x10),
GameRegion = stream.ReadUInt32()
};
//FactorySettings
EEPROM.FactorySettings = new FactorySection
{
Checksum = stream.ReadUInt32(),
SerialNumber = stream.ReadChars(0xC),
MACAddress = stream.ReadBytes(6),
Reserved1 = stream.ReadBytes(2),
OnlineKey = stream.ReadBytes(0x10),
VideoRegion = stream.ReadUInt32(),
Reserved2 = stream.ReadBytes(4)
};
//UserSettings
EEPROM.UserSettings = new UserConfigSection
{
Checksum = stream.ReadUInt32(),
TimeZoneBias = stream.ReadInt32(),
TimeZoneStdName = stream.ReadChars(4),
TimeZoneDltName = stream.ReadChars(4),
Reserved1 = stream.ReadBytes(8),
TimeZoneStdDate = new TimeZoneDate()
{
Month = stream.ReadByte(),
Day = stream.ReadByte(),
DayOfWeek = stream.ReadByte(),
Hour = stream.ReadByte()
},
TimeZoneDltDate = new TimeZoneDate()
{
Month = stream.ReadByte(),
Day = stream.ReadByte(),
DayOfWeek = stream.ReadByte(),
Hour = stream.ReadByte()
},
Reserved2 = stream.ReadBytes(8),
TimeZoneStdBias = stream.ReadInt32(),
TimeZoneDltBias = stream.ReadInt32(),
Language = stream.ReadUInt32(),
VideoFlags = stream.ReadUInt32(),
AudioFlags = stream.ReadUInt32(),
ParentalControlGames = stream.ReadUInt32(),
ParentalControlPassword = stream.ReadUInt32(),
ParentalControlMovies = stream.ReadUInt32(),
OnlineIpAddress = stream.ReadBytes(4),
OnlineDnsAddress = stream.ReadBytes(4),
OnlineDefaultGatewayAddress = stream.ReadBytes(4),
OnlineSubnetMask = stream.ReadBytes(4),
MiscFlags = stream.ReadUInt32(),
DvdRegion = stream.ReadUInt32()
};
//HardwareConfiguration
EEPROM.HardwareConfiguration = new HardwareConfigSection
{
FbioDelay = stream.ReadByte(),
AddrDrv = stream.ReadByte(),
CTrim2 = stream.ReadByte(),
EMRS = stream.ReadByte(),
ExtSlow = stream.ReadBytes(10),
Slow = stream.ReadBytes(10),
Typical = stream.ReadBytes(10),
Fast = stream.ReadBytes(10),
ExtFast = stream.ReadBytes(10)
};
//unsectioned/extended data
EEPROM.ThermalSensorCalibration = stream.ReadUInt16();
EEPROM.Unused = stream.ReadBytes(2);
EEPROM.UEMInfo = new UEMInformation()
{
LastCode = stream.ReadByte(),
Reserved1 = stream.ReadByte(),
History = stream.ReadUInt16()
};
EEPROM.Reserved1 = stream.ReadBytes(2);
}
//store encryption key
EEPROM.XboxEEPROMKey = XboxEEPROMKey;
//store copies of encrypted/decrypted EEPROM data
EEPROM.EncryptedEEPROM = EncryptedData;
EEPROM.DecryptedEEPROM = DecryptedData;
return(EEPROM);
}
catch
{
throw new Exception("Failed to parse EEPROM data");
}
}
public LCDChip(XmlNode settings)
{
XmlNode chip = settings["Chip"];
this.link = Link.CreateLink(chip["Link"].InnerText);
this.link.ByteRecieved += this.ProccessByte;
this.eeprom = new EEPROM(chip["EEPROM"].InnerText);
this.lcd = new LCDDisplay(settings["Display"], this);
this.lcd.FormClosed += FormClosed;
this.t = new Timer(this.TurnOffDisplay);
this.lcd.Clear();
this.DCB_state = (DCB)this.eeprom.ReadByte(EEP_DISPLAY);
this.lcd.Display = this.DCB_state.Has(DCB.Display);
this.lcd.Blink = this.DCB_state.Has(DCB.Blink);
this.lcd.ShowCursor = this.DCB_state.Has(DCB.Cursor);
SetTimeout(this.onFor = this.eeprom.ReadByte(EEP_DISPLAY_MIN));
this.lcd.Backlight = this.eeprom.ReadByte(EEP_BACKLIGHT);
this.lcd.Contrast = this.eeprom.ReadByte(EEP_CONTRAST);
for (int i = 0; i < EEP_GPO.Length; ++i)
{
this.gpo[i] = this.eeprom.ReadByte(EEP_GPO[i]) > 0;
this.gpo_val[i] = this.eeprom.ReadByte(EEP_GPO_PWM[i]);
this.RefreshGPO(i);
}
for (int i = 0; i < EEP_CHAR.Length; ++i) { this.lcd.SetCustomChar(i, this.eeprom.ReadBytes(EEP_CHAR[i], 8)); }
for (int i = 0; i < EEP_LINE.Length; ++i) { this.lcd.Goto(1, (byte)(i + 1)); this.lcd.Write(this.eeprom.ReadBytes(EEP_LINE[i], LINE_LEN)); }
System.Windows.Forms.Application.Run(this.lcd);
}
public WriteEEPROMForm(EEPROM mc)
{
InitializeComponent();
config = mc;
load();
}
