Beispiel #1
0
 void Status(string address, string state)
 {
     try
     {
         if (!Groups.ContainsKey(address))
         {
             var knxGroup = new KnxGroupWithStateDto
             {
                 Address = address,
                 Name    = address,
             };
             LogValue(knxGroup, state, false);
             using (var scope = _serviceProvider.CreateScope())
             {
                 var ctx = scope.ServiceProvider.GetService <BBDomDbContext>();
                 ctx.KnxGroups.Add(new KnxGroup
                 {
                     Address = address,
                     Name    = address,
                 });
                 ctx.SaveChanges();
             }
             Groups[address] = knxGroup;
             _logger.LogInformation("New Status: device {0} has state {1}", address, state);
         }
         else
         {
             var knxGroup = Groups[address];
             LogValue(knxGroup, state, false);
             using (var scope = _serviceProvider.CreateScope())
             {
                 var utcNow = DateTime.UtcNow;
                 var ctx    = scope.ServiceProvider.GetService <BBDomDbContext>();
                 ctx.KnxStates.Add(new KnxState
                 {
                     Address      = knxGroup.Address,
                     State        = knxGroup.State,
                     UTCTicks     = utcNow.Ticks,
                     UTCTimestamp = utcNow,
                     StateSource  = StateSource.STATUS,
                 });
                 ctx.SaveChanges();
             }
         }
     }
     catch (Exception ex)
     {
         _logger.LogError("Status, address {0}", address);
         _logger.LogError("Status, exception: {0}", string.Format("{0}{1}{2}", ex.Message, System.Environment.NewLine, ex.StackTrace));
     }
 }
Beispiel #2
0
        private void LogValue(KnxGroupWithStateDto knxGroup, string state, bool isEvent)
        {
            string stringFormat = string.Empty;

            if (!knxGroup.DPT.HasValue)
            {
                stringFormat = string.Format("New {0}: knxGroup {1} has state {2}", isEvent ? "Event" : "Status", knxGroup.Address, state);
            }
            else
            {
                switch (knxGroup.DPT.Value)
                {
                case KnxDPTEnum.PERCENTAGE:
                    decimal perc = (decimal)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.PERCENTAGE], state);
                    knxGroup.State = (double)perc;
                    stringFormat   = string.Format("knxGroup {0}, perc: {1}", knxGroup.Name, perc);
                    break;

                case KnxDPTEnum.TEMPERATURE:
                    decimal temp = (decimal)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.TEMPERATURE], state);
                    knxGroup.State = (double)temp;
                    stringFormat   = string.Format("knxGroup {0}, temp: {1}", knxGroup.Name, temp);
                    break;

                case KnxDPTEnum.SWITCH:
                    bool switchVal = (bool)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.SWITCH], state);
                    knxGroup.State = switchVal ? 1 : 0;
                    stringFormat   = string.Format("knxGroup {0}, switch: {1}", knxGroup.Name, switchVal ? "on" : "off");
                    break;

                case KnxDPTEnum.BOOLEAN:
                    bool booleanVal = (bool)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.SWITCH], state);
                    knxGroup.State = booleanVal ? 1 : 0;
                    stringFormat   = string.Format("knxGroup {0}, boolean: {1}", knxGroup.Name, booleanVal);
                    break;

                case KnxDPTEnum.UP_DOWN:
                    bool upDownVal = (bool)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.UP_DOWN], state);
                    knxGroup.State = upDownVal ? 1 : 0;
                    stringFormat   = string.Format("knxGroup {0}, upDown: {1}", knxGroup.Name, upDownVal ? "down" : "up");
                    break;

                case KnxDPTEnum.OPEN_CLOSE:
                    bool openCloseVal = (bool)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.OPEN_CLOSE], state);
                    knxGroup.State = openCloseVal ? 1 : 0;
                    stringFormat   = string.Format("knxGroup {0}, openClose: {1}", knxGroup.Name, openCloseVal ? "opened" : "closed");
                    break;

                case KnxDPTEnum.COUNTER_PULSES:
                    int counterPulsesVal = (int)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.COUNTER_PULSES], state);
                    knxGroup.State = (double)counterPulsesVal;
                    stringFormat   = string.Format("knxGroup {0}, counterPulsesVal: {1}", knxGroup.Name, counterPulsesVal);
                    break;

                case KnxDPTEnum.DIMMING_CONTROL:
                    int step = (int)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.DIMMING_CONTROL], state);
                    knxGroup.State = (double)step;
                    stringFormat   = string.Format("knxGroup {0}, step: {1}", knxGroup.Name, step);
                    break;

                case KnxDPTEnum.HVAC:
                    int hvac = (int)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.HVAC], state);
                    knxGroup.State = hvac;
                    switch (hvac)
                    {
                    case 0:
                        stringFormat = string.Format("knxGroup {0}, hvac: Auto", knxGroup.Name);
                        break;

                    case 1:
                        stringFormat = string.Format("knxGroup {0}, hvac: Comfort", knxGroup.Name);
                        break;

                    case 2:
                        stringFormat = string.Format("knxGroup {0}, hvac: Standby", knxGroup.Name);
                        break;

                    case 3:
                        stringFormat = string.Format("knxGroup {0}, hvac: Economy", knxGroup.Name);
                        break;

                    case 4:
                        stringFormat = string.Format("knxGroup {0}, hvac: Building Protection", knxGroup.Name);
                        break;

                    default:
                        stringFormat = string.Format("knxGroup {0}, hvac: {1}", knxGroup.Name, hvac);
                        break;
                    }
                    break;

                case KnxDPTEnum.HEAT_COOL:
                    bool heatCoolVal = (bool)_connection.FromDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.HEAT_COOL], state);
                    knxGroup.State = heatCoolVal ? 1 : 0;
                    stringFormat   = string.Format("knxGroup {0}, openClose: {1}", knxGroup.Name, heatCoolVal ? "heating" : "cooling");
                    break;

                default:
                    stringFormat = string.Format("New {0}: knxGroup {1} has state {2}", isEvent ? "Event" : "Status", knxGroup.Address, state);
                    break;
                }
            }
            _logger.LogInformation(stringFormat);
            Console.Out.WriteLine(stringFormat);
        }
Beispiel #3
0
        void Event(string address, string state)
        {
            try
            {
                if (!Groups.ContainsKey(address))
                {
                    var knxGroup = new KnxGroupWithStateDto
                    {
                        Address = address,
                        Name    = address,
                    };
                    LogValue(knxGroup, state, true);
                    using (var scope = _serviceProvider.CreateScope())
                    {
                        var utcNow = DateTime.UtcNow;
                        var ctx    = scope.ServiceProvider.GetService <BBDomDbContext>();
                        ctx.KnxGroups.Add(new KnxGroup
                        {
                            Address = address,
                            Name    = address,
                        });
                        ctx.SaveChanges();
                    }
                    Groups[address] = knxGroup;
                    _logger.LogInformation("New Event: device {0} has state {1}", address, state);
                }
                else
                {
                    var knxGroup = Groups[address];
                    switch (knxGroup.Address)
                    {
                    case "3/0/1":
                        DoUscitaCasaNotte();
                        break;

                    case "3/0/2":
                        DoUscitaCasaGiorno();
                        break;

                    case "3/0/3":
                        DoIngressoCasaGiorno();
                        break;

                    case "3/0/5":
                        DoSonno();
                        break;

                    default:
                        break;
                    }
                    LogValue(knxGroup, state, true);
                    using (var scope = _serviceProvider.CreateScope())
                    {
                        var utcNow = DateTime.UtcNow;
                        var ctx    = scope.ServiceProvider.GetService <BBDomDbContext>();
                        ctx.KnxStates.Add(new KnxState
                        {
                            Address      = knxGroup.Address,
                            State        = knxGroup.State,
                            UTCTicks     = utcNow.Ticks,
                            UTCTimestamp = utcNow,
                            StateSource  = StateSource.EVENT,
                        });
                        ctx.SaveChanges();
                    }
                }
            }
            catch (Exception ex)
            {
                _logger.LogError("Event, address {0}", address);
                _logger.LogError("Event, exception: {0}", string.Format("{0}{1}{2}", ex.Message, System.Environment.NewLine, ex.StackTrace));
            }
        }
Beispiel #4
0
        private void RequestStateChange(KnxGroupWithStateDto group)
        {
            switch (group.DPT.Value)
            {
            case KnxDPTEnum.BOOLEAN:
            {
                Console.Write("true/false: ");
                var  boolString = Console.In.ReadLine();
                bool boolState;
                if (bool.TryParse(boolString, out boolState))
                {
                    _connection.Action(group.Address, boolState);
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            case KnxDPTEnum.SWITCH:
            {
                Console.Write("on/off: ");
                var onOffString = Console.In.ReadLine();
                if (onOffString.ToLower() == "on".ToLower())
                {
                    _connection.Action(group.Address, true);
                }
                else if (onOffString.ToLower() == "off".ToLower())
                {
                    _connection.Action(group.Address, false);
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            case KnxDPTEnum.UP_DOWN:
            {
                Console.Write("up/down: ");
                var onOffString = Console.In.ReadLine();
                if (onOffString.ToLower() == "up".ToLower())
                {
                    _connection.Action(group.Address, false);
                }
                else if (onOffString.ToLower() == "down".ToLower())
                {
                    _connection.Action(group.Address, true);
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            case KnxDPTEnum.TEMPERATURE:
            {
                Console.Write("5..28: ");
                var    tempString = Console.In.ReadLine();
                double tempState;
                if (double.TryParse(tempString, NumberStyles.Any, CultureInfo.InvariantCulture, out tempState))
                {
                    _connection.Action(group.Address, _connection.ToDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.TEMPERATURE], tempString));
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            case KnxDPTEnum.OPEN_CLOSE:
            {
                Console.Write("open/closed: ");
                var openClosedString = Console.In.ReadLine();
                if (openClosedString.ToLower() == "open".ToLower())
                {
                    _connection.Action(group.Address, false);
                }
                else if (openClosedString.ToLower() == "closed".ToLower())
                {
                    _connection.Action(group.Address, true);
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            case KnxDPTEnum.COUNTER_PULSES:
            case KnxDPTEnum.DIMMING_CONTROL:
                Console.Out.WriteLine("DPT non gestito");
                break;

            case KnxDPTEnum.PERCENTAGE:
            {
                Console.Write("0..100: ");
                var    percString = Console.In.ReadLine();
                double percState;
                if (double.TryParse(percString, NumberStyles.Any, CultureInfo.InvariantCulture, out percState) &&
                    percState >= 0 && percState <= 100)
                {
                    _connection.Action(group.Address, _connection.ToDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.PERCENTAGE], percString));
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            case KnxDPTEnum.HVAC:
            {
                Console.Write("0..4: ");
                var intString = Console.In.ReadLine();
                int intHVAC;
                if (int.TryParse(intString, NumberStyles.Any, CultureInfo.InvariantCulture, out intHVAC) &&
                    intHVAC >= 0 && intHVAC <= 4)
                {
                    _connection.Action(group.Address, _connection.ToDataPoint(KnxDPT.KnxDPTs[KnxDPTEnum.HVAC], intString));
                }
                else
                {
                    Console.Out.WriteLine("Stato non valido");
                }
            }
            break;

            default:
                break;
            }
        }