Sixdegreeoffreedomdynamicloadsimulationdevice/NIFPGA/FPGA.cs

using FxpConvert.Common;
using NIFPGA.lvbitx;

namespace NIFPGA
{
    public sealed class FPGA
    {
        public string BitstreamMD5 { get; private set; } = string.Empty;
        public string BitfileVersion { get; private set; } = string.Empty;
        public string SignatureRegister { get; private set; } = string.Empty;
        public string BitstreamVersion { get; private set; } = string.Empty;
        public string SignatureNames { get; private set; } = string.Empty;
        private List<Fifo> fifos= new List<Fifo>();
        private IFxpConvert _FXPConvert;
        private List<FPGABaseProperty> properties= new List<FPGABaseProperty>();

        public IReadOnlyDictionary<String,Fifo> Fifos => fifos.ToDictionary(x=>x.Name);
        public IReadOnlyDictionary<String,FPGABaseProperty> Properties=> properties.ToDictionary(x=>x.Name);
        private FPGASession session;
        public Boolean Error=> session.Error;
        public NiFpga_Status LastStatus=> session.LastStatus;
        public string Message=>session.Message;
        public FPGA(IFxpConvert convert)
        {
            _FXPConvert = convert;
            session = new FPGASession();
            Irq = new Irq(session);
        }
        public T CreateProperty<T>(string name) where T :FPGABaseProperty
        {
            var pro = properties.FirstOrDefault(x => x.Name == name);
            if (pro == null) throw new Exception($"Property {name} not found");
            return (T)pro;
        }
        public T CreateFifo<T>(string name) where T:Fifo
        {
            var fifo = fifos.FirstOrDefault(x => x.Name == name);
            if (fifo == null) throw new Exception($"Fifo {name} not found");
            return (T)fifo;
        }
        public void Parse(string path)
        {
            var val = lvbitx.Parse.ParseFile(path);
            InitProperies(val.VI.Registers);
            InitFifo(val.Project.DMA);
        }
        
        private void InitFifo(List<DMA> dma)
        {
            if (dma == null || dma.Count == 0) return;
            dma.ForEach(x =>
            {
                switch(x.Direction)
                {
                    case "TargetToHost"://read
                        switch (x.Datatype)
                        {
                            case Datatype.Boolean:
                                fifos.Add(new ReadFifo<bool>(session, x));
                                break;
                            case Datatype.Int8:
                                fifos.Add(new ReadFifo<sbyte>(session, x));
                                break;
                            case Datatype.Uint8:
                                fifos.Add(new ReadFifo<byte>(session, x));
                                break;
                            case Datatype.Int16:
                                fifos.Add(new ReadFifo<short>(session, x));
                                break;
                            case Datatype.Uint16:
                                fifos.Add(new ReadFifo<ushort>(session, x));
                                break;
                            case Datatype.Int32:
                                fifos.Add(new ReadFifo<int>(session, x));
                                break;
                            case Datatype.Uint32:
                                fifos.Add(new ReadFifo<uint>(session, x));
                                break;
                            case Datatype.Int64:
                                fifos.Add(new ReadFifo<long>(session, x));
                                break;
                            case Datatype.Uint64:
                                fifos.Add(new ReadFifo<ulong>(session, x));
                                break;
                            case Datatype.Float:
                                fifos.Add(new ReadFifo<float>(session, x));
                                break;
                            case Datatype.Double:
                                fifos.Add(new ReadFifo<double>(session, x));
                                break;
                            case Datatype.FXP:
                                fifos.Add(new ReadFXPFifo(session, x, _FXPConvert));
                                break;
                            case Datatype.Array:
                                break;
                        }
                        break;
                    case "HostToTarget"://write
                        switch (x.Datatype)
                        {
                            case Datatype.Boolean:
                                fifos.Add(new WriteFifo<bool>(session, x));
                                break;
                            case Datatype.Int8:
                                fifos.Add(new WriteFifo<sbyte>(session, x));
                                break;
                            case Datatype.Uint8:
                                fifos.Add(new WriteFifo<byte>(session, x));
                                break;
                            case Datatype.Int16:
                                fifos.Add(new WriteFifo<short>(session, x));
                                break;
                            case Datatype.Uint16:
                                fifos.Add(new WriteFifo<ushort>(session, x));
                                break;
                            case Datatype.Int32:
                                fifos.Add(new WriteFifo<int>(session, x));
                                break;
                            case Datatype.Uint32:
                                fifos.Add(new WriteFifo<uint>(session, x));
                                break;
                            case Datatype.Int64:
                                fifos.Add(new WriteFifo<long>(session, x));
                                break;
                            case Datatype.Uint64:
                                fifos.Add(new WriteFifo<ulong>(session, x));
                                break;
                            case Datatype.Float:
                                fifos.Add(new WriteFifo<float>(session, x));
                                break;
                            case Datatype.Double:
                                fifos.Add(new WriteFifo<double>(session, x));
                                break;
                            case Datatype.FXP:
                                fifos.Add(new WriteFXPFifo(session, x, _FXPConvert));
                                break;
                            case Datatype.Array:
                                break;
                        }
                        break;
                }
            });
        }
        public Irq Irq { get; }
        public void Open(string bitfile, string resource, NiFpga_OpenAttribute attribute)
        {
            var lv = lvbitx.Parse.ParseFile(bitfile);
            BitfileVersion = lv.BitfileVersion;
            SignatureNames = lv.SignatureNames;
            SignatureRegister= lv.SignatureRegister;
            BitstreamMD5 = lv.BitstreamMD5;
            BitstreamVersion = lv.BitstreamVersion;
            InitProperies(lv.VI.Registers);
            InitFifo(lv.Project.DMA);
            session.Open(bitfile, lv.SignatureRegister, resource, attribute);
            var indicator = properties.Select(x => x.Register).ToArray();
        }
        private void InitProperies(List<lvbitx.Register> registers)
        {
            if (registers == null || registers.Count == 0) return;

            foreach (var reg in registers)
            {
                switch (reg.Datatype)
                {
                    case lvbitx.Datatype.Int16:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<short>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<short>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Boolean:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<bool>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<bool>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Int8:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<sbyte>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<sbyte>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Uint8:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<byte>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<byte>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Uint16:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<ushort>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<ushort>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Int32:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<int>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<int>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Uint32:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<uint>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<uint>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Int64:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<long>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<long>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Uint64:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<ulong>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<ulong>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Float:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<float>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<float>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.Double:
                        if (!reg.Indicator)
                        {

                            properties.Add(new FPGAWriteProperty<double>(session, reg));
                        }
                        else
                        {
                            properties.Add(new FPGAReadProperty<double>(session, reg));
                        }
                        break;
                    case lvbitx.Datatype.FXP:
                        if (!reg.Indicator)
                        {
                            properties.Add(new FPGAFXPWriteProperty(session, reg, _FXPConvert));
                        }
                        else
                        {
                            properties.Add(new FPGAFXPReadProperty(session, reg, _FXPConvert));
                        }
                        break;
                    case lvbitx.Datatype.Array:
                        switch (reg.ArrayValueType)
                        {
                            case lvbitx.Datatype.Boolean:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<bool>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<bool>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Int8:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<sbyte>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<sbyte>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Uint8:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<byte>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<byte>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Int16:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<short>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<short>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Uint16:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<ushort>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<ushort>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Int32:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<int>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<int>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Uint32:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<uint>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<uint>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Int64:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<long>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<long>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Uint64:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<ulong>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<ulong>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Float:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<float>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<float>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.Double:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayWriteProperty<double>(session, reg));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayReadProperty<double>(session, reg));
                                }
                                break;
                            case lvbitx.Datatype.FXP:
                                if (!reg.Indicator)
                                {
                                    properties.Add(new FPGAArrayFXPWriteProperty(session, reg,_FXPConvert));
                                }
                                else
                                {
                                    properties.Add(new FPGAArrayFXPReadProperty(session, reg,_FXPConvert));
                                }
                                break;
                            case lvbitx.Datatype.Array:
                                break;
                        }
                        break;
                }
            }
        }
        public void Close()=>session.Close();
        public void Run()
        {
            session.CheckResult(session.GetDelegate<Interop.NiFpgaDll_Run>()(session.Session, Interop.NiFpga_RunAttribute.NiFpga_RunAttribute_None));
        }
        public void Abort()
        {
            session.CheckResult(session.GetDelegate<Interop.NiFpgaDll_Abort>()(session.Session));
        }
        public void Reset()
        {
            session.CheckResult(session.GetDelegate<Interop.NiFpgaDll_Reset>()(session.Session));
        }
        public void Download()
        {
            session.CheckResult(session.GetDelegate<Interop.NiFpgaDll_Download>()(session.Session));
        }
        public void FpgaFinalize()
        {
            session.CheckResult(session.GetDelegate<Interop.NiFpgaDll_Finalize>()());
        }
    }
}