using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Runtime.InteropServices;
using System.Windows.Forms;
using FTD2XX_NET;
using System.Threading;
using System.IO;


public delegate void SendingByteToRAMHandler();
public delegate void SendedByteToRAMHandler();
public delegate void SendingByteToEEPROMHandler();
public delegate void SendedByteToEEPROMHandler();
public delegate void RecivingByteFromEEPROMHandler();
public delegate void RecivedByteFromEEPROMHandler();
public delegate void RecivingByteFromRAMHandler();
public delegate void RecivedByteFromRAMHandler();
public delegate void ProgrammingPAOHandler();
public delegate void ProgrammedPAOHandler();
public delegate void CircuitEchoingHandler();
public delegate void CircuitEchoedHandler();

public delegate void ErrorMessageHandler();
public delegate void ReloadThumbinalsHandler();

public delegate void ReloadSchemeSetterHandler();

public delegate void EmptyDeviceHandler();

public delegate void ProtocolCrash();

namespace Nastavení_PAO
{
     public struct TransferRes{

            public int CommandType;
            public DateTime EventTime;
            public int ad, val;
            public bool res;
            public int TypeOfReport;

            public TransferRes(int CommandTypeX, DateTime EventTimeX, int adX, int valX, bool resX) {

                CommandType = CommandTypeX;
                EventTime = EventTimeX;
                ad = adX;
                val = valX;
                res = resX;
                TypeOfReport = 4;
            
            }

            public TransferRes(int CommandTypeX, DateTime EventTimeX, int adX)
            {

                CommandType = CommandTypeX;
                EventTime = EventTimeX;
                ad = adX;
                val = 999999;
                res = false;
                TypeOfReport = 2;

            }

            public TransferRes(int CommandTypeX, DateTime EventTimeX)
            {

                CommandType = CommandTypeX;
                EventTime = EventTimeX;
                ad = 999999;
                val = 999999;
                res = false;
                TypeOfReport = 1;

            }

            public TransferRes(int CommandTypeX, DateTime EventTimeX, int adX, int valX)
            {

                CommandType = CommandTypeX;
                EventTime = EventTimeX;
                ad = adX;
                val = valX;
                res = false;
                TypeOfReport = 3;

            }

         
        }

     public struct ErrorMessageBlock {

         public String FunctionName;
         public bool StatusOfFunction;
         public int ErrorCodeName;
         public int NumberOfFunction;
         public String DescribeOfErr;
 
         public ErrorMessageBlock(String FunctionNameX, bool StatusOfFunctionX, int ErrorCodeNameX,int NumberOfFunctionX,String DescribeOfErrX){

             FunctionName = FunctionNameX;
             StatusOfFunction = StatusOfFunctionX;
             ErrorCodeName = ErrorCodeNameX;
             NumberOfFunction = NumberOfFunctionX;
             DescribeOfErr = DescribeOfErrX;
         
         }
     
     }

     public class ErrorMessage {

         public List<ErrorMessageBlock> ErrorList = new List<ErrorMessageBlock>();

         public ErrorMessage(List<ErrorMessageBlock> EMBX) {


             for (int i = 0; i < EMBX.Count; i++) {

                 ErrorList.Add(EMBX[i]);
             
             }
         
         }

     
     }

     public class ErrorMessageEventArgs : EventArgs
     {
         ErrorMessage em;

         public ErrorMessageEventArgs(ErrorMessage emX)
         {
             this.em = emX;
         }

         public ErrorMessage Em
         {
             get
             {
                 return em;
             }
         }
     }

     public class SendingByteToRAMEventArgs : EventArgs
     {
         TransferRes transres;

         public SendingByteToRAMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class SendedByteToRAMEventArgs : EventArgs
     {
         TransferRes transres;

         public SendedByteToRAMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }




     public class SendingByteToEEPROMEventArgs : EventArgs
     {
         TransferRes transres;

         public SendingByteToEEPROMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class SendedByteToEEPROMEventArgs : EventArgs
     {
         TransferRes transres;

         public SendedByteToEEPROMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }


    //-----


     public class RecivingByteFromEEPROMEventArgs : EventArgs
     {
         TransferRes transres;

         public RecivingByteFromEEPROMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class RecivedByteFromEEPROMEventArgs : EventArgs
     {
         TransferRes transres;

         public RecivedByteFromEEPROMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class RecivingByteFromRAMEventArgs : EventArgs
     {
         TransferRes transres;

         public RecivingByteFromRAMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class RecivedByteFromRAMEventArgs : EventArgs
     {
         TransferRes transres;

         public RecivedByteFromRAMEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

    //_--------------
     public class ProgrammingPAOEventArgs : EventArgs
     {
         TransferRes transres;

         public ProgrammingPAOEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class ProgrammedPAOEventArgs : EventArgs
     {
         TransferRes transres;

         public ProgrammedPAOEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class CircuitEchoingEventArgs : EventArgs
     {
         TransferRes transres;

         public CircuitEchoingEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class CircuitEchoedEventArgs : EventArgs
     {
         TransferRes transres;

         public CircuitEchoedEventArgs(TransferRes transres)
         {
             this.transres = transres;
         }

         public TransferRes Transres
         {
             get
             {
                 return transres;
             }
         }
     }

     public class ProgressBarInfoArgs : EventArgs {

        private bool _res;
        private int _num;

        public ProgressBarInfoArgs(int adx, bool resX) {

            this._res = resX;
            this._num = adx;
        
        }

        public bool Res {
            get {

                return _res;
            
            }
         
         }

        public int Addr
        {
            get
            {

                return _num;

            }

        }
     
     }

     public struct ListOfFTDIs {

         public string Description;
         public string SerialNumber;
         public uint ID;
         public uint LocID;
         public uint index;

         public ListOfFTDIs(uint indexX, uint LocIDX, uint IDX, string DescriptionX, string SerialNumberX) {

             this.Description = DescriptionX;
             this.SerialNumber = SerialNumberX;
             this.ID = IDX;
             this.LocID = LocIDX;
             this.index = indexX;

         
         }
     }


     public class FindedDevices : EventArgs
     {

         bool OperationSuccess;
         List<ListOfFTDIs> list;
         bool ErrDeviceCount;
         bool ErrDeviceGetDesc;
         string ReasonOfErr;
         string FunctionOfProblem;


         public FindedDevices(List<ListOfFTDIs> listX, bool OperationSuccessX, bool ErrDeviceGetDescX, bool ErrDeviceCountX, string ReasonOfErrX, string FunctionOfProblemX)
         {
             this.list = listX;
             this.OperationSuccess = OperationSuccessX;
             this.ErrDeviceCount = ErrDeviceCountX;
             this.ErrDeviceGetDesc = ErrDeviceGetDescX;
             this.ReasonOfErr = ReasonOfErrX;
             this.FunctionOfProblem = FunctionOfProblemX;
         }

         public List<ListOfFTDIs> List
         {
             get
             {
                 return list;
             }
         }

         public bool operationSuccess
         {
             get
             {
                 return OperationSuccess;
             }
         }

         public bool errDeviceCount
         {
             get
             {
                 return ErrDeviceCount;
             }
         }

         public bool errDeviceGetDesc
         {
             get
             {
                 return ErrDeviceGetDesc;
             }
         }

         public string reasonOfErr
         {
             get
             {
                 return ReasonOfErr;
             }
         }
         public string functionOfProblem
         {
             get
             {
                 return FunctionOfProblem;
             }
         }
     }


     public class UsbCom
    {
   
        private int lowBorderAddress, hightBorderAddress;
        public Dictionary<Byte, Byte> BytesMemory = new Dictionary<Byte, Byte>();
        private static List<ErrorMessageBlock> listofErrX = new List<ErrorMessageBlock>();
        private int CountOfElementsByte;
        FTDI myFtdiDevice;
        private  int i, j, k;
        public PAOProperties ControlRegisters = new PAOProperties();
        private uint ActiveDeviceLoc;
        private bool DeviceIsSet;
        public Profiler profiler = new Profiler(Path.Combine(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location),"profily"));
        private string actual_conf = string.Empty;


        private uint baudrate,ReadTimeOut,WriteTimeOut;
        private byte DataBits, StopBits, Parity, FCtrlXon, FCtrlXoff;
        private ushort FlowCtrlType;

        public delegate void GetConnectedDevicesHandler(object sender, FindedDevices e);
        public delegate void LoadProgressBarInfo(object sender, ProgressBarInfoArgs e);

        public delegate void SendingByteToRAMEventHandler(object sender, SendingByteToRAMEventArgs e);
        public delegate void SendedByteToRAMEventHandler(object sender, SendedByteToRAMEventArgs e);
        public delegate void SendingByteToEEPROMEventHandler(object sender, SendingByteToEEPROMEventArgs e);
        public delegate void SendedByteToEEPROMEventHandler(object sender, SendedByteToEEPROMEventArgs e);
        public delegate void RecivingByteFromRAMEventHandler(object sender, RecivingByteFromRAMEventArgs e);
        public delegate void RecivedByteFromRAMEventHandler(object sender, RecivedByteFromRAMEventArgs e);
        public delegate void RecivingByteFromEEPROMEventHandler(object sender, RecivingByteFromEEPROMEventArgs e);
        public delegate void RecivedByteFromEEPROMEventHandler(object sender, RecivedByteFromEEPROMEventArgs e);
        public delegate void ProgrammingPAOEventHandler(object sender, ProgrammingPAOEventArgs e);
        public delegate void ProgrammedPAOEventHandler(object sender, ProgrammedPAOEventArgs e);
        public delegate void CircuitEchoingEventHandler(object sender, CircuitEchoingEventArgs e);
        public delegate void CircuitEchoedEventHandler(object sender, CircuitEchoedEventArgs e);
        public delegate void ErrorMessageEventHandler(object sender, ErrorMessageEventArgs e);

        public event GetConnectedDevicesHandler GetConnectedDevicesHandlerStatus;
        public event EmptyDeviceHandler EmptyDeviceHandlerStatus;
        public event LoadProgressBarInfo LoadProgressBarInfoStatus;
        public event ProtocolCrash ProtocolCrashStatus;

        public event SendingByteToRAMEventHandler SendingByteToRAMEventHandlerStatus;
        public event SendedByteToRAMEventHandler SendedByteToRAMEventHandlerStatus;
        public event SendingByteToEEPROMEventHandler SendingByteToEEPROMEventHandlerStatus;
        public event SendedByteToEEPROMEventHandler SendedByteToEEPROMEventHandlerStatus;
        public event RecivingByteFromRAMEventHandler RecivingByteFromRAMEventHandlerStatus;
        public event RecivedByteFromRAMEventHandler RecivedByteFromRAMEventHandlerStatus;
        public event RecivingByteFromEEPROMEventHandler RecivingByteFromEEPROMEventHandlerStatus;
        public event RecivedByteFromEEPROMEventHandler RecivedByteFromEEPROMEventHandlerStatus;
        public event ProgrammingPAOEventHandler ProgrammingPAOEventHandlerStatus;
        public event ProgrammedPAOEventHandler ProgrammedPAOEventHandlerStatus;
        public event CircuitEchoingEventHandler CircuitEchoingEventHandlerStatus;
        public event CircuitEchoedEventHandler CircuitEchoedEventHandlerStatus;
        public event ErrorMessageEventHandler ErrorMessageEventHandlerStatus;

         public event ReloadThumbinalsHandler ReloadThumbinalsHandlerStatus;
         public event ReloadSchemeSetterHandler ReloadSchemeHandlerStatus;

        

        //V EEPROMce jsou někde uloženy FUSE_BITY (16 -> 2B), nesmíme je takhle přepsat
         public UsbCom(uint baudrateX, uint ReadTimeOutX, uint WriteTimeOutX, byte DataBitsX, byte StopBitsX, byte ParityX, byte FCtrlXonX, byte FCtrlXoffX, ushort FlowCtrlTypeX)
        {
            // Create new instance of the FTDI device class
            myFtdiDevice = new FTDI();

            
       baudrate=baudrateX;
       ReadTimeOut=ReadTimeOutX;
       WriteTimeOut=WriteTimeOutX;
       DataBits=DataBitsX;
       StopBits=StopBitsX;
       Parity=ParityX;
       FCtrlXon=FCtrlXonX;
       FCtrlXoff=FCtrlXoffX;
       FlowCtrlType = FlowCtrlTypeX;
        

            ControlRegisters.PAOPropertiesChandedStatus += new PAOProperties.PAOPropertiesChandedHandler(Properties2Dictionary);
            ControlRegisters.PropertiesWillBeReloadedStatus += new PropertiesWillBeReloadedHandler(DictToProp);

            ActiveDeviceLoc = 999999;
            DeviceIsSet = false;


         }


         public uint SetActiveDeviceLoc{

             set {

                 if (value != 999999)
                 {
                     this.ActiveDeviceLoc = value;
                     DeviceIsSet = true;
                 }
                 else {

                     DeviceIsSet = false;
                     this.ActiveDeviceLoc = 999999;
                 }

             
             }
             get {

                 return ActiveDeviceLoc;
             
             }
         
         }

        public enum CommandTypes
        {
            CircuitEcho = 1,
            ReadByteFromEEPROM = 2,
            WriteByteToEEPROM = 3,
            ProgrammPAOFromRAM = 4,
            WriteByteToRAM = 5,
            ReadByteFromRAM = 6,
         
        }
        public enum MsgReturns
        {

            msgOK = 1,
            msgErr = 2

        }

        public enum Erors
        {

            CouldntOpenUsbDevice = 0,
            ControlTransferFailed = 1,
            EchoTestFailed = 2,
            NotExistKeyInDictionary = 3,
            UsbSendDataFunctionFailed = 4,
            ControlNegationTestFailed = 5,
            WriteManyValuesToRAM = 6,
            ReadManyValuesFromRAM = 7,
            ReadManyValuesFromEEPROM = 8,
            WriteManyValuesToEEPROM = 9,
            CouldntDetectUsbDevice = 10,
            CouldntWriteUsbDevice = 11,
            UsbDeviceClosingFailed = 12,
            UsbDeviceReadFailed = 13,
            UsbDeviceWriteFailed = 14,
            UsbDeviceTimeoutValFailed = 15,
            UsbDeviceFlowCtrlFailed = 16,
            UsbDeviceCharacterFailed = 17,
            UsbDeviceBaudrateFailed = 18,
            UsbDeviceReadFrameSendErr = 19,
            UsbDeviceReadErrFromAtmel = 20

        }

    

        public enum Constans
        {

            NotDefined = 999999,
        }


        public void SetBorderAdressValues(byte a1, byte a2) {

            lowBorderAddress = a1;
            hightBorderAddress = a2;

            //inicializace dictionary .... pravděpodobně 256 hodnot (0x00 - 0xFF hodnota 0x00)

            for (i = lowBorderAddress; i <=hightBorderAddress; i++) {

                BytesMemory.Add((byte)i, (byte)0);
            
            }
        
        
        }

        protected void ProtocolCrashStatusMake() {

            if (ProtocolCrashStatus != null) {

                ProtocolCrashStatus();
            
            }
        
        
        }

        protected void LoadProgressBarInfoStatusMake(ProgressBarInfoArgs e) {

            if (LoadProgressBarInfoStatus != null) {

                LoadProgressBarInfoStatus(this, e);
            
            }
        
        }

        protected void GetConnectedDevicesStatusMake(FindedDevices e)
        {

            if (GetConnectedDevicesHandlerStatus != null)
            {

                GetConnectedDevicesHandlerStatus(this, e);
            }

        }



        protected void EmptyDeviceHandlerStatusMake()
        {

            if (EmptyDeviceHandlerStatus != null)
            {

                EmptyDeviceHandlerStatus();
            }

        }

        protected void ErrorMessageHandlerStatusMake(ErrorMessageEventArgs e)
        {

            if (ErrorMessageEventHandlerStatus != null)
            {

                ErrorMessageEventHandlerStatus(this, e);
            }

        }

        protected void ReloadSchemeGUIStatusMake() {

            if (ReloadSchemeHandlerStatus != null) {

                ReloadSchemeHandlerStatus();
            
            }
        
        }
        
         protected void ReloadThumbinalsHandlerStatusMake()
        {

            if (ReloadThumbinalsHandlerStatus != null)
            {

                ReloadThumbinalsHandlerStatus();
            }

        }

        protected void SendingByteToRAMHandlerStatusMake(SendingByteToRAMEventArgs e) {

            if (SendingByteToRAMEventHandlerStatus != null) {

                SendingByteToRAMEventHandlerStatus(this,e);
            }
        
        }

        protected void SendingByteToEEPROMHandlerStatusMake(SendingByteToEEPROMEventArgs e)
        {

            if (SendingByteToEEPROMEventHandlerStatus != null)
            {

                SendingByteToEEPROMEventHandlerStatus(this,e);
            }

        }

        protected void SendedByteToRAMHandlerStatusMake(SendedByteToRAMEventArgs e)
        {

            if (SendedByteToRAMEventHandlerStatus != null)
            {

                SendedByteToRAMEventHandlerStatus(this,e);
            }

        }

        protected void SendedByteToEEPROMHandlerStatusMake(SendedByteToEEPROMEventArgs e)
        {

            if (SendedByteToEEPROMEventHandlerStatus != null)
            {

                SendedByteToEEPROMEventHandlerStatus(this,e);
            }

        }

        protected void RecivingByteFromEEPROMHandlerStatusMake(RecivingByteFromEEPROMEventArgs e) {

            if (RecivingByteFromEEPROMEventHandlerStatus != null)
            {

                RecivingByteFromEEPROMEventHandlerStatus(this,e);
            }
        
        }

        protected void RecivedByteFromEEPROMHandlerStatusMake(RecivedByteFromEEPROMEventArgs e)
        {

            if (RecivedByteFromEEPROMEventHandlerStatus != null)
            {

                RecivedByteFromEEPROMEventHandlerStatus(this,e);
            }

        }
        protected void RecivedByteFromRAMHandlerStatusMake(RecivedByteFromRAMEventArgs e)
        {

            if (RecivedByteFromRAMEventHandlerStatus != null)
            {

                RecivedByteFromRAMEventHandlerStatus(this,e);
            }

        }
        protected void RecivingByteFromRAMHandlerStatusMake(RecivingByteFromRAMEventArgs e)
        {

            if (RecivingByteFromRAMEventHandlerStatus != null)
            {

                RecivingByteFromRAMEventHandlerStatus(this,e);
            }

        }

        protected void ProgrammingPAOHandlerStatusMake(ProgrammingPAOEventArgs e)
        {

            if (ProgrammingPAOEventHandlerStatus != null)
            {

                ProgrammingPAOEventHandlerStatus(this,e);
            }

        }

        protected void ProgrammedPAOHandlerStatusMake(ProgrammedPAOEventArgs e)
        {

            if (ProgrammedPAOEventHandlerStatus != null)
            {

                ProgrammedPAOEventHandlerStatus(this,e);
            }

        }

        protected void CircuitEchoingHandlerStatusMake(CircuitEchoingEventArgs e)
        {

            if (CircuitEchoingEventHandlerStatus != null)
            {

                CircuitEchoingEventHandlerStatus(this,e);
            }

        }

        protected void CircuitEchoedHandlerStatusMake(CircuitEchoedEventArgs e)
        {

            if (CircuitEchoedEventHandlerStatus != null)
            {

                CircuitEchoedEventHandlerStatus(this,e);

            }

        }

        private static void AddError(int Type, String functionName, String ReasonOfError)
        {

         Dictionary<String, String> errDescribeField = new Dictionary<String, String>();
          List<String> listOfFunction = new List<String>();

          listOfFunction.Add("UsbSendData");
          listOfFunction.Add("CircuitEcho");
          listOfFunction.Add("SendSingleDataToEEPROM");
          listOfFunction.Add("SendSingleDataToRAM");
          listOfFunction.Add("GetSingleDataFromEEPROM");
          listOfFunction.Add("GetSingleDataFromRAM");
          listOfFunction.Add("SendAllValuesToEEPROM");
          listOfFunction.Add("SendAllValuesToRAM");
          listOfFunction.Add("GetAllValuesFromRAM");
          listOfFunction.Add("GetAllValuesFromEEPROM");

          errDescribeField.Add(((int)Erors.ControlNegationTestFailed).ToString(), "Chyba kontrolní negace, pro kontrolu přenosu dat z programátoru");
          errDescribeField.Add(((int)Erors.ControlTransferFailed).ToString(), "Selhala metoda UsbControlTansfer komunikující s Control Endpointem v zařízení programátoru");
          errDescribeField.Add(((int)Erors.CouldntDetectUsbDevice).ToString(), "Nemohu detekovat programátor na Usb sběrnici, zařízení nebylo nalezeno v seznamu připojených zařízení");
          errDescribeField.Add(((int)Erors.CouldntOpenUsbDevice).ToString(), "Nemohu otevřít zařízení programátoru na Usb sběrnici, zařízení bylo nalezeno, ale nepodařilo se jej otevřít");
          errDescribeField.Add(((int)Erors.EchoTestFailed).ToString(), "Selhala kontrola komunikace s programátorem, chybou některých rodičovských metod");
          errDescribeField.Add(((int)Erors.NotExistKeyInDictionary).ToString(), "Ke klíči hodnoty adresy neexistuje hodnota dat");
          errDescribeField.Add(((int)Erors.ReadManyValuesFromEEPROM).ToString(), "Chyba zápisu vícera dat do EEPROM, chyba rodičovkých metod");
          errDescribeField.Add(((int)Erors.ReadManyValuesFromRAM).ToString(), "Chyba čtení hodnot z RAM programátoru, chyba rodičovských metod");
          errDescribeField.Add(((int)Erors.UsbSendDataFunctionFailed).ToString(), "Selhání metody UsbRecieveBuffer, způsobená zřejmě chybou metody usbControlTransfer");
          errDescribeField.Add(((int)Erors.WriteManyValuesToEEPROM).ToString(), "Chyba zápisu vícera dat do EEPROM programátoru, způsobená chybou rodičovských metod");
          errDescribeField.Add(((int)Erors.WriteManyValuesToRAM).ToString(), "Chyba zápisu vícera dat do RAM programátoru, způsobená chybou rodičovských metod");
          errDescribeField.Add(((int)Erors.UsbDeviceBaudrateFailed).ToString(), "Nepodařilo se nastavit modulační rychlost přenosu na driveru FT232BL");
          errDescribeField.Add(((int)Erors.UsbDeviceClosingFailed).ToString(), "Nepodařilo se uzavřít přístup k zařízení FT232BL na driveru");
          errDescribeField.Add(((int)Erors.UsbDeviceFlowCtrlFailed).ToString(), "Nepodařilo se nastavit řízení přenosu (handshaking) na driveru obvodu FT232BL");
          errDescribeField.Add(((int)Erors.UsbDeviceCharacterFailed).ToString(), "Nepodařilo se nastavit parametry přenosu obvodu FT232BL (počet datových bitů, paritních a stop bitů)");
          errDescribeField.Add(((int)Erors.UsbDeviceReadFailed).ToString(), "Nepodařilo se přečíst data z zařízení FT232BL skrz driver");
          errDescribeField.Add(((int)Erors.UsbDeviceTimeoutValFailed).ToString(), "Nepodařilo se nastavit Timeout pro naslouchání a následný příjem dat z obvodu FT232BL skrz jeho driver");
          errDescribeField.Add(((int)Erors.UsbDeviceWriteFailed).ToString(), "Do zařízení FT232BL se nepodařilo zapsat data skz driver");
          errDescribeField.Add(((int)Erors.UsbDeviceReadFrameSendErr).ToString(), "Díky vzniklým chybám se nepodařilo přenést programový rámec (zapsat 5B a následně 5B přečíst) z a do obvodu FT232BL skrz driver (chyba příjmu seriového rozhranní atmelu)");
          errDescribeField.Add(((int)Erors.UsbDeviceReadErrFromAtmel).ToString(), "Při posílání dat směrem od mikrokontroléru do FT232BL vznikla chyba na sériovém rozhranní (parita, rámec, přetečení) (chyba příjmu seriového rozhranní FT232BL)");

          string cast1, cast2;

          if (ReasonOfError == String.Empty)
          {

              cast1 = ".";
              cast2 = "";

          }
          else {

              cast1 = " (";
              cast2 = ").";
          
          
          }


          listofErrX.Add(new ErrorMessageBlock(functionName, false, Type, listOfFunction.IndexOf((String)functionName), errDescribeField[((int)Type).ToString()] + cast1 + ReasonOfError + cast2));
        
        }

        private void ExportErrors() {

            bool[] zastoupeneHodnoty = new bool[20] { false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false };
            List<ErrorMessageBlock> tempX = new List<ErrorMessageBlock>();
                    
          List<String> listOfFunction = new List<String>();

          listOfFunction.Add("UsbSendData");
          listOfFunction.Add("CircuitEcho");
          listOfFunction.Add("SendSingleDataToEEPROM");
          listOfFunction.Add("SendSingleDataToRAM");
          listOfFunction.Add("GetSingleDataFromEEPROM");
          listOfFunction.Add("GetSingleDataFromRAM");
          listOfFunction.Add("SendAllValuesToEEPROM");
          listOfFunction.Add("SendAllValuesToRAM");
          listOfFunction.Add("GetAllValuesFromRAM");
          listOfFunction.Add("GetAllValuesFromEEPROM");

            if (listofErrX.Count != 0) { 
            
            //Není prázdný
                for (i = 0; i < listofErrX.Count; i++) {

                    if (listofErrX[i].StatusOfFunction == false) {

                        zastoupeneHodnoty[(listofErrX[i].NumberOfFunction)] = true;
                    
                    }
                
                }

                //Zbyly tam hodnoty, ktere to maji dobre

                for (i = 0; i < 10; i++)
                {

                    if (zastoupeneHodnoty[i] == false)
                    {

                        listofErrX.Add(new ErrorMessageBlock(listOfFunction[i],true,(int)Constans.NotDefined,i,""));

                    }

                }
            
            
        
        //ted to potřebuje setřídit podle number of functions (hierarchicky)
            j = 0;

            while (true) {
 
            for (i = 0; i < listofErrX.Count; i++) {

                if (listofErrX[i].NumberOfFunction == j) {

                    tempX.Add(listofErrX[i]);
                    j++;
                
                }
            
            }
            if (j == 10) {

                break;
            
            }

            }

                //Předání události
            ErrorMessageHandlerStatusMake(new ErrorMessageEventArgs(new ErrorMessage(tempX)));

            listofErrX.Clear();
            }
          
        }

        

        public int CountOfElementsOfDataGSX
        {

            get {

                return CountOfElementsByte;
            
            }
            set {

                this.CountOfElementsByte = value;
            
            }
        
        }
       




        //Pošleme příkaz a chceme si ověřit zda-li dorazil do zařízení, toto ověření zaručí návratová hodnota fce, která musí být v případě úspěchu větší jak 0, navíc do bufferu se dá lecos uložit a poslat zpět, ale tuším jen 1B

        //public int UsbRecieveBuffer(char request, short value, short index, IntPtr buffer, short LengthOfBuffer)
        public bool UsbSendData(byte request, byte adress, byte value, out List<byte> vystup, uint baudrate, byte DataBits, byte StopBits, byte Parity, ushort FlowCtrlType, byte FCtrlXon,byte FCtrlXoff, uint ReadTimeOut,uint WriteTimeOut)   
        {

            //myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE) == FTDI.FT_STATUS.FT_OK)
            //ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13); ReadTO = 5000; WriteTO = 0;
            //5-Bytový protokol
            bool repeat = false;
            int countOfRepeat = 0;


            bool returnval = true;
            vystup = new List<byte>();
            listofErrX.Clear();
            FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;

            UInt32 ftdiDeviceCount = 0;

            // Check status
            ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
            if (ftStatus == FTDI.FT_STATUS.FT_OK)
            {
                if ((ftdiDeviceCount == 0) && (ActiveDeviceLoc != 999999))
                {
                    EmptyDeviceHandlerStatusMake();
                }

                if (ftdiDeviceCount != 0)
                {

                    FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];

                    ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
                    if (ftStatus == FTDI.FT_STATUS.FT_OK)
                    {

                        if (DeviceIsSet == true)
                        {
                            ftStatus = myFtdiDevice.OpenByLocation(ActiveDeviceLoc);
                            
                            if (ftStatus == FTDI.FT_STATUS.FT_OK)
                            {
                                ftStatus = myFtdiDevice.SetBaudRate(baudrate); 
                                if (ftStatus == FTDI.FT_STATUS.FT_OK)
                                {
                                    // Set data characteristics - Data bits, Stop bits, Parity
                                    ftStatus = myFtdiDevice.SetDataCharacteristics(DataBits, StopBits, Parity);
                                    if (ftStatus == FTDI.FT_STATUS.FT_OK)
                                    {

                                        ftStatus = myFtdiDevice.SetFlowControl(FlowCtrlType, FCtrlXon, FCtrlXoff);
                                        if (ftStatus == FTDI.FT_STATUS.FT_OK)
                                        {
                                            ftStatus = myFtdiDevice.SetTimeouts(ReadTimeOut, WriteTimeOut);
                                            if (ftStatus == FTDI.FT_STATUS.FT_OK)
                                            {


                                            REPEAT:
                                                UInt32 numBytesWritten = 0;
                                                // Note that the Write method is overloaded, so can write string or byte array data

                                            ftStatus = myFtdiDevice.Write(new byte[] { 0xFF, request, adress, value, 0xFF }, (new byte[] { 0xFF, request, adress, value, 0xFF }).Length, ref numBytesWritten);
                                                if (ftStatus == FTDI.FT_STATUS.FT_OK)
                                                {


                                                    UInt32 numBytesAvailable = 0;
                                                    double checkval = ConvertToUnixTimestamp(DateTime.Now);
                                                    bool crash = false;

                                                    do
                                                    {
                                                        ftStatus = myFtdiDevice.GetRxBytesAvailable(ref numBytesAvailable);
                                                        if (ftStatus == FTDI.FT_STATUS.FT_OK)
                                                        {

                                                        }
                                                        else { 
                                                        
                                                        
                                                        }

                                                        Thread.Sleep(10);

                                                        if ((checkval + 5) < ConvertToUnixTimestamp(DateTime.Now)) {

                                                            crash = true;
                                                            break;
                                                        
                                                        }

                                                    } while (numBytesAvailable < (new byte[] { 0xFF, request, adress, value, 0xFF }).Length);

                                                    if (crash == true) {

                                                        ProtocolCrashStatusMake();
                                                        returnval = false;
                                                        crash = false;

                                                    }

                                                    byte[] readData = new byte[] { 0x00, 0x00, 0x00, 0x00, 0x00 };

                                                    byte lineStatus = 0x00;
                                                    FTDI.FT_STATUS errorCheck_ftStatus = FTDI.FT_STATUS.FT_OK;
                                                    UInt32 numBytesRead = 0;
                                                    // Note that the Read method is overloaded, so can read string or byte array data

                                                    errorCheck_ftStatus = myFtdiDevice.GetLineStatus(ref lineStatus);
                                                    ftStatus = myFtdiDevice.Read(readData, numBytesAvailable, ref numBytesRead);
                                                    if ((ftStatus == FTDI.FT_STATUS.FT_OK) && (errorCheck_ftStatus == FTDI.FT_STATUS.FT_OK))
                                                    {
                                                        //Atmel poslal data s chybou parit nebo rámce nebo přetečení
                                                        if(GetSingleBitFromByte(lineStatus,1)||GetSingleBitFromByte(lineStatus,2)||GetSingleBitFromByte(lineStatus,3))
                                                        {

                                                            AddError((byte)Erors.UsbDeviceReadErrFromAtmel, "UsbSendData", ftStatus.ToString());
                                                            returnval = false;
                                                        
                                                        }
                                                        else
                                                        {
                                                        //Atmel poslal data správně
                                                        if (readData[1] == (byte)MsgReturns.msgOK)
                                                        {

                                                            for (int i = 0; i < readData.Length; i++)
                                                            {


                                                                vystup.Add(readData[i]);

                                                            }


                                                        }
                                                        else
                                                        {

                                                            if (readData[1] == (byte)MsgReturns.msgErr)
                                                            {

                                                                countOfRepeat++;

                                                                //chyba parity asi předešlého přenosu
                                                                if (repeat == false)
                                                                {

                                                                    repeat = true;

                                                                }
                                                                else
                                                                {

                                                                    if (countOfRepeat > 3)
                                                                    {
                                                                        repeat = false;
                                                                    }

                                                                }

                                                            }

                                                            if (repeat == true)
                                                            {

                                                                goto REPEAT;

                                                            }

                                                            AddError((byte)Erors.UsbDeviceReadFrameSendErr, "UsbSendData", ftStatus.ToString());
                                                            returnval = false;

                                                        }
                                                    }
                                                        ftStatus = myFtdiDevice.Close(); 
                                                        if (ftStatus != FTDI.FT_STATUS.FT_OK)
                                                        {

                                                            AddError((int)Erors.UsbDeviceClosingFailed, "UsbSendData", ftStatus.ToString());
                                                            returnval = false;

                                                        }
                                                    }

                                                    else
                                                    {

                                                        AddError((int)Erors.UsbDeviceReadFailed, "UsbSendData", ftStatus.ToString());
                                                        returnval = false;
                                                    }
                                                }

                                                else
                                                {

                                                    AddError((int)Erors.UsbDeviceWriteFailed, "UsbSendData", ftStatus.ToString());
                                                    returnval = false;
                                                }
                                            }
                                            else
                                            {
                                                returnval = false;
                                                AddError((int)Erors.UsbDeviceTimeoutValFailed, "UsbSendData", ftStatus.ToString());

                                            }
                                        }
                                        else
                                        {
                                            returnval = false;
                                            AddError((int)Erors.UsbDeviceFlowCtrlFailed, "UsbSendData", ftStatus.ToString());

                                        }
                                    }

                                    else
                                    {
                                        returnval = false;
                                        AddError((int)Erors.UsbDeviceCharacterFailed, "UsbSendData", ftStatus.ToString());

                                    }
                                }
                                else
                                {
                                    returnval = false;
                                    AddError((int)Erors.UsbDeviceBaudrateFailed, "UsbSendData", ftStatus.ToString());

                                }
                            }
                            else
                            {
                                returnval = false;
                                AddError((int)Erors.CouldntOpenUsbDevice, "UsbSendData", ftStatus.ToString());

                            }
                        }
                        else { 
                        
                        //Není vybrané žádné zařízení
                            EmptyDeviceHandlerStatusMake();
                        
                        }
                    }
                    else { 
                        returnval= false;
                        AddError((int)Erors.CouldntDetectUsbDevice, "UsbSendData", ftStatus.ToString());
                    
                    }
                }
                else { 
                returnval= false;
                AddError((int)Erors.CouldntDetectUsbDevice, "UsbSendData", ftStatus.ToString());
                }
            }
            else
            {
                returnval= false;
                AddError((int)Erors.CouldntDetectUsbDevice, "UsbSendData", ftStatus.ToString());
            }

            return returnval;
        }

        public void Properties2Dictionary(object sender, PAOPropertiesChangedEventArgs e)
        {
            BytesMemory = new Dictionary<byte, byte>(e.Dictrprop);

            /*
            if (File.Exists("mem.txt")) {

                File.Delete("mem.txt");
            
            }

            TextWriter t = new StreamWriter("mem.txt");
            for (int i = 1; i <= 14; i++) {

                t.WriteLine(ControlRegisters.ConvertByteToStrAndCrop(BytesMemory[(byte)i], 8));
            
            }
            t.Close();
           */
            actual_conf = profiler.ConvertMemToXml(BytesMemory);

            ReloadThumbinalsHandlerStatusMake();
        }

        public double ConvertToUnixTimestamp(DateTime date)
        {
            TimeSpan span = date.Subtract(new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc));
            return Math.Floor(span.TotalSeconds);
        }

        public void DictToProp() {

            ControlRegisters.Dictionary2Properties(BytesMemory);
            ReloadSchemeGUIStatusMake();
        
        }

         //Zobrazení seznamu dostupných zařízení
         //Před otestováním připojení programátora bude nutné kliknout na položku seznamu Výběru zařízení
         //Do tohoto seznamu se budou zařízení načítat vždy po 5 sekundách, dokud na nějaké neklikneme

        public void FindFTDIDevice()
        {
            UInt32 ftdiDeviceCount = 0;
            List<ListOfFTDIs> list = new List<ListOfFTDIs>();
            FTDI.FT_STATUS ftStatus = FTDI.FT_STATUS.FT_OK;

            if (myFtdiDevice.IsOpen == false)
            {
                ftStatus = myFtdiDevice.GetNumberOfDevices(ref ftdiDeviceCount);
                if (ftStatus == FTDI.FT_STATUS.FT_OK)
                {
                    if (ftdiDeviceCount != 0)
                    {

                        FTDI.FT_DEVICE_INFO_NODE[] ftdiDeviceList = new FTDI.FT_DEVICE_INFO_NODE[ftdiDeviceCount];

                        ftStatus = myFtdiDevice.GetDeviceList(ftdiDeviceList);
                        if (ftStatus == FTDI.FT_STATUS.FT_OK)
                        {

                            for (int i = 0; i < ftdiDeviceCount; i++)
                            {
                                if (ftdiDeviceList[i].ID != 0)
                                {
                                    ListOfFTDIs itemOfL = new ListOfFTDIs((uint)i, ftdiDeviceList[i].LocId, ftdiDeviceList[i].ID, ftdiDeviceList[i].Description, ftdiDeviceList[i].SerialNumber);
                                    list.Add(itemOfL);
                                }
                                else {

                                    GetConnectedDevicesStatusMake(new FindedDevices(list, true, false, false, string.Empty, string.Empty));
                                
                                }

                            }

                            GetConnectedDevicesStatusMake(new FindedDevices(list, true, false, false,string.Empty,string.Empty));
                        }

                        else
                        {

                            GetConnectedDevicesStatusMake(new FindedDevices(list, false, true, false,ftStatus.ToString(),"GetDeviceList()"));

                        }

                    }

                    else
                    {

                        GetConnectedDevicesStatusMake(new FindedDevices(list, true, false, false,string.Empty,string.Empty));

                    }

                }
                else
                {

                    GetConnectedDevicesStatusMake(new FindedDevices(list, false, false, true,ftStatus.ToString(),"GetNumberOfDevices()"));

                }
            }

        }


        //Nyní již následují fce, které jistým způsobem znamenají náš program, to předtím jsou jen přípravy
        //Circuit echo je fce, která má zaručit, že připojení je správné, prakticky to, co přišlo v bufferu tam se odešle bufferem zpět, nezaručíme tím správnost chodu EEPROMky .... to by se mělo poznat tak, že něco zapíšeme, následně hodnotu přečteme a porovnáme se zapisovanou
        //EEPROMku ničí zapisování, nikoliv čtení !!!!!

             //myFtdiDevice.SetDataCharacteristics(FTDI.FT_DATA_BITS.FT_BITS_8, FTDI.FT_STOP_BITS.FT_STOP_BITS_1, FTDI.FT_PARITY.FT_PARITY_NONE) == FTDI.FT_STATUS.FT_OK)
            //ftStatus = myFtdiDevice.SetFlowControl(FTDI.FT_FLOW_CONTROL.FT_FLOW_RTS_CTS, 0x11, 0x13); ReadTO = 5000; WriteTO = 0;
            //5-Bytový protokol


        //Nově !!!!!!! 21.1.2013 -> vracející se rámec byl po úvaze změněn .... 0xFF, kód návratu (0x01,0x02), par1,par2,0xFF

        public bool CircuitEcho()
        {
            bool test = false;

          List<Byte> buffer = new List<Byte>();

            byte ValueForConnectionTest = 12;
           
            CircuitEchoingHandlerStatusMake(new CircuitEchoingEventArgs(new TransferRes((int)CommandTypes.CircuitEcho, DateTime.Now)));

           
            if(UsbSendData((byte)CommandTypes.CircuitEcho,(byte)0x00,ValueForConnectionTest,out buffer,baudrate, DataBits, StopBits,  Parity, FlowCtrlType, FCtrlXon, FCtrlXoff, ReadTimeOut,WriteTimeOut) == true)
            {

                test = (buffer[2] == ValueForConnectionTest); //číslo menší 254
                
            }
            else
            {
                AddError((int)Erors.EchoTestFailed,"CircuitEcho",String.Empty);
                test = false;

            }

            

            CircuitEchoedHandlerStatusMake(new CircuitEchoedEventArgs(new TransferRes((int)CommandTypes.CircuitEcho, DateTime.Now, (int)Constans.NotDefined, (int)Constans.NotDefined, test)));

            ExportErrors();
            return test;
        }
        
        private bool SendSingleDataToEEPROM(byte adress)
        {
            bool result = false;
            List<Byte> buffer = new List<byte>();
            //Value v USBCtrlTransfer je 2B, adresace eepromky je 128 hodnot po 1B, tedy na zakódování adresy se hodí 1B a na hodnotu též 1B
            //Úkolem je shovat do 2B Value adresu i hodnotu zápisu do EEPROMky
            if (BytesMemory.ContainsKey(adress))
            {
               SendingByteToEEPROMHandlerStatusMake(new SendingByteToEEPROMEventArgs(new TransferRes((int)CommandTypes.WriteByteToEEPROM,DateTime.Now,(int)adress,(int)BytesMemory[adress])));



                    if (UsbSendData((byte)CommandTypes.WriteByteToEEPROM, adress, BytesMemory[adress], out buffer, baudrate, DataBits, StopBits, Parity, FlowCtrlType, FCtrlXon, FCtrlXoff, ReadTimeOut, WriteTimeOut) == true)
                {

                    //Pokud data dorazila v pořádku, můžeme si je nechat odeslat zpět a porovnat s daty odesílanými :-).
                    //Ideálně by bylo dobré data uložit, a zkusit poslat ne data obdržená, ale data po zapsání přečtená ---> rapidně snížíme životnost EEPROMky
                    result = ((buffer[3]  == adress) && (buffer[2] == BytesMemory[adress]));// buffer[2] = ADRESA, buffer[1]=DATA

                }
                else
                {
                    AddError((int)Erors.UsbSendDataFunctionFailed, "SetSingleDataToEEPROM",String.Empty);
                    result = false;

                }

                SendedByteToEEPROMHandlerStatusMake(new SendedByteToEEPROMEventArgs(new TransferRes((int)CommandTypes.WriteByteToEEPROM, DateTime.Now, (int)adress, (int)BytesMemory[adress], result)));


            }
            else {

                AddError((int)Erors.NotExistKeyInDictionary, "SetSingleDataToEEPROM",String.Empty);
                result = false;
            
            }
            return result;

        }

        private bool GetSingleDataFromEEPROM(byte adress)
        {
            bool result = false;
            List<Byte> buffer = new List<Byte>();
            //Value v USBCtrlTransfer je 2B, adresace eepromky je 128 hodnot po 1B, tedy na zakódování adresy se hodí 1B a na hodnotu též 1B
            //Úkolem je shovat do 2B Value adresu i hodnotu zápisu do EEPROMky
        
                RecivingByteFromEEPROMHandlerStatusMake(new RecivingByteFromEEPROMEventArgs(new TransferRes((int)CommandTypes.ReadByteFromEEPROM,DateTime.Now,adress)));



            if (UsbSendData((byte)CommandTypes.ReadByteFromEEPROM, adress, 0, out buffer, baudrate, DataBits, StopBits, Parity, FlowCtrlType, FCtrlXon, FCtrlXoff, ReadTimeOut, WriteTimeOut) == true)
            {


                //Pokud data dorazila v pořádku, můžeme si je nechat odeslat zpět a porovnat s daty odesílanými :-).
                //Ideálně by bylo dobré data uložit, a zkusit poslat ne data obdržená, ale data po zapsání přečtená ---> rapidně snížíme životnost EEPROMky
                //Pokud čtení dopadlo v pořádku, bude v 3B naplněn číslem 0xFF (11111111)
                // buffer[0]=MSGOK, buffer[1]=DATA,buffer[2] = ~buffer[1];
                if (buffer[2] == NegateByte(buffer[3]))
                {
                    BytesMemory[adress] = (byte)buffer[2];
                    result = true;

                }
                else {

                    AddError((int)Erors.ControlNegationTestFailed, "GetSingleDataFromEEPROM",String.Empty);
                
                }


                    RecivedByteFromEEPROMHandlerStatusMake(new RecivedByteFromEEPROMEventArgs(new TransferRes((int)CommandTypes.ReadByteFromEEPROM,DateTime.Now,adress,BytesMemory[adress],result)));

            }
            else
            {
                AddError((int)Erors.UsbSendDataFunctionFailed, "GetSingleDataFromEEPROM",String.Empty);
                result = false;

            }
            return result;

        }

        //Programování Programovatelného Analogového obvodu (PAO) bude poněkud komplikovaná fce, která si zajistí pochopení na straně uC, nemá cenu řešit to dálkovým ovládáním portů přes USB příkazy
        //Fce se stvoří uvnitř firmwaru a do PAO se pouze zapíší data v určitém uspořádání a systému, podle přesně definovaných konstant se skrytým významem z paměti EEPROM (například na adrese 0x05 bude hodnota pro spínače uvnitř PAO (8 bitů bude logicky představovat sepnutí/rozepnutí 8 spínačů uvnitř PAO), fce bude muset zajistit, aby logicky interpretovala byte na adrese 0x05 jako ten co ovládá spínače a podle nějakého schématu tak ty spínače přes vnější rozhranní na PAO sepla/rozepla)

        //Co když se nám nebude zdát pořád ,,ničit" při každém použití EEPROMku dobré, a budeme chtít údaje schovat pouze v RAMce, tedy pokud vypadne napájení, bude nám jejich osud volný
        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
        //Předtím jsme definovali fce, které dokáží zapsat a přečíst libovolný Byte z adresy, kterou zadáme/požadujeme
        //Co když ale zapojení budeme pouze testovat a chceme data uložit pouze do pole char uvnitř RAM?

        //Organizace DAT v EEPROMce je -  skrz adresu obdržíme určitý Byte
        //Organizace DAT v RAMce je - skrz index zapíšeme určitý Byte ----> nebudeme chtít nic obrdržet, skladbu dat máme uloženou v poli DATABYTETOWRITE

        //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

        //Zápis dat do RAMky (skrz index), uspořádání dat v ramce je jen skrz index (pole char), které souhlasí s polem zde ve tříde

        private bool SendSingleDataToRAM(byte adress)
        {
            bool result = false;
            List<Byte> buffer = new List<Byte>();
            //Value v USBCtrlTransfer je 2B, pole char v ramce bude 1B, s indexací položek -> indexace bude max. 1B, hodnota 1B 
            //Úkolem je shovat do 2B Value index i hodnotu zápisu do pole char

            if (BytesMemory.ContainsKey(adress))
            {
                    SendingByteToRAMHandlerStatusMake(new SendingByteToRAMEventArgs(new TransferRes((int)CommandTypes.WriteByteToRAM,DateTime.Now,adress,BytesMemory[adress])));


                    if (UsbSendData((byte)CommandTypes.WriteByteToRAM, adress, BytesMemory[adress], out buffer, baudrate, DataBits, StopBits, Parity, FlowCtrlType, FCtrlXon, FCtrlXoff, ReadTimeOut, WriteTimeOut) == true)
                {

                    //Pokud data dorazila v pořádku, můžeme si je nechat odeslat zpět a porovnat s daty odesílanými :-).
                    //Ideálně by bylo dobré data uložit, a zkusit poslat ne data obdržená, ale data po zapsání přečtená ---> rapidně snížíme životnost EEPROMky
                    result = ((buffer[3]  == adress) && (buffer[2] == BytesMemory[adress]));// buffer[2] = INDEX, buffer[1]=DATA

                }
                else
                {
                    AddError((int)Erors.UsbSendDataFunctionFailed, "SendSingleDataToRAM",String.Empty);
                    result = false;

                }

                    SendedByteToRAMHandlerStatusMake(new SendedByteToRAMEventArgs(new TransferRes((int)CommandTypes.WriteByteToRAM,DateTime.Now,adress,BytesMemory[adress],result)));

               
                    
            }
            else {

                AddError((int)Erors.NotExistKeyInDictionary, "SendSingleDataToRAM",String.Empty);
                result = false;
            
            }
            return result;

        }

        public bool GetSingleBitFromByte(byte SingleByte, int SearchedbitNumber)
        {
            return (SingleByte & (1 << SearchedbitNumber)) != 0;
        }

        public byte ConvertBitsToByte(List<bool> bitList)
        {
            byte resultByte = 0;

            for (byte i = 0; i < bitList.Count; i++)
            {
                if (bitList[i] == true)
                {
                    resultByte |= (byte)(1 << i);
                }
            }

            return resultByte;
        }

        public byte NegateByte(byte inp) {

            List<bool> list = new List<bool>();

            for (int i = 0; i < 8; i++) {

                list.Add(!GetSingleBitFromByte(inp, i));
            
            }
            return ConvertBitsToByte(list);
        
        }

        private bool GetSingleDataFromRAM(byte adress)
        {
            bool result = false;
            List<Byte> buffer = new List<Byte>();
            //Value v USBCtrlTransfer je 2B, adresace eepromky je 128 hodnot po 1B, tedy na zakódování adresy se hodí 1B a na hodnotu též 1B
            //Úkolem je shovat do 2B Value adresu i hodnotu zápisu do EEPROMky
            
                RecivingByteFromRAMHandlerStatusMake(new RecivingByteFromRAMEventArgs(new TransferRes((int)CommandTypes.ReadByteFromRAM,DateTime.Now,adress)));

                if (UsbSendData((byte)CommandTypes.ReadByteFromRAM, adress,0, out buffer, baudrate, DataBits, StopBits, Parity, FlowCtrlType, FCtrlXon, FCtrlXoff, ReadTimeOut, WriteTimeOut) == true)
            {

                //Pokud data dorazila v pořádku, můžeme si je nechat odeslat zpět a porovnat s daty odesílanými :-).
                //Ideálně by bylo dobré data uložit, a zkusit poslat ne data obdržená, ale data po zapsání přečtená ---> rapidně snížíme životnost EEPROMky
                //Pokud čtení dopadlo v pořádku, bude v 3B naplněn číslem 0xFF (11111111)
                // buffer[0]=MSGOK, buffer[1]=DATA,buffer[2] = ~buffer[1];
                //if (((uint)buffer[2]) == ~((uint)buffer[3]))
               if (buffer[2] == NegateByte(buffer[3]))
                {
                    BytesMemory[adress] = (byte)buffer[2];
                    result = true;

                }
                else
                {

                    AddError((int)Erors.ControlNegationTestFailed, "GetSingleDataFromRAM",String.Empty);

                }

               RecivedByteFromRAMHandlerStatusMake(new RecivedByteFromRAMEventArgs(new TransferRes((int)CommandTypes.ReadByteFromRAM,DateTime.Now,adress,BytesMemory[adress],result)));

            }
            else
            {
                AddError((int)Erors.UsbSendDataFunctionFailed, "GetSingleDataFromRAM",String.Empty);
                result = false;

            }
            return result;

        }

        //Pokud by náhodou vypadlo napájení, chtělo by to, aby se data v ramce v poli char[] uložila do EEPROM dřív, než procesor ztratí kontrolu nad svými fcemi.
        //Zde něco nastavíme ve schématu, zapíseme do pole DataByteToWrite, následně zapíšeme nové nastavení do pole char[] v paměti RAM uC, a pokud budeme chtít, uložíme konfiguraci do EEPROMky v uC, odkud si ji můžeme kdykoliv znovu načíst
        //Při zapnutí uC by měl bez větších problémů sám umět obnovit nastavení pole char[] ve své RAMce z EEPROMky a následně naprogramovat PAO 

        /*

       public bool SendAllValuesToRAM() {
           bool subresult = false;
           bool result = false;
           int counter = 0;

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if (SendSingleDataToRAM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {
                       while (true)
                       {

                           subresult = SendSingleDataToRAM((Byte)i);
                           if ((counter <= 3) && (subresult == true))
                           {

                               result = true;
                               break;
                           }
                           if ((counter > 3) && (subresult == false))
                           {

                               result = false;
                               break;
                           }

                           counter++;

                       }
                       if ((counter > 3) && (result = false))
                       {

                           AddError((int)Erors.WriteManyValuesToRAM, "SendAllValuesToRAM");
                           break;

                       }

                       else
                       {


                           //pokračuj dál ;-)

                       }

                   }

           }

           return result;
       }

       public bool SendAllValuesToEEPROM()
       {
           bool subresult = false;
           bool result = false;
           int counter = 0;

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if (SendSingleDataToEEPROM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {
                       while (true) {

                           subresult = SendSingleDataToEEPROM((Byte)i);
                           if ((counter <= 3) && (subresult == true))
                           {

                               result = true;
                               break;
                           }
                           if ((counter > 3) && (subresult == false)){

                               result = false;
                               break;
                           }
                        
                       counter++;

                       }
                   if ((counter > 3) && (result = false)) {

                       AddError((int)Erors.WriteManyValuesToEEPROM, "SendAllValuesToEEPROM");
                   break;
                            
                   }

                   else{
                    
                    
                   //pokračuj dál ;-)
                    
                   }

                   }

                    

                   }

           return result;
       }


       public bool GetAllValuesFromEEPROM()
       {
           bool subresult = false;
           bool result = false;
           int counter = 0;

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if (GetSingleDataFromEEPROM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {
                       while (true)
                       {

                           subresult = GetSingleDataFromEEPROM((Byte)i);
                           if ((counter <= 3) && (subresult == true))
                           {

                               result = true;
                               break;
                           }
                           if ((counter > 3) && (subresult == false))
                           {

                               result = false;
                               break;
                           }

                           counter++;

                       }
                       if ((counter > 3) && (result = false))
                       {

                           AddError((int)Erors.ReadManyValuesFromEEPROM, "GetAllValuesFromEEPROM");
                           break;

                       }

                       else
                       {


                           //pokračuj dál ;-)

                       }

                   }



               }

           return result;
       }

        

       public bool GetAllValuesFromRAM()
       {
           bool subresult = false;
           bool result = false;
           int counter = 0;


               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if (GetSingleDataFromRAM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {
                       while (true)
                       {

                           subresult = GetSingleDataFromRAM((Byte)i);
                           if ((counter <= 3) && (subresult == true))
                           {

                               result = true;
                               break;
                           }
                           if ((counter > 3) && (subresult == false))
                           {

                               result = false;
                               break;
                           }

                           counter++;

                       }
                       if ((counter > 3) && (result = false))
                       {

                           AddError((int)Erors.ReadManyValuesFromRAM, "GetAllValuesFromRAM");
                           break;

                       }

                       else
                       {


                           //pokračuj dál ;-)

                       }

                   }



               }

           return result;
       }

       */


       public bool SendAllValuesToRAM() {
         
           bool result = false;

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if (ControlRegisters.enabledData.Contains(i))
                   {
                       if (SendSingleDataToRAM((Byte)i) == true)
                       {

                           result = true;

                       }
                       else
                       {

                           result = false;
                           break;

                       }


                       LoadProgressBarInfoStatusMake(new ProgressBarInfoArgs(i, result));
                   }  
                }

          

           return result;
       }

       public bool SendAllValuesToEEPROM()
       {
          
           bool result = false;

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if (ControlRegisters.enabledData.Contains(i))
                   {

                   if (SendSingleDataToEEPROM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {

                       result = false;
                       break;

                   }
                   
                       LoadProgressBarInfoStatusMake(new ProgressBarInfoArgs(i, result));

                   }
                   
               }
               
           return result;
       }


       public bool GetAllValuesFromEEPROM()
       {
          
            bool result = false;
       

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {
                   if(ControlRegisters.enabledData.Contains(i)){

                   if (GetSingleDataFromEEPROM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {
                       result = false;
                       break;

                   }
                   
                       LoadProgressBarInfoStatusMake(new ProgressBarInfoArgs(i, result));

                   }
                   
                   
               }
           
           return result;
       }

        

       public bool GetAllValuesFromRAM()
       {
           bool result = false;
         

               for (i = lowBorderAddress; i <= hightBorderAddress; i++)
               {

                   if(ControlRegisters.enabledData.Contains(i)){

                   if (GetSingleDataFromRAM((Byte)i) == true)
                   {

                       result = true;

                   }
                   else
                   {
                       result = false;
                       break;
                   }
                   
                       LoadProgressBarInfoStatusMake(new ProgressBarInfoArgs(i, result));

                   }
                   
                   
               }
               
           return result;
       }

       

        //_--------------------------------------------------------------
        public bool ProgrammPAOFromRAM()
        {
            
            bool result = false;
            List<Byte> buffer = new List<Byte>();
            //Value v USBCtrlTransfer je 2B, pole char v ramce bude 1B, s indexací položek -> indexace bude max. 1B, hodnota 1B 
            //Úkolem je shovat do 2B Value index i hodnotu zápisu do pole char

         
            ProgrammingPAOHandlerStatusMake(new ProgrammingPAOEventArgs(new TransferRes((int)CommandTypes.ProgrammPAOFromRAM,DateTime.Now,(int)Constans.NotDefined)));


            if (UsbSendData((byte)CommandTypes.ProgrammPAOFromRAM, 0, 0, out buffer, baudrate, DataBits, StopBits, Parity, FlowCtrlType, FCtrlXon, FCtrlXoff, ReadTimeOut, WriteTimeOut) == true)
            {
         
                //Pokud data dorazila v pořádku, můžeme si je nechat odeslat zpět a porovnat s daty odesílanými :-).
                //Ideálně by bylo dobré data uložit, a zkusit poslat ne data obdržená, ale data po zapsání přečtená ---> rapidně snížíme životnost EEPROMky
                result = (buffer[2] == 0xEE);// buffer[0] = MSGOK, buffer[2]=0xEE XXX 0xBB (jiné než 0xFF)

                    ProgrammedPAOHandlerStatusMake(new ProgrammedPAOEventArgs(new TransferRes((int)CommandTypes.ProgrammPAOFromRAM,DateTime.Now,(int)Constans.NotDefined,(int)Constans.NotDefined,result)));

            }
            else
            {
                AddError((int)Erors.UsbSendDataFunctionFailed, "ProgramPAOFromRAM",String.Empty);
                result = false;

            }
            
            return result;

        }

    }
}
