pgmfi.org

Hacking up Honda's ECU
It is currently Mon Mar 30, 2020 12:08 pm

All times are UTC - 5 hours [ DST ]





Post new topic Reply to topic  [ 2 posts ] 
Author Message
PostPosted: Wed Mar 04, 2020 8:39 pm 
Offline

Joined: Wed Apr 27, 2011 2:30 am
Posts: 11
Thought id share this little .net core app that lets you simulate with software a couple different emulators.
Makes it easy to debug if your writing a program that interfaces with them,
PS iv removed the encrypted transfere functions since that could be used to rip bins from certain programs.

Code:
using System;
using System.IO;
using System.IO.Ports;
using System.Text;
using System.Threading;
namespace EmulatorSimulator
{
    class Program
    {
        public static string Header = @"
        ███████╗███╗   ███╗██╗   ██╗███████╗██╗███╗   ███╗
        ██╔════╝████╗ ████║██║   ██║██╔════╝██║████╗ ████║
        █████╗  ██╔████╔██║██║   ██║███████╗██║██╔████╔██║
        ██╔══╝  ██║╚██╔╝██║██║   ██║╚════██║██║██║╚██╔╝██║
        ███████╗██║ ╚═╝ ██║╚██████╔╝███████║██║██║ ╚═╝ ██║
        ╚══════╝╚═╝     ╚═╝ ╚═════╝ ╚══════╝╚═╝╚═╝     ╚═╝
        BMGJET 2020" + "\n"; //Header image
        public static string HS = " Emulator Simulator 0.1\n\n"; //Header string
        public static string FS = "\n(Enter The Number To Select Option)"; //Help tip.
        public static bool NoDelay = false;
        private static SerialPort serialPort_0;
        public static byte Protocol;
        public static byte[] Bin;
        public static byte[] Version;
        public static int TimeOut = 60;
        public static string BinFile;
        public static byte[] OK = new byte[] { 0x4F };
        public static byte[] Serial = new byte[] { 0x04, 0x01, 0x02, 0x08, 0x08, 0x01, 0x04, 0x05, 0x06, 0x07  };
        public static byte[] EEPROM = new byte[] { 0x42, 0x4d, 0x47, 0x4a, 0x45, 0x54, 0x20, 0x32, 0x30, 0x32, 0x30 };
        //███████╗██╗   ██╗███╗   ██╗ ██████╗████████╗██╗ ██████╗ ███╗   ██╗███████╗
        //██╔════╝██║   ██║████╗  ██║██╔════╝╚══██╔══╝██║██╔═══██╗████╗  ██║██╔════╝
        //█████╗  ██║   ██║██╔██╗ ██║██║        ██║   ██║██║   ██║██╔██╗ ██║███████╗
        //██╔══╝  ██║   ██║██║╚██╗██║██║        ██║   ██║██║   ██║██║╚██╗██║╚════██║
        //██║     ╚██████╔╝██║ ╚████║╚██████╗   ██║   ██║╚██████╔╝██║ ╚████║███████║
        //╚═╝      ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝   ╚═╝   ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚══════╝

        static bool LoadBin()
        {
            //Loads bin that was dragged onto application.
            try
            {
                byte[] file = System.IO.File.ReadAllBytes(BinFile);
                if (file.Length == 32768L)
                {
                    Bin = new byte[32768]; //Sets byte array size 32K
                    Bin = file;
                    Console.WriteLine("Loaded 32K");
                    return true;
                }
                else if (file.Length == 65536L)
                {
                    Bin = new byte[65536]; //Sets byte array size 64K
                    Bin = file;
                    Console.WriteLine("Loaded 64K");
                    return true;
                }

                return false; //Unsupported size fail.
            }
            catch
            {
                return false; //Something had issue fail.
            }
        }

        public static void SetNoDelay() //Disables delay that emulates bluetooth speed.
        {
            NoDelay = !NoDelay;
            Console.WriteLine("No Delay Mode: "+ NoDelay);
        }

        static byte Setup()
        {
            //Define what protocol to use.
            int P = 0;
            Console.WriteLine("\nWhat Protocol To Emulate: \n(1) Moates Ostrich 1.0\n(2) Moates Ostrich 2.0\n(3) CobraRTP\n(4) ECUTamer\n(0) Moates Demon(WIP)" + FS);
            FS = "";
            int.TryParse(Console.ReadLine(), out P);
            switch (P)  //Switch version array for what emulator your using.
            {
                case 0:
                    Console.WriteLine("Protocol: Moates Demon");
                    Version = new byte[] { 0x01, 0x09, 0x44 };
                    break;
                case 1:
                    Console.WriteLine("Protocol: Moates Ostrich 1.0");
                    Version = new byte[] { 0x10, 0x07, 0x4F };
                    break;
                case 2:
                    Console.WriteLine("Protocol: Moates Ostrich 2.0");
                    Version = new byte[] { 0x14, 0x09, 0x4F };
                    break;
                case 3:
                    Console.WriteLine("Protocol: CobraRTP");
                    Version = new byte[] { 0x14, 0x18, 0x43 };
                    break;
                default:
                    Console.WriteLine("Protocol: ECUTamer");
                    Version = new byte[] { 0x01, 0x28, 0x4F };
                    break;
            }
            try
            {
                Console.WriteLine("\nSelect Port:");
                //Builds list of avaliable COMPorts
                foreach (string s in SerialPort.GetPortNames())
                {
                    Console.WriteLine(s);
                }
            }
            catch { Console.WriteLine("No Avaliable ComPorts"); }

            //Read back COMPORT selection.
            bool NC = true;
            while (NC)
            {
                string CP = Console.ReadLine().ToUpper();
                if (CP.Contains("COM"))
                {
                    serialPort_0 = new SerialPort();
                    //Setup Baud rate
                    Console.WriteLine("\nWhat Baud Rate:\n(1) 115.2K\n(2) 921.6K");
                    int B = 1;
                    int.TryParse(Console.ReadLine(), out B);
                    if (B == 2)
                    {
                        serialPort_0.BaudRate = 921600;
                    }
                    else
                    {
                        serialPort_0.BaudRate = 115200;
                    }
                    serialPort_0.ReadBufferSize = 64000;
                    serialPort_0.PortName = CP;
                    serialPort_0.DataReceived += new SerialDataReceivedEventHandler(DataReceivedHandler);
                    NC = false;
                }
                else
                {
                    Console.WriteLine("Must Use Format COM# (#=number)");
                }
            }
            return (byte)P; //Returns protocol selection.
        }


        static bool MakeBin()
        {
            BinFile = Directory.GetCurrentDirectory() + "\\EMUSIM.bin";
            if (File.Exists(BinFile)) //Checks if old file already exsists.
            {
                Console.WriteLine("Found a exsisting bin file:\n" + BinFile);
                if (!LoadBin()) //Trys to load the file.
                {
                    return false;
                }
                else
                {
                    return true;
                }
            }
            else
            {
                //Makes a Bin File if one not opened.
                int P;
                Console.WriteLine("No Bin Loaded\nCreating Blank ECUSIM.bin\nWhat Chip Size Fo You Want To Emulate\n(1) 32KB\n(2) 64KB" + FS);
                FS = "";
                int.TryParse(Console.ReadLine(), out P);
                switch (P)
                {
                    case 2:
                        Console.WriteLine("Creating 64KB");
                        Bin = new byte[65536];
                        break;
                    default:
                        Console.WriteLine("Creating 32KB");
                        Bin = new byte[32768];
                        break;
                }
                try
                {

                    File.WriteAllBytes(BinFile, Bin);
                    return true;
                }
                catch
                {
                    Console.WriteLine("Failed to create temp file EMUSIM.bin");
                    return false;
                }
            }
        }

        public static void SaveFile()
        {
            //Saves file to opened file or blank file.
            try
            {
                System.IO.File.WriteAllBytes(BinFile, Bin);
                Console.WriteLine("Saved Bytes To Bin: " + BinFile);
            }
            catch
            {
                Console.WriteLine("Failed To Saved Bytes To Bin: " + BinFile);
            }
        }

        //Erases byte array memory.
        public static void ClearFile()
        {
            Array.Clear(Bin, 0, Bin.Length);
            Console.WriteLine("Zeroed Bin Memory.");
        }

        //Help prompts
        public static void HELP()
        {
            string HelpHeader = @"
                ██╗  ██╗███████╗██╗     ██████╗
                ██║  ██║██╔════╝██║     ██╔══██╗
                ███████║█████╗  ██║     ██████╔╝
                ██╔══██║██╔══╝  ██║     ██╔═══╝
                ██║  ██║███████╗███████╗██║     
                ╚═╝  ╚═╝╚══════╝╚══════╝╚═╝" + "\n";
            string keys = "ESC = Exit Program\nSpace = Save Memory to File\nBackspace = Clear Memory\nF1 = Toggle Bluetooth Delay";
            ConsoleKey H = Console.ReadKey().Key;
            switch (H)
            {
                case ConsoleKey.Escape:
                    Environment.Exit(0);
                    break;
                case ConsoleKey.Spacebar:
                    SaveFile();
                    break;
                case ConsoleKey.Backspace:
                    ClearFile();
                    break;
                case ConsoleKey.F1:
                    SetNoDelay();
                    break;
                default:
                    Console.WriteLine(HelpHeader + Encoding.ASCII.GetString(EEPROM) + HS + keys);
                    break;
            }
        }

        // ██████╗ ██████╗ ███╗   ███╗
        //██╔════╝██╔═══██╗████╗ ████║
        //██║     ██║   ██║██╔████╔██║
        //██║     ██║   ██║██║╚██╔╝██║
        //╚██████╗╚██████╔╝██║ ╚═╝ ██║
        // ╚═════╝ ╚═════╝ ╚═╝     ╚═╝
        public static void DataReceivedHandler(object sender, SerialDataReceivedEventArgs e)
        {
            //Handles Incoming data.
            SerialPort sp = (SerialPort)sender;
            if (!NoDelay)
            {
                Thread.Sleep(TimeOut);// Delay to allow bluetooth buffer to fill before reading.
            }
            else
            {
                Thread.Sleep(20);// Delay 20ms to reduce cpu load.
            }
            byte[] inputbytes = new byte[sp.BytesToRead];
            sp.Read(inputbytes, 0, inputbytes.Length);
            if (inputbytes.Length != 0)
            {
                if (Protocol == 0) //Trys parse the Demon protocol
                {
                    if (!DemonAPI(inputbytes, sp))
                    {
                        ErrorLog(Encoding.Default.GetString(inputbytes));
                    }
                }
                else
                {
                    if (!OstrichAPI(inputbytes, sp)) //Trys parse the Ostrich protocol
                    {
                        ErrorLog(Encoding.Default.GetString(inputbytes));
                    }
                }
            }
        }

        private static void ErrorLog(string Debug)
        {
            if (Debug.Length > 16)
            {
                Debug = Debug.Substring(0, 16); //limited to 16 char
            }
            Console.Write("SD: " + Debug); //Dump string that failed
        }
   


        //Handles outgoing data
        public static void DataSender(byte[] DataByte, SerialPort sp)
        {
            if (sp.IsOpen)
            {
                sp.Write(DataByte, 0, DataByte.Length);
            }
        }

        //███╗   ███╗ █████╗ ██╗███╗   ██╗
        //████╗ ████║██╔══██╗██║████╗  ██║
        //██╔████╔██║███████║██║██╔██╗ ██║
        //██║╚██╔╝██║██╔══██║██║██║╚██╗██║
        //██║ ╚═╝ ██║██║  ██║██║██║ ╚████║
        //╚═╝     ╚═╝╚═╝  ╚═╝╚═╝╚═╝  ╚═══╝
        static void Main(string[] args)
        {
            //Code starts here
            Console.WriteLine(Header);

            //Checks if file has been dragged onto application.
            if (args.Length > 0 && File.Exists(args[0]))
            {
                BinFile = args[0];
                Console.WriteLine("Loading Bin:" + BinFile);
                if (!LoadBin()) //Trys to load the file.
                {
                    Console.WriteLine("Failed to load to byte array.");
                    if (!MakeBin()) //Trys to make new temp file.
                    {
                        Console.WriteLine("Complete Fail, Will close.");
                        Console.ReadKey();
                        Environment.Exit(0);
                    }
                }
            }
            else
            {
                if (!MakeBin()) //Trys to make new temp file.
                {
                    Console.WriteLine("Complete Fail, Will close.");
                    Console.ReadKey();
                    Environment.Exit(0);
                }
            }

            Protocol = Setup(); //Sets up Protocol
            serialPort_0.Open(); //Open COMPort
            if (serialPort_0.IsOpen)
            {
                Console.WriteLine(@"
██████╗ ██╗   ██╗███╗   ██╗███╗   ██╗██╗███╗   ██╗ ██████╗         
██╔══██╗██║   ██║████╗  ██║████╗  ██║██║████╗  ██║██╔════╝         
██████╔╝██║   ██║██╔██╗ ██║██╔██╗ ██║██║██╔██╗ ██║██║  ███╗         
██╔══██╗██║   ██║██║╚██╗██║██║╚██╗██║██║██║╚██╗██║██║   ██║         
██║  ██║╚██████╔╝██║ ╚████║██║ ╚████║██║██║ ╚████║╚██████╔╝██╗██╗██╗
╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝╚═╝╚═╝  ╚═══╝ ╚═════╝ ╚═╝╚═╝╚═╝
Press Enter Key To See Command List.
");
            }
            else
            {
                Console.WriteLine(@"
███████╗ █████╗ ██╗██╗     ███████╗██████╗         
██╔════╝██╔══██╗██║██║     ██╔════╝██╔══██╗         
█████╗  ███████║██║██║     █████╗  ██║  ██║         
██╔══╝  ██╔══██║██║██║     ██╔══╝  ██║  ██║         
██║     ██║  ██║██║███████╗███████╗██████╔╝██╗██╗██╗
╚═╝     ╚═╝  ╚═╝╚═╝╚══════╝╚══════╝╚═════╝ ╚═╝╚═╝╚═╝
Press Any Key To Close!
");
                Console.ReadKey();
                Environment.Exit(0);
            }
            while (true)
            {
                HELP();
            }
        }


        //██████╗ ███████╗███╗   ███╗ ██████╗ ███╗   ██╗
        //██╔══██╗██╔════╝████╗ ████║██╔═══██╗████╗  ██║
        //██║  ██║█████╗  ██╔████╔██║██║   ██║██╔██╗ ██║
        //██║  ██║██╔══╝  ██║╚██╔╝██║██║   ██║██║╚██╗██║
        //██████╔╝███████╗██║ ╚═╝ ██║╚██████╔╝██║ ╚████║
        //╚═════╝ ╚══════╝╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═══╝

        public static bool DemonAPI(byte[] bytearray, SerialPort sp)
        {
            if (VersionRequested(bytearray, sp)) //Version request VV
            { return true; }
            if (EnableOnboard(bytearray, sp)) //Enable onboard datalogging.
            { return true; }
            if (!StandardCheckSum(bytearray)) //Checksum
            { return false; }
            if (SlowRead(bytearray, sp)) //Read bin bytes slow
            {
                TimeOut = 60;
                return true;
            }
            if (SlowWrite(bytearray, sp)) //Write bin bytes slow
            {
                TimeOut = 120;
                return true;
            }
            if (FastRead(bytearray, sp)) //Read bin bytes Fast
            {
                TimeOut = 60;
                return true;
            }
            if (FastWrite(bytearray, sp)) //Write bin bytes Fast
            {
                TimeOut = 600;
                return true;
            }
            if (SerialRequest(bytearray, sp)) //Serial number request
            { return true; }
            if (QCSRequest(bytearray, sp)) //Quick CheckSum request BMGJET Protocol
            { return true; }
            if (EEPROMRequest(bytearray, sp)) //EEPROM Information requested
            { return true; }
            if (EEPROMRequest2(bytearray, sp)) //EEPROM Information requested
            { return true; }
            if (BankActive(bytearray, sp)) //Select Active Emulation Bank.
            { return true; }
            if (BankStatic(bytearray, sp)) //Select Static Emulation Bank.
            { return true; }

            return false; //No valid commands found.
        }

        // ██████╗ ███████╗████████╗██████╗ ██╗ ██████╗██╗  ██╗
        //██╔═══██╗██╔════╝╚══██╔══╝██╔══██╗██║██╔════╝██║  ██║
        //██║   ██║███████╗   ██║   ██████╔╝██║██║     ███████║
        //██║   ██║╚════██║   ██║   ██╔══██╗██║██║     ██╔══██║
        //╚██████╔╝███████║   ██║   ██║  ██║██║╚██████╗██║  ██║
        // ╚═════╝ ╚══════╝   ╚═╝   ╚═╝  ╚═╝╚═╝ ╚═════╝╚═╝  ╚═╝
        public static bool OstrichAPI(byte[] bytearray, SerialPort sp)
        {
            if(VersionRequested(bytearray, sp)) //Version request VV
            {return true;}
            if (!StandardCheckSum(bytearray)) //Checksum
            {return false;}
            if (SlowRead(bytearray, sp)) //Read bin bytes slow
            {
                TimeOut = 60;
                return true;
            }
            if (SlowWrite(bytearray, sp)) //Write bin bytes slow
            {
                TimeOut = 120;
                return true;
            }
            if (FastRead(bytearray, sp)) //Read bin bytes Fast
            {
                TimeOut = 60;
                return true;
            }
            if (FastWrite(bytearray, sp)) //Write bin bytes Fast
            {
                TimeOut = 600;
                return true;
            }
            if (SerialRequest(bytearray, sp)) //Serial number request
            {return true;}
            if (QCSRequest(bytearray, sp)) //Quick CheckSum request BMGJET Protocol
            { return true; }
            if (EEPROMRequest(bytearray, sp)) //EEPROM Information requested
            { return true; }
            if (EEPROMRequest2(bytearray, sp)) //EEPROM Information requested
            { return true; }
            if (BankActive(bytearray, sp)) //Select Active Emulation Bank.
            { return true; }
            if (BankStatic(bytearray, sp)) //Select Static Emulation Bank.
            { return true; }
            return false; //No valid commands found.
        }

        //███╗   ███╗ ██████╗  █████╗ ████████╗███████╗███████╗
        //████╗ ████║██╔═══██╗██╔══██╗╚══██╔══╝██╔════╝██╔════╝
        //██╔████╔██║██║   ██║███████║   ██║   █████╗  ███████╗
        //██║╚██╔╝██║██║   ██║██╔══██║   ██║   ██╔══╝  ╚════██║
        //██║ ╚═╝ ██║╚██████╔╝██║  ██║   ██║   ███████╗███████║
        //╚═╝     ╚═╝ ╚═════╝ ╚═╝  ╚═╝   ╚═╝   ╚══════╝╚══════╝
        public static bool VersionRequested(byte[] bytearray, SerialPort sp)
        {
            //VV request
            if (bytearray[0] == 0x56 && bytearray[1] == 0x56)
            {
                TimeOut = 600;
                Console.WriteLine("Version Requested.");
                DataSender(Version, sp);
                return true;
            }
            return false;
        }
        public static bool BankStatic(byte[] bytearray, SerialPort sp)
        {
            //Get Static Emulation Bank
            //42 45 53 DA write
            //oo read
            if (bytearray[0] == 0x42 && bytearray[1] == 0x45 && bytearray[2] == 0x53 && bytearray[3] == 0xDA)
            {
                Console.WriteLine("Static Bank Info Requested");
                byte[] BANKINFO = new byte[] { 0x00 };
                DataSender(BANKINFO, sp);
                return true;
            }
            return false;
        }
        public static bool BankActive(byte[] bytearray, SerialPort sp)
        {
            //Get Active Emulation Bank Succeeded: Bank 0
            //42 52 52 Bank write
            //00            read
            if (bytearray[0] == 0x42 && bytearray[1] == 0x52)
            {
                Console.WriteLine("Active Bank Info Requested");
                byte[] BANKINFO = new byte[] { 0x00 };
                DataSender(BANKINFO, sp);
                return true;
            }
            if (bytearray[0] == 0x42 && bytearray[1] == 0x53)
            {
                Console.WriteLine("Active Bank Info Requested");
                DataSender(OK, sp);
                return true;
            }
            return false;
        }

        public static bool EEPROMRequest(byte[] bytearray, SerialPort sp)
        {
            //EEPROM Information requested
            if (bytearray[0] == 0x45 && bytearray[1] == 0x07 && bytearray[3] == 0x01)
            {
                Console.WriteLine("EEPROM Info Requested");
                byte[] EEPROMINFO = new byte[] { 0x50, 0x02, 0x00, 0x55, 0x02, 0x01, 0x10 };
                DataSender(EEPROMINFO, sp);
                return true;
            }
            return false;
        }


        public static bool EEPROMRequest2(byte[] bytearray, SerialPort sp)
        {
            //EEPROM Information requested
            if (bytearray[0] == 0x48 && bytearray[1] == 0x52 && bytearray[2] == 0x07 && bytearray[4] == 0x01 && bytearray[5] == 0xA2)
            {
                Console.WriteLine("EEPROM Info Requested");
                byte[] EEPROMINFO = new byte[] { 0x50, 0x02, 0x00, 0x55, 0x02, 0x01, 0x10 };
                if (Protocol == 0)
                {
                   EEPROMINFO[0] = 0x44;
                }
                DataSender(EEPROMINFO, sp);
                return true;
            }
            return false;
        }

        public static bool SerialRequest(byte[] bytearray, SerialPort sp)
        {
            if (bytearray[0] == 0x4E && bytearray[1] == 0x53)
            {
                Console.WriteLine("Serial Number Requested");
                DataSender(Serial, sp);
                return true;
            }
            return false;
        }

        public static bool StandardCheckSum(byte[] bytearray)
        {
            //Checksum used on most packets.
            byte Tchecksum = 0;
            int bytelen = bytearray.Length;
            byte Cchecksum = bytearray[bytelen - 1];
            //Calculate checksum
            for (int i = 0; i <= bytelen - 2; i++)
            {
                Tchecksum += bytearray[i];
            }

            //Check valid checksum.
            if (Tchecksum != Cchecksum)
            {
                Console.WriteLine("CheckSum Failed");
                return false; //Not valid stop processing
            }
            return true;
        }

        //Fast Write
        public static void BinFastWrite(byte[] bytearray, SerialPort sp)
        {
            int BlockSize = (256 * (bytearray[2]));

            if (bytearray.Length == BlockSize + 6) //normal
            {
                int Address = GetAddress(bytearray[3], bytearray[4]);

                //Pack bin with write bytes.
                for (int i = 0; i < BlockSize; i++)
                {
                    Bin[Address + i] = bytearray[i + 5];
                }
                byte[] OK = new byte[] { 0x4F };
                Console.WriteLine(BlockSize + " Bytes written to " + Address);
                DataSender(OK, sp);
            }
            else if (bytearray.Length == BlockSize + 8) //encrypt byte 3/4 random encrypt bytes
            {
                //Removed function to protect intellectual property
                Console.WriteLine("Encrypted fast write transfere");
                DataSender(OK, sp);
            }

        }

        //Slow Write
        public static void BinWrite(byte[] bytearray, SerialPort sp)
        {
            int BlockSize = GetBlockSize(bytearray[1]);

            if (bytearray.Length == BlockSize + 5)
            {
                int Address = GetAddress(bytearray[3], bytearray[2]);

                //Pack bin with write bytes.
                for (int i = 0; i < BlockSize; i++)
                {
                    Bin[Address + i] = bytearray[i + 4];
                }
                byte[] OK = new byte[] { 0x4F };
                Console.WriteLine(BlockSize + " Bytes written to " + Address);
                DataSender(OK, sp);
            }
            else if (bytearray.Length == 8) //encrypted slow write
            {
                //Removed function to protect intellectual property
                Console.WriteLine("Encrypted slow write transfere");
                DataSender(OK, sp);
            }

            }

        //Slow Read
        public static void BinRead(byte[] bytearray, SerialPort sp)
        {
            int BlockSize = GetBlockSize(bytearray[1]);
            if (bytearray.Length == 6) //normal
            {
                //Setup buffer
                byte[] Binbuff = new byte[BlockSize];
                int Address = GetAddress(bytearray[3], bytearray[2]);

                //Pack the buffer
                for (int i = 0; i <= BlockSize - 1; i++)
                {
                    Binbuff[i] = Bin[Address + i];
                }
                //Output buffer.
                Console.WriteLine(BlockSize + " Bytes read from " + Address);
                DataSender(checksum(Binbuff), sp);
            }
            else if (bytearray.Length == 8) //encrypted fast read
            {
                //Removed function to protect intellectual property
                Console.WriteLine("Encrypted slow read transfere");
                DataSender(OK, sp);
            }

        }
        //Fast read
        public static void BinFastRead(byte[] bytearray, SerialPort sp)
        {
            int BlockSize = (256 * (bytearray[2]));

             if (bytearray.Length == 5) //fast read
            {
                int Address = GetAddress(bytearray[3], bytearray[4]);

            //Setup buffer
            byte[] Binbuff = new byte[BlockSize];

            //Pack the buffer
            for (int i = 0; i <= BlockSize - 1; i++)
            {
                Binbuff[i] = Bin[Address + i];
            }
            //Output buffer.
            Console.WriteLine(BlockSize + " Bytes read from " + Address);
            DataSender(checksum(Binbuff), sp);
        }
            else if (bytearray.Length == 8) //encrypted fast read
            {
                //Removed function to protect intellectual property
                Console.WriteLine("Encrypted fast read transfere");
                DataSender(OK, sp);
            }
        }

        //Block size correction.
        public static int GetBlockSize(int BlockSize)
        {
            if (BlockSize == 0)
            {
                BlockSize = 256;
            }
            return BlockSize;
        }

        //Get byte array address
        public static int GetAddress(int MSB, int LSB)
        {
            int Address = (MSB | LSB << 8);
            if (Address >= Bin.Length)
            {
                Address -= 32768; //Resize 64K back to 32K.
            }
            return Address;
        }

        //Calculate Checksum and create new byte array with it added on.
        public static byte[] checksum(byte[] bArray)
        {
            byte cs = 0;
            foreach (byte raw in bArray)
            {
                cs += raw;
            }
            byte[] newArray = new byte[bArray.Length + 1];
            bArray.CopyTo(newArray, 0);
            newArray[newArray.Length - 1] = cs;
            return newArray;
        }
        public static bool SlowRead(byte[] bytearray, SerialPort sp)
        {
            if (bytearray[0] == 0x52 && bytearray.Length == 5) //R
            {
                BinRead(bytearray, sp);
                return true;
            }
            return false;
        }
        public static bool SlowWrite(byte[] bytearray, SerialPort sp) //W
        {
            if (bytearray[0] == 0x57)
            {
                BinWrite(bytearray, sp);
                return true;
            }
            return false;
        }
        public static bool FastRead(byte[] bytearray, SerialPort sp) //ZR
        {
            if (bytearray[0] == 0x5A && bytearray[1] == 0x52)
            {
                BinFastRead(bytearray, sp);
                return true;
            }
            return false;
        }
        public static bool FastWrite(byte[] bytearray, SerialPort sp) //ZW
        {
            if (bytearray[0] == 0x5A && bytearray[1] == 0x57)
            {
                BinFastWrite(bytearray, sp);
                return true;
            }
            return false;
        }

        public static bool EnableOnboard(byte[] bytearray, SerialPort sp) //DOLY Enable onboard
        {
            if (bytearray[0] == 0x44 && bytearray[1] == 0x4F && bytearray[2] == 0x4C  && bytearray[3] == 0x59)
            {
                DataSender(OK, sp);
                return true;
            }
            if (bytearray[0] == 0x44 && bytearray[1] == 0x4F && bytearray[2] == 0x4C && bytearray[3] == 0x79)
            {
                DataSender(OK, sp);
                return true;
            }
            return false;
        }


        //███████╗██╗  ██╗████████╗██████╗  █████╗
        //██╔════╝╚██╗██╔╝╚══██╔══╝██╔══██╗██╔══██╗
        //█████╗   ╚███╔╝    ██║   ██████╔╝███████║
        //██╔══╝   ██╔██╗    ██║   ██╔══██╗██╔══██║
        //███████╗██╔╝ ██╗   ██║   ██║  ██║██║  ██║
        //╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝

        //Quick Check Sum
        //5a 43 53 PacketCS     write
        //MemoryCS              read
        public static bool QCSRequest(byte[] bytearray, SerialPort sp)
        {
            if (bytearray[0] == 0x5A && bytearray[1] == 0x43 && bytearray[2] == 0x53)
            {
                QuckCS(sp);
                return true;
            }
            return false;
        }
        public static void QuckCS(SerialPort sp)
        {
            //Sum of Emulator Memory.
            byte[] QCS = new byte[1];
            foreach (byte B in Bin)
            {
                QCS[0] += B;
            }
            Console.WriteLine("Quick CheckSum: " + QCS[0].ToString("X2"));
            DataSender(QCS, sp);
        }
    }
}


Top
 Profile  
Reply with quote  
PostPosted: Thu Mar 05, 2020 7:03 pm 
Offline

Joined: Mon Nov 25, 2019 5:18 pm
Posts: 6
Thank you !!!


Top
 Profile  
Reply with quote  
Display posts from previous:  Sort by  
Post new topic Reply to topic  [ 2 posts ] 

All times are UTC - 5 hours [ DST ]


Who is online

Users browsing this forum: No registered users and 1 guest


You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot post attachments in this forum

Search for:
Jump to:  


Powered by phpBB® Forum Software © phpBB Group