Merge remote-tracking branch 'origin/development' into feature/ecs-1257

.github/.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+  "workbench.colorCustomizations": {
+    "activityBar.background": "#59014E",
+    "titleBar.activeBackground": "#7C016D",
+    "titleBar.activeForeground": "#FFF8FE"
+  }
+}

.github/scripts/GenerateVersionNumber.ps1

@@ -0,0 +1,38 @@
+$latestVersions = $(git tag --merged origin/master)
+$latestVersion = [version]"0.0.0"
+Foreach ($version in $latestVersions) {
+  Write-Host $version
+  try {
+    if (([version]$version) -ge $latestVersion) {
+      $latestVersion = $version
+      Write-Host "Setting latest version to: $latestVersion"
+    }
+  } catch {
+    Write-Host "Unable to convert $($version). Skipping"
+    continue;
+  }
+}
+
+$newVersion = [version]$latestVersion
+$phase = ""
+$newVersionString = ""
+switch -regex ($Env:GITHUB_REF) {
+  '^refs\/heads\/master*.' {
+    $newVersionString = "{0}.{1}.{2}" -f $newVersion.Major, $newVersion.Minor, ($newVersion.Build + 1)
+  }
+  '^refs\/heads\/feature\/*.' {
+    $phase = 'alpha'
+  }
+  '^refs\/heads\/release\/*.' {
+    $phase = 'rc'
+  }
+  '^refs\/heads\/development*.' {
+    $phase = 'beta'
+  }
+  '^refs\/heads\/hotfix\/*.' {
+    $phase = 'hotfix'
+  }
+}
+$newVersionString = "{0}.{1}.{2}-{3}-{4}" -f $newVersion.Major, $newVersion.Minor, ($newVersion.Build + 1), $phase, $Env:GITHUB_RUN_NUMBER
+
+Write-Output $newVersionString

.github/scripts/UpdateAssemblyVersion.ps1

@@ -0,0 +1,40 @@
+function Update-SourceVersion {
+    Param ([string]$Version)
+    #$fullVersion = $Version
+    $baseVersion = [regex]::Match($Version, "(\d+.\d+.\d+).*").captures.groups[1].value
+    $NewAssemblyVersion = ‘AssemblyVersion("‘ + $baseVersion + ‘.*")’
+    Write-Output "AssemblyVersion = $NewAssemblyVersion"
+    $NewAssemblyInformationalVersion = ‘AssemblyInformationalVersion("‘ + $Version + ‘")’
+    Write-Output "AssemblyInformationalVersion = $NewAssemblyInformationalVersion"
+
+    foreach ($o in $input) {
+        Write-output $o.FullName
+        $TmpFile = $o.FullName + “.tmp”
+        get-content $o.FullName |
+        ForEach-Object {
+            $_ -replace ‘AssemblyVersion\(".*"\)’, $NewAssemblyVersion } |
+        ForEach-Object {
+            $_ -replace ‘AssemblyInformationalVersion\(".*"\)’, $NewAssemblyInformationalVersion
+        }  > $TmpFile 
+        move-item $TmpFile $o.FullName -force
+    }
+}
+
+function Update-AllAssemblyInfoFiles ( $version ) {
+    foreach ($file in “AssemblyInfo.cs”, “AssemblyInfo.vb” ) {
+        get-childitem -Path $Env:GITHUB_WORKSPACE -recurse | Where-Object { $_.Name -eq $file } | Update-SourceVersion $version ;
+    }
+}
+
+# validate arguments
+$r = [System.Text.RegularExpressions.Regex]::Match($args[0], "\d+\.\d+\.\d+.*");
+if ($r.Success) {
+    Write-Output "Updating Assembly Version to $args ...";
+    Update-AllAssemblyInfoFiles $args[0];
+}
+else {
+    Write-Output ” “;
+    Write-Output “Error: Input version does not match x.y.z format!”
+    Write-Output ” “;
+    Write-Output "Unable to apply version to AssemblyInfo.cs files";
+}

.github/scripts/ZipBuildOutput.ps1

@@ -0,0 +1,41 @@
+# Uncomment these for local testing
+# $Env:GITHUB_WORKSPACE = "C:\Working Directories\PD\essentials"
+# $Env:SOLUTION_FILE = "PepperDashEssentials"
+# $Env:VERSION = "0.0.0-buildType-test"
+
+# Sets the root directory for the operation
+$destination = "$($Env:GITHUB_HOME)\output"
+New-Item -ItemType Directory -Force -Path ($destination)
+Get-ChildItem ($destination)
+$exclusions = @(git submodule foreach --quiet 'echo $name')
+# Trying to get any .json schema files (not currently working)
+# Gets any files with the listed extensions.
+Get-ChildItem -recurse -Path "$($Env:GITHUB_WORKSPACE)" -include "*.clz", "*.cpz", "*.cplz" | ForEach-Object {
+  $allowed = $true;
+  # Exclude any files in submodules
+  foreach ($exclude in $exclusions) {
+    if ((Split-Path $_.FullName -Parent).contains("$($exclude)")) {
+      $allowed = $false;
+      break;
+    }
+  }
+  if ($allowed) {
+    Write-Host "allowing $($_)"
+    $_;
+  }
+} | Copy-Item -Destination ($destination) -Force
+Write-Host "Getting matching files..."
+# Get any files from the output folder that match the following extensions
+Get-ChildItem -Path $destination | Where-Object {($_.Extension -eq ".clz") -or ($_.Extension -eq ".cpz" -or ($_.Extension -eq ".cplz"))} | ForEach-Object { 
+  # Replace the extensions with dll and xml and create an array 
+  $filenames = @($($_ -replace "cpz|clz|cplz", "dll"), $($_ -replace "cpz|clz|cplz", "xml"))
+  Write-Host "Filenames:"
+  Write-Host $filenames
+  if ($filenames.length -gt 0) {
+    # Attempt to get the files and return them to the output directory
+    Get-ChildItem -Recurse -Path "$($Env:GITHUB_WORKSPACE)" -include $filenames | Copy-Item -Destination ($destination) -Force
+  }
+}
+Compress-Archive -Path $destination -DestinationPath "$($Env:GITHUB_WORKSPACE)\$($Env:SOLUTION_FILE)-$($Env:VERSION).zip" -Force
+Write-Host "Output Contents post Zip"
+Get-ChildItem -Path $destination

.github/workflows/docker.yml

@@ -0,0 +1,247 @@
+name: Branch Build Using Docker
+
+on:
+  push:
+    branches:
+      - feature/*
+      - hotfix/*
+      - release/*
+      - master
+      - development
+
+env:
+  # solution path doesn't need slashes unless there it is multiple folders deep
+  # solution name does not include extension. .sln is assumed
+  SOLUTION_PATH: PepperDashEssentials
+  SOLUTION_FILE: PepperDashEssentials
+  # Do not edit this, we're just creating it here
+  VERSION: 0.0.0-buildtype-buildnumber
+  # Defaults to debug for build type
+  BUILD_TYPE: Debug
+  # Defaults to master as the release branch.  Change as necessary
+  RELEASE_BRANCH: master
+jobs:
+  Build_Project:
+    runs-on: windows-latest
+    steps:
+      # First we checkout the source repo
+      - name: Checkout repo
+        uses: actions/checkout@v2
+        with:
+          fetch-depth: 0
+      # And any submodules
+      - name: Checkout submodules
+        shell: bash
+        run: |
+          git config --global url."https://github.com/".insteadOf "git@github.com:"
+          auth_header="$(git config --local --get http.https://github.com/.extraheader)"
+          git submodule sync --recursive
+          git -c "http.extraheader=$auth_header" -c protocol.version=2 submodule update --init --force --recursive --depth=1
+      # Set the BUILD_TYPE environment variable
+      - name: Set Build to Release if triggered from Master
+        run: |
+          if("$($Env:GITHUB_REF)".contains("$($Env:RELEASE_BRANCH)")) {
+            Write-Host "Setting build type to Release"
+            Write-Output "::set-env name=BUILD_TYPE::Release"
+          }
+      # Fetch all tags
+      - name: Fetch tags
+        run: git fetch --tags
+      # Generate the appropriate version number
+      - name: Set Version Number
+        shell: powershell
+        run: |
+          $version = ./.github/scripts/GenerateVersionNumber.ps1
+          Write-Output "::set-env name=VERSION::$version"
+      # Use the version number to set the version of the assemblies
+      - name: Update AssemblyInfo.cs
+        shell: powershell
+        run: |
+          Write-Output ${{ env.VERSION }}
+          ./.github/scripts/UpdateAssemblyVersion.ps1 ${{ env.VERSION }}
+      # Build the solutions in the docker image
+      - name: Build Solution
+        shell: powershell
+        run: |
+          Invoke-Expression "docker run --rm --mount type=bind,source=""$($Env:GITHUB_WORKSPACE)"",target=""c:/project"" pepperdash/sspbuilder c:\cihelpers\vsidebuild.exe -Solution ""c:\project\$($Env:SOLUTION_FILE).sln"" -BuildSolutionConfiguration $($ENV:BUILD_TYPE)"
+      # Zip up the output files as needed
+      - name: Zip Build Output
+        shell: powershell
+        run: ./.github/scripts/ZipBuildOutput.ps1
+      # Write the version to a file to be consumed by the push jobs
+      - name: Write Version
+        run: Write-Output "$($Env:VERSION)" | Out-File -FilePath "$($Env:GITHUB_HOME)\output\version.txt"
+      # Upload the build output as an artifact
+      - name: Upload Build Output
+        uses: actions/upload-artifact@v1
+        with:
+          name: Build
+          path: ./${{ env.SOLUTION_FILE}}-${{ env.VERSION}}.zip
+      # Upload the Version file as an artifact
+      - name: Upload version.txt
+        uses: actions/upload-artifact@v1
+        with:
+          name: Version
+          path: ${{env.GITHUB_HOME}}\output\version.txt
+      # Create the release on the source repo
+      - name: Create Release
+        id: create_release
+        uses: actions/create-release@v1
+        with:
+          tag_name: ${{ env.VERSION  }}
+          release_name: ${{ env.VERSION }}
+          prerelease: ${{contains('debug', env.BUILD_TYPE)}}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+      # Upload the build package to the release
+      - name: Upload Release Package
+        id: upload_release
+        uses: actions/upload-release-asset@v1
+        with:
+          upload_url: ${{ steps.create_release.outputs.upload_url }}
+          asset_path: ./${{ env.SOLUTION_FILE}}-${{ env.VERSION}}.zip
+          asset_name: ${{ env.SOLUTION_FILE}}-${{ env.VERSION}}.zip
+          asset_content_type: application/zip
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  # This step always runs and pushes the build to the internal build rep
+  Internal_Push_Output:
+    needs: Build_Project
+    runs-on: windows-latest
+    steps:
+      # Checkout the repo
+      - name: Checkout Builds Repo
+        uses: actions/checkout@v2
+        with:
+          token: ${{ secrets.BUILDS_TOKEN }}
+          repository: PepperDash-Engineering/essentials-builds
+          ref: ${{ Env.GITHUB_REF }}
+      # Download the version artifact from the build job
+      - name: Download Build Version Info
+        uses: actions/download-artifact@v1
+        with:
+          name: Version
+      - name: Check Directory
+        run: Get-ChildItem "./"
+      # Set the version number environment variable from the file we just downloaded
+      - name: Set Version Number
+        shell: powershell
+        run: |
+          Get-ChildItem "./Version"
+          $version = Get-Content -Path ./Version/version.txt
+          Write-Host "Version: $version"
+          Write-Output "::set-env name=VERSION::$version"
+          Remove-Item -Path ./Version/version.txt
+          Remove-Item -Path ./Version
+      # Checkout/Create the branch
+      - name: Create new branch
+        run: git checkout -b $($Env:GITHUB_REF -replace "refs/heads/")
+      # Download the build output into the repo
+      - name: Download Build output
+        uses: actions/download-artifact@v1
+        with:
+          name: Build
+          path: ./
+      - name: Check directory
+        run: Get-ChildItem ./
+      # Unzip the build package file
+      - name: Unzip Build file
+        run: |
+          Get-ChildItem .\*.zip | Expand-Archive -DestinationPath .\
+          Remove-Item -Path .\*.zip
+      - name: Check directory again
+        run: Get-ChildItem ./
+      # Commits the build output to the branch and tags it with the version
+      - name: Commit build output and tag the commit
+        shell: powershell
+        run: |
+          git config user.email "actions@pepperdash.com"
+          git config user.name "GitHub Actions"
+          git add .
+          $commit = "Build $($Env:GITHUB_RUN_NUMBER) from commit: https://github.com/$($Env:GITHUB_REPOSITORY)/commit/$($Env:GITHUB_SHA)"
+          Write-Host "Commit: $commit"
+          git commit -m $commit
+          git tag $($Env:VERSION)
+      # Push the commit
+      - name: Push to Builds Repo
+        shell: powershell
+        run: |
+          $branch = $($Env:GITHUB_REF) -replace "refs/heads/"
+          Write-Host "Branch: $branch"
+          git push -u origin $($branch) --force
+      # Push the tags
+      - name: Push tags
+        run: git push --tags origin
+      - name: Check Directory
+        run: Get-ChildItem ./
+  # This step only runs if the branch is master or release/ runs and pushes the build to the public build repo
+  Public_Push_Output:
+    needs: Build_Project
+    runs-on: windows-latest
+    if: contains(github.ref, 'master') || contains(github.ref, 'release')
+    steps:
+      # Checkout the repo
+      - name: Checkout Builds Repo
+        uses: actions/checkout@v2
+        with:
+          token: ${{ secrets.BUILDS_TOKEN }}
+          repository: PepperDash/Essentials-Builds
+          ref: ${{ Env.GITHUB_REF }}
+      # Download the version artifact from the build job
+      - name: Download Build Version Info
+        uses: actions/download-artifact@v1
+        with:
+          name: Version
+      - name: Check Directory
+        run: Get-ChildItem "./"
+      # Set the version number environment variable from the file we just downloaded
+      - name: Set Version Number
+        shell: powershell
+        run: |
+          Get-ChildItem "./Version"
+          $version = Get-Content -Path ./Version/version.txt
+          Write-Host "Version: $version"
+          Write-Output "::set-env name=VERSION::$version"
+          Remove-Item -Path ./Version/version.txt
+          Remove-Item -Path ./Version
+      # Checkout/Create the branch
+      - name: Create new branch
+        run: git checkout -b $($Env:GITHUB_REF -replace "refs/heads/")
+      # Download the build output into the repo
+      - name: Download Build output
+        uses: actions/download-artifact@v1
+        with:
+          name: Build
+          path: ./
+      - name: Check directory
+        run: Get-ChildItem ./
+      # Unzip the build package file
+      - name: Unzip Build file
+        run: |
+          Get-ChildItem .\*.zip | Expand-Archive -DestinationPath .\
+          Remove-Item -Path .\*.zip
+      - name: Check directory again
+        run: Get-ChildItem ./
+      # Commits the build output to the branch and tags it with the version
+      - name: Commit build output and tag the commit
+        shell: powershell
+        run: |
+          git config user.email "actions@pepperdash.com"
+          git config user.name "GitHub Actions"
+          git add .
+          $commit = "Build $($Env:GITHUB_RUN_NUMBER) from commit: https://github.com/$($Env:GITHUB_REPOSITORY)/commit/$($Env:GITHUB_SHA)"
+          Write-Host "Commit: $commit"
+          git commit -m $commit
+          git tag $($Env:VERSION)
+      # Push the commit
+      - name: Push to Builds Repo
+        shell: powershell
+        run: |
+          $branch = $($Env:GITHUB_REF) -replace "refs/heads/"
+          Write-Host "Branch: $branch"
+          git push -u origin $($branch) --force
+      # Push the tags
+      - name: Push tags
+        run: git push --tags origin
+      - name: Check Directory
+        run: Get-ChildItem ./

.gitignore

@@ -22,3 +22,6 @@ _ReSharper*/
 SIMPLSharpLogs/
 *.projectinfo
 essentials-framework/EssentialDMTestConfig/
+output/
+
+PepperDashEssentials-0.0.0-buildType-test.zip

PepperDashEssentials/Bridges/BridgeBase.cs

@@ -136,6 +136,11 @@ namespace PepperDash.Essentials.Bridges
                             (device as GenericRelayDevice).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
                             continue;
                         }
+                        else if (device is IRSetTopBoxBase)
+                        {
+                            (device as IRSetTopBoxBase).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);
+                            continue;
+                        }
                         else if (device is IDigitalInput)
                         {
                             (device as IDigitalInput).LinkToApi(Eisc, d.JoinStart, d.JoinMapKey);

PepperDashEssentials/Bridges/DmChassisControllerBridge.cs

@@ -1,4 +1,5 @@
-using System;
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -16,7 +17,7 @@ using Newtonsoft.Json;
 
 namespace PepperDash.Essentials.Bridges
 {
-    public static class DmChassisControllerApiExtensions
+    public static class DmChassisControllerApiExtentions
     {
         public static void LinkToApi(this DmChassisController dmChassis, BasicTriList trilist, uint joinStart, string joinMapKey)
         {
@@ -81,14 +82,14 @@ namespace PepperDash.Essentials.Bridges
                         }
                     }
 
-                    if (advancedTxDevice != null)   // Advanced TX device
+                    if (basicTxDevice != null && advancedTxDevice == null)
+                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
+
+                    if (advancedTxDevice != null)
                     {
                         advancedTxDevice.AnyVideoInput.VideoStatus.VideoSyncFeedback.LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
-
-                        // Flag if the TX is an advanced endpoint type
-                        trilist.BooleanInput[joinMap.TxAdvancedIsPresent + ioSlot].BoolValue = true;
                     }
-                    else if(advancedTxDevice == null || basicTxDevice != null)  // Basic TX device
+                    else if(advancedTxDevice == null || basicTxDevice != null)
                     {
                         Debug.Console(1, "Setting up actions and feedbacks on input card {0}", ioSlot);
                         dmChassis.VideoInputSyncFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.VideoSyncStatus + ioSlot]);
@@ -167,6 +168,7 @@ namespace PepperDash.Essentials.Bridges
                         }
                     }
                 }
+                
                 if (dmChassis.RxDictionary.ContainsKey(ioSlot))
                 {
                     Debug.Console(2, "Creating Rx Feedbacks {0}", ioSlot);
@@ -191,11 +193,12 @@ namespace PepperDash.Essentials.Bridges
                 dmChassis.UsbOutputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.OutputUsb + ioSlot]);
                 dmChassis.UsbInputRoutedToFeebacks[ioSlot].LinkInputSig(trilist.UShortInput[joinMap.InputUsb + ioSlot]);
 
-
                 dmChassis.OutputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputNames + ioSlot]);
                 dmChassis.InputNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.InputNames + ioSlot]);
                 dmChassis.OutputVideoRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentVideoInputNames + ioSlot]);
                 dmChassis.OutputAudioRouteNameFeedbacks[ioSlot].LinkInputSig(trilist.StringInput[joinMap.OutputCurrentAudioInputNames + ioSlot]);
+                
+                dmChassis.OutputDisabledByHdcpFeedbacks[ioSlot].LinkInputSig(trilist.BooleanInput[joinMap.OutputDisabledByHdcp + ioSlot]);
             }
         }
 
@@ -281,4 +284,5 @@ namespace PepperDash.Essentials.Bridges
         }
 
     }
+
 }

PepperDashEssentials/Bridges/GlsOccupancySensorBaseControllerBridge.cs

@@ -31,6 +31,16 @@ namespace PepperDash.Essentials.Bridges
 
             #region Single and Dual Sensor Stuff
             occController.IsOnline.LinkInputSig(trilist.BooleanInput[joinMap.IsOnline]);
+            trilist.StringInput[joinMap.Name].StringValue = occController.Name;
+
+            trilist.OnlineStatusChange += new Crestron.SimplSharpPro.OnlineStatusChangeEventHandler((d, args) =>
+            {
+                if (args.DeviceOnLine)
+                {
+                    trilist.StringInput[joinMap.Name].StringValue = occController.Name;
+                }
+            }
+            );
 
             // Occupied status
             trilist.SetSigTrueAction(joinMap.ForceOccupied, new Action(() => occController.ForceOccupied()));
@@ -38,6 +48,7 @@ namespace PepperDash.Essentials.Bridges
             occController.RoomIsOccupiedFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RoomOccupiedFeedback]);
             occController.RoomIsOccupiedFeedback.LinkComplementInputSig(trilist.BooleanInput[joinMap.RoomVacantFeedback]);
             occController.RawOccupancyFeedback.LinkInputSig(trilist.BooleanInput[joinMap.RawOccupancyFeedback]);
+            trilist.SetBoolSigAction(joinMap.EnableRawStates, new Action<bool>((b) => occController.EnableRawStates(b)));
 
             // Timouts
             trilist.SetUShortSigAction(joinMap.Timeout, new Action<ushort>((u) => occController.SetRemoteTimeout(u)));

PepperDashEssentials/Bridges/IRSetTopBoxBaseBridge.cs

@@ -0,0 +1,128 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro.DeviceSupport;
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+using PepperDash.Essentials.Devices.Common;
+
+using Newtonsoft.Json;
+
+namespace PepperDash.Essentials.Bridges
+{
+    public static class IRSetTopBoxBaseApiExtensions
+    {
+        public static void LinkToApi(this PepperDash.Essentials.Devices.Common.IRSetTopBoxBase stbDevice, BasicTriList trilist, uint joinStart, string joinMapKey)
+        {
+            SetTopBoxControllerJoinMap joinMap = new SetTopBoxControllerJoinMap();
+            var joinMapSerialized = JoinMapHelper.GetJoinMapForDevice(joinMapKey);
+
+            if (!string.IsNullOrEmpty(joinMapSerialized))
+                joinMap = JsonConvert.DeserializeObject<SetTopBoxControllerJoinMap>(joinMapSerialized);
+
+            joinMap.OffsetJoinNumbers(joinStart);
+
+            Debug.Console(1, "Linking to Trilist '{0}'", trilist.ID.ToString("X"));
+            Debug.Console(0, "Linking to Display: {0}", stbDevice.Name);
+
+            trilist.StringInput[joinMap.Name].StringValue = stbDevice.Name;
+
+            var stbBase = stbDevice as ISetTopBoxControls;
+            if (stbBase != null)
+            {
+                trilist.BooleanInput[joinMap.HasDpad].BoolValue = stbBase.HasDpad;
+                trilist.BooleanInput[joinMap.HasNumeric].BoolValue = stbBase.HasNumeric;
+                trilist.BooleanInput[joinMap.HasDvr].BoolValue = stbBase.HasDvr;
+                trilist.BooleanInput[joinMap.HasPresets].BoolValue = stbBase.HasPresets;
+
+                trilist.SetBoolSigAction(joinMap.DvrList, (b) => stbBase.DvrList(b));
+                trilist.SetBoolSigAction(joinMap.Replay, (b) => stbBase.Replay(b));
+
+                trilist.SetStringSigAction(joinMap.LoadPresets, (s) => stbBase.LoadPresets(s));
+            }
+
+            var stbPower = stbDevice as IPower;
+            if (stbPower != null)
+            {
+                trilist.SetSigTrueAction(joinMap.PowerOn, () => stbPower.PowerOn());
+                trilist.SetSigTrueAction(joinMap.PowerOff, () => stbPower.PowerOff());
+                trilist.SetSigTrueAction(joinMap.PowerToggle, () => stbPower.PowerToggle());
+
+            }
+
+            var stbDPad = stbDevice as IDPad;
+            if (stbDPad != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Up, (b) => stbDPad.Up(b));
+                trilist.SetBoolSigAction(joinMap.Down, (b) => stbDPad.Down(b));
+                trilist.SetBoolSigAction(joinMap.Left, (b) => stbDPad.Left(b));
+                trilist.SetBoolSigAction(joinMap.Right, (b) => stbDPad.Right(b));
+                trilist.SetBoolSigAction(joinMap.Select, (b) => stbDPad.Select(b));
+                trilist.SetBoolSigAction(joinMap.Menu, (b) => stbDPad.Menu(b));
+                trilist.SetBoolSigAction(joinMap.Exit, (b) => stbDPad.Exit(b));
+            }
+
+            var stbChannel = stbDevice as IChannel;
+            if (stbChannel != null)
+            {
+                trilist.SetBoolSigAction(joinMap.ChannelUp, (b) => stbChannel.ChannelUp(b));
+                trilist.SetBoolSigAction(joinMap.ChannelDown, (b) => stbChannel.ChannelDown(b));
+                trilist.SetBoolSigAction(joinMap.LastChannel, (b) => stbChannel.LastChannel(b));
+                trilist.SetBoolSigAction(joinMap.Guide, (b) => stbChannel.Guide(b));
+                trilist.SetBoolSigAction(joinMap.Info, (b) => stbChannel.Info(b));
+                trilist.SetBoolSigAction(joinMap.Exit, (b) => stbChannel.Exit(b));
+            }
+
+            var stbColor = stbDevice as IColor;
+            if (stbColor != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Red, (b) => stbColor.Red(b));
+                trilist.SetBoolSigAction(joinMap.Green, (b) => stbColor.Green(b));
+                trilist.SetBoolSigAction(joinMap.Yellow, (b) => stbColor.Yellow(b));
+                trilist.SetBoolSigAction(joinMap.Blue, (b) => stbColor.Blue(b));
+            }
+
+            var stbKeypad = stbDevice as ISetTopBoxNumericKeypad;
+            if (stbKeypad != null)
+            {
+                trilist.StringInput[joinMap.KeypadAccessoryButton1Label].StringValue = stbKeypad.KeypadAccessoryButton1Label;
+                trilist.StringInput[joinMap.KeypadAccessoryButton2Label].StringValue = stbKeypad.KeypadAccessoryButton2Label;
+
+                trilist.BooleanInput[joinMap.HasKeypadAccessoryButton1].BoolValue = stbKeypad.HasKeypadAccessoryButton1;
+                trilist.BooleanInput[joinMap.HasKeypadAccessoryButton2].BoolValue = stbKeypad.HasKeypadAccessoryButton2;
+
+                trilist.SetBoolSigAction(joinMap.Digit0, (b) => stbKeypad.Digit0(b));
+                trilist.SetBoolSigAction(joinMap.Digit1, (b) => stbKeypad.Digit1(b));
+                trilist.SetBoolSigAction(joinMap.Digit2, (b) => stbKeypad.Digit2(b));
+                trilist.SetBoolSigAction(joinMap.Digit3, (b) => stbKeypad.Digit3(b));
+                trilist.SetBoolSigAction(joinMap.Digit4, (b) => stbKeypad.Digit4(b));
+                trilist.SetBoolSigAction(joinMap.Digit5, (b) => stbKeypad.Digit5(b));
+                trilist.SetBoolSigAction(joinMap.Digit6, (b) => stbKeypad.Digit6(b));
+                trilist.SetBoolSigAction(joinMap.Digit7, (b) => stbKeypad.Digit7(b));
+                trilist.SetBoolSigAction(joinMap.Digit8, (b) => stbKeypad.Digit8(b));
+                trilist.SetBoolSigAction(joinMap.Digit9, (b) => stbKeypad.Digit9(b));
+                trilist.SetBoolSigAction(joinMap.KeypadAccessoryButton1Press, (b) => stbKeypad.KeypadAccessoryButton1(b));
+                trilist.SetBoolSigAction(joinMap.KeypadAccessoryButton2Press, (b) => stbKeypad.KeypadAccessoryButton1(b));
+                trilist.SetBoolSigAction(joinMap.Dash, (b) => stbKeypad.Dash(b));
+                trilist.SetBoolSigAction(joinMap.KeypadEnter, (b) => stbKeypad.KeypadEnter(b));
+            }
+
+            var stbTransport = stbDevice as ITransport;
+            if (stbTransport != null)
+            {
+                trilist.SetBoolSigAction(joinMap.Play, (b) => stbTransport.Play(b));
+                trilist.SetBoolSigAction(joinMap.Pause, (b) => stbTransport.Pause(b));
+                trilist.SetBoolSigAction(joinMap.Rewind, (b) => stbTransport.Rewind(b));
+                trilist.SetBoolSigAction(joinMap.FFwd, (b) => stbTransport.FFwd(b));
+                trilist.SetBoolSigAction(joinMap.ChapMinus, (b) => stbTransport.ChapMinus(b));
+                trilist.SetBoolSigAction(joinMap.ChapPlus, (b) => stbTransport.ChapPlus(b));
+                trilist.SetBoolSigAction(joinMap.Stop, (b) => stbTransport.Stop(b));
+                trilist.SetBoolSigAction(joinMap.Record, (b) => stbTransport.Record(b));
+
+            }
+
+        }
+    }
+}

PepperDashEssentials/Bridges/JoinMaps/DmChassisControllerJoinMap.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -38,6 +38,10 @@ namespace PepperDash.Essentials.Bridges
         /// Range reports high if corresponding input's transmitter supports bridging as a separate device for detailed AV switching, HDCP control, etc.
         /// </summary>
         public uint TxAdvancedIsPresent { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
+        /// <summary>
+        /// Range reports high if corresponding output is disabled by HDCP.
+        /// </summary>
+        public uint OutputDisabledByHdcp { get; set; } // indicates that there is an attached transmitter that should be bridged to be interacted with
 #endregion
 
 #region Analogs
@@ -101,6 +105,7 @@ namespace PepperDash.Essentials.Bridges
             InputEndpointOnline = 500; //501-699
             OutputEndpointOnline = 700; //701-899
             TxAdvancedIsPresent = 1000; //1001-1199
+            OutputDisabledByHdcp = 1200; //1201-1399
 
             //Analog
             OutputVideo = 100; //101-299
@@ -139,6 +144,7 @@ namespace PepperDash.Essentials.Bridges
             OutputEndpointOnline = OutputEndpointOnline + joinOffset;
             HdcpSupportState = HdcpSupportState + joinOffset;
             HdcpSupportCapability = HdcpSupportCapability + joinOffset;
+            OutputDisabledByHdcp = OutputDisabledByHdcp + joinOffset;
             TxAdvancedIsPresent = TxAdvancedIsPresent + joinOffset;
         }
     }

PepperDashEssentials/Bridges/JoinMaps/GlsOccupancySensorBaseJoinMap.cs

@@ -137,6 +137,10 @@ namespace PepperDash.Essentials.Bridges
         public uint PirSensitivityInVacantState { get; set; }
         #endregion
 
+        #region Serial
+        public uint Name { get; set; }
+        #endregion
+
         public GlsOccupancySensorBaseJoinMap()
         {
             IsOnline = 1;
@@ -178,6 +182,9 @@ namespace PepperDash.Essentials.Bridges
             UsSensitivityInVacantState = 6;
             PirSensitivityInOccupiedState = 7;
             PirSensitivityInVacantState = 8;
+
+            Name = 1;
+            
         }
 
         public override void OffsetJoinNumbers(uint joinStart)
@@ -206,7 +213,6 @@ namespace PepperDash.Essentials.Bridges
             DisableUsB =                        DisableUsB + joinOffset; 
             EnablePir =                         EnablePir + joinOffset; 
             DisablePir =                        DisablePir + joinOffset; 
-            DisablePir =                        DisablePir + joinOffset; 
             IncrementUsInOccupiedState =        IncrementUsInOccupiedState + joinOffset; 
             DecrementUsInOccupiedState =        DecrementUsInOccupiedState + joinOffset; 
             IncrementUsInVacantState =          IncrementUsInVacantState + joinOffset; 
@@ -224,6 +230,8 @@ namespace PepperDash.Essentials.Bridges
             UsSensitivityInVacantState =        UsSensitivityInVacantState + joinOffset; 
             PirSensitivityInOccupiedState =     PirSensitivityInOccupiedState + joinOffset;
             PirSensitivityInVacantState =       PirSensitivityInVacantState + joinOffset;
+
+            Name =                              Name + joinOffset;
         }
     }    
          

PepperDashEssentials/Bridges/JoinMaps/SetTopBoxControllerJoinMap.cs

@@ -0,0 +1,212 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using PepperDash.Essentials.Core;
+using Crestron.SimplSharp.Reflection;
+
+
+namespace PepperDash.Essentials.Bridges
+{
+    public class SetTopBoxControllerJoinMap : JoinMapBase
+    {
+        #region Digitals
+        public uint DvrList { get; set; } //
+        public uint Replay { get; set; }
+        public uint Up { get; set; } //
+        public uint Down { get; set; } //
+        public uint Left { get; set; } //
+        public uint Right { get; set; } //
+        public uint Select { get; set; } //
+        public uint Menu { get; set; } //
+        public uint Exit { get; set; } //
+        public uint Digit0 { get; set; } //
+        public uint Digit1 { get; set; } // 
+        public uint Digit2 { get; set; } //
+        public uint Digit3 { get; set; } //
+        public uint Digit4 { get; set; } // 
+        public uint Digit5 { get; set; } //
+        public uint Digit6 { get; set; } //
+        public uint Digit7 { get; set; } //
+        public uint Digit8 { get; set; } //
+        public uint Digit9 { get; set; } //
+        public uint Dash { get; set; } //
+        public uint KeypadEnter { get; set; } //
+        public uint ChannelUp { get; set; } //
+        public uint ChannelDown { get; set; } //
+        public uint LastChannel { get; set; } //
+        public uint Guide { get; set; } //
+        public uint Info { get; set; } //
+        public uint Red { get; set; } //
+        public uint Green { get; set; } //
+        public uint Yellow { get; set; } //
+        public uint Blue { get; set; } //
+        public uint ChapMinus { get; set; }
+        public uint ChapPlus { get; set; }
+        public uint FFwd { get; set; } //
+        public uint Pause { get; set; } //
+        public uint Play { get; set; } //
+        public uint Record { get; set; }
+        public uint Rewind { get; set; } //
+        public uint Stop { get; set; } //
+
+        public uint PowerOn { get; set; } //
+        public uint PowerOff { get; set; } //
+        public uint PowerToggle { get; set; } //
+
+        public uint HasKeypadAccessoryButton1 { get; set; }
+        public uint HasKeypadAccessoryButton2 { get; set; }
+
+        public uint KeypadAccessoryButton1Press { get; set; }
+        public uint KeypadAccessoryButton2Press { get; set; }
+
+
+        public uint HasDvr { get; set; }
+        public uint HasPresets { get; set; }
+        public uint HasNumeric { get; set; }
+        public uint HasDpad { get; set; }
+
+
+        #endregion
+
+        #region Analogs
+
+        #endregion
+
+        #region Strings
+        public uint Name { get; set; }
+        public uint LoadPresets { get; set; }
+        public uint KeypadAccessoryButton1Label { get; set; }
+        public uint KeypadAccessoryButton2Label { get; set; }
+
+        #endregion
+
+        public SetTopBoxControllerJoinMap()
+        {
+            PowerOn = 1;
+            PowerOff = 2;
+            PowerToggle = 3;
+
+            HasDpad = 4;
+            Up = 4;
+            Down = 5;
+            Left = 6;
+            Right = 7;
+            Select = 8;
+            Menu = 9;
+            Exit = 10;
+
+            HasNumeric = 11;
+            Digit0 = 11;
+            Digit1 = 12;
+            Digit2 = 13;
+            Digit3 = 14;
+            Digit4 = 15;
+            Digit5 = 16;
+            Digit6 = 17;
+            Digit7 = 18;
+            Digit8 = 19;
+            Digit9 = 20;
+            Dash = 21;
+            KeypadEnter = 22;
+            ChannelUp = 23;
+            ChannelDown = 24;
+            LastChannel = 25;
+
+            Guide = 26;
+            Info = 27;
+            Red = 28;
+            Green = 29;
+            Yellow = 30;
+            Blue = 31;
+
+            HasDvr = 32;
+            DvrList = 32;
+            Play = 33;
+            Pause = 34;
+            Stop = 35;
+            FFwd = 36;
+            Rewind = 37;
+            ChapPlus = 38;
+            ChapMinus = 39;
+            Replay = 40;
+            Record = 41;
+            HasKeypadAccessoryButton1 = 42;
+            KeypadAccessoryButton1Press = 42;
+            HasKeypadAccessoryButton2 = 43;
+            KeypadAccessoryButton2Press = 43;
+
+            Name = 1;
+            KeypadAccessoryButton1Label = 42;
+            KeypadAccessoryButton2Label = 43;
+
+            LoadPresets = 50;
+        }
+
+        public override void OffsetJoinNumbers(uint joinStart)
+        {
+            var joinOffset = joinStart - 1;
+
+            PowerOn += joinOffset;
+            PowerOff += joinOffset;
+            PowerToggle += joinOffset;
+
+            HasDpad += joinOffset;
+            Up += joinOffset;
+            Down += joinOffset;
+            Left += joinOffset;
+            Right += joinOffset;
+            Select += joinOffset;
+            Menu += joinOffset;
+            Exit += joinOffset;
+
+            HasNumeric += joinOffset;
+            Digit0 += joinOffset;
+            Digit1 += joinOffset;
+            Digit2 += joinOffset;
+            Digit3 += joinOffset;
+            Digit4 += joinOffset;
+            Digit5 += joinOffset;
+            Digit6 += joinOffset;
+            Digit7 += joinOffset;
+            Digit8 += joinOffset;
+            Digit9 += joinOffset;
+            Dash += joinOffset;
+            KeypadEnter += joinOffset;
+            ChannelUp += joinOffset;
+            ChannelDown += joinOffset;
+            LastChannel += joinOffset;
+
+            Guide += joinOffset;
+            Info += joinOffset;
+            Red += joinOffset;
+            Green += joinOffset;
+            Yellow += joinOffset;
+            Blue += joinOffset;
+
+            HasDvr += joinOffset;
+            DvrList += joinOffset;
+            Play += joinOffset;
+            Pause += joinOffset;
+            Stop += joinOffset;
+            FFwd += joinOffset;
+            Rewind += joinOffset;
+            ChapPlus += joinOffset;
+            ChapMinus += joinOffset;
+            Replay += joinOffset;
+            Record += joinOffset;
+            HasKeypadAccessoryButton1 += joinOffset;
+            KeypadAccessoryButton1Press += joinOffset;
+            HasKeypadAccessoryButton2 += joinOffset;
+            KeypadAccessoryButton2Press += joinOffset;
+
+            Name += joinOffset;
+            KeypadAccessoryButton1Label += joinOffset;
+            KeypadAccessoryButton2Label += joinOffset;
+
+            LoadPresets += joinOffset;
+        }
+
+    }
+}

PepperDashEssentials/Bridges/SystemMonitorBridge.cs

@@ -61,6 +61,16 @@ namespace PepperDash.Essentials.Bridges
                     (b => SystemMonitor.ProgramCollection[programNumber].RegistrationState = eProgramRegistrationState.Unregister));
                 p.Value.ProgramUnregisteredFeedback.LinkInputSig(trilist.BooleanInput[programSlotJoinStart + joinMap.ProgramUnregister]);
 
+                p.Value.ProgramNameFeedback.LinkInputSig(trilist.StringInput[programSlotJoinStart + joinMap.ProgramName]);
+                p.Value.ProgramCompileTimeFeedback.LinkInputSig(
+                    trilist.StringInput[programSlotJoinStart + joinMap.ProgramCompiledTime]);
+                p.Value.CrestronDataBaseVersionFeedback.LinkInputSig(
+                    trilist.StringInput[programSlotJoinStart + joinMap.ProgramCrestronDatabaseVersion]);
+                p.Value.EnvironmentVersionFeedback.LinkInputSig(
+                    trilist.StringInput[programSlotJoinStart + joinMap.ProgramEnvironmentVersion]);
+                p.Value.AggregatedProgramInfoFeedback.LinkInputSig(
+                    trilist.StringInput[programSlotJoinStart + joinMap.AggregatedProgramInfo]);
+
                 programSlotJoinStart = programSlotJoinStart + joinMap.ProgramOffsetJoin;
             }
         }

PepperDashEssentials/ControlSystem.cs

@@ -99,9 +99,11 @@ namespace PepperDash.Essentials
 
                 directoryPrefix = Crestron.SimplSharp.CrestronIO.Directory.GetApplicationRootDirectory();
 
-                var version = Crestron.SimplSharp.Reflection.Assembly.GetExecutingAssembly().GetName().Version;
+                var fullVersion = Assembly.GetExecutingAssembly().GetCustomAttributes(typeof(AssemblyInformationalVersionAttribute), false);
 
-                Global.SetAssemblyVersion(string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.Build));
+                AssemblyInformationalVersionAttribute fullVersionAtt = fullVersion[0] as AssemblyInformationalVersionAttribute;
+
+                Global.SetAssemblyVersion(fullVersionAtt.InformationalVersion);
 
                 if (CrestronEnvironment.DevicePlatform != eDevicePlatform.Server)   // Handles 3-series running Windows CE OS
                 {
@@ -453,11 +455,30 @@ namespace PepperDash.Essentials
 
                             DeviceManager.AddDevice(dmpsRoutingController);
                         }
+                        else if (this.ControllerPrompt.IndexOf("mpc3", StringComparison.OrdinalIgnoreCase) > -1)
+                        {
+                            Debug.Console(2, "MPC3 processor type detected.  Adding Mpc3TouchpanelController.");
+
+                            var butToken = devConf.Properties["buttons"];
+                            if (butToken != null)
+                            {
+                                var buttons = butToken.ToObject<Dictionary<string, Essentials.Core.Touchpanels.KeypadButton>>();
+                                var tpController = new Essentials.Core.Touchpanels.Mpc3TouchpanelController(devConf.Key, devConf.Name, Global.ControlSystem, buttons);
+                                DeviceManager.AddDevice(tpController);
+                            }
+                            else
+                            {
+                                Debug.Console(0, Debug.ErrorLogLevel.Error, "Error: Unable to deserialize buttons collection for device: {0}", devConf.Key);
+                            }
+                            
+                        }
                         else
                         {
                             Debug.Console(2, "************Processor is not DMPS type***************");
                         }
 
+                        
+
                         continue;
                     }
 

PepperDashEssentials/PepperDashEssentials.csproj

@@ -123,6 +123,7 @@
     <Compile Include="Bridges\CameraControllerBridge.cs" />
     <Compile Include="Bridges\AirMediaControllerBridge.cs" />
     <Compile Include="Bridges\DmBladeChassisControllerBridge.cs" />
+    <Compile Include="Bridges\IRSetTopBoxBaseBridge.cs" />
     <Compile Include="Bridges\JoinMaps\C2nRthsControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\DmBladeChassisControllerJoinMap.cs" />
     <Compile Include="Bridges\DmpsAudioOutputControllerBridge.cs" />
@@ -155,6 +156,7 @@
     <Compile Include="Bridges\JoinMaps\IBasicCommunicationJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\IDigitalInputJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\GlsOccupancySensorBaseJoinMap.cs" />
+    <Compile Include="Bridges\JoinMaps\SetTopBoxControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\StatusSignControllerJoinMap.cs" />
     <Compile Include="Bridges\JoinMaps\SystemMonitorJoinMap.cs" />
     <Compile Include="Bridges\StatusSignControllerBridge.cs" />

PepperDashEssentials/Properties/AssemblyInfo.cs

@@ -1,8 +1,10 @@
 using System.Reflection;
+using Crestron.SimplSharp.Reflection;
 
-[assembly: AssemblyTitle("PepperDashEssentials")]
+[assembly: System.Reflection.AssemblyTitle("PepperDashEssentials")]
-[assembly: AssemblyCompany("PepperDash Technology Corp")]
+[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
-[assembly: AssemblyProduct("PepperDashEssentials")]
+[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
-[assembly: AssemblyCopyright("Copyright © PepperDash Technology Corp 2018")]
+[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
-[assembly: AssemblyVersion("1.4.0.*")]
+[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
-
+[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
+[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]

PepperDashEssentials/Properties/UpdateAssemblyVersion.ps1

@@ -1,13 +1,23 @@
 function Update-SourceVersion
 {
     Param ([string]$Version)
-    $NewVersion = ‘AssemblyVersion("‘ + $Version + ‘.*")’;
+    $fullVersion = $Version
+    $baseVersion = [regex]::Match($Version, "(\d+.\d+.\d+).*").captures.groups[1].value
+    $NewAssemblyVersion = ‘AssemblyVersion("‘ + $baseVersion + ‘.*")’
+    echo "AssemblyVersion = $NewAssemblyVersion"
+    $NewAssemblyInformationalVersion = ‘AssemblyInformationalVersion("‘ + $Version + ‘")’
+    echo "AssemblyInformationalVersion = $NewAssemblyInformationalVersion"
+
     foreach ($o in $input)
    {
         Write-output $o.FullName
         $TmpFile = $o.FullName + “.tmp”
         get-content $o.FullName |
-        %{$_ -replace ‘AssemblyVersion\("(\d+\.\d+\.\d+)\.\*"\)’, $NewVersion  }  > $TmpFile
+        %{
+           $_ -replace ‘AssemblyVersion\(".*"\)’, $NewAssemblyVersion} |
+        %{
+           $_ -replace ‘AssemblyInformationalVersion\(".*"\)’, $NewAssemblyInformationalVersion
+         }  > $TmpFile 
         move-item $TmpFile $o.FullName -force
     }
 }
@@ -21,9 +31,10 @@ function Update-AllAssemblyInfoFiles ( $version )
 }
 
 # validate arguments
-$r= [System.Text.RegularExpressions.Regex]::Match($args[0], "^\d+\.\d+\.\d+$");
+$r= [System.Text.RegularExpressions.Regex]::Match($args[0], "\d+\.\d+\.\d+.*");
 if ($r.Success)
 {
+    echo "Updating Assembly Version to $args ...";
     Update-AllAssemblyInfoFiles $args[0];
 }
 else

PepperDashEssentials/References/PepperDashEssentialsBase.cplz/PepperDashEssentialsBase.config

@@ -1,16 +0,0 @@
-<ProgramInfo>
-  <RequiredInfo>
-    <FriendlyName>PepperDashEssentials</FriendlyName>
-    <SystemName>PepperDashEssentialsBase</SystemName>
-    <EntryPoint>PepperDashEssentialsBase</EntryPoint>
-    <MinFirmwareVersion>1.009.0029</MinFirmwareVersion>
-    <ProgramTool>SIMPL# Plugin</ProgramTool>
-    <DesignToolId>5</DesignToolId>
-    <ProgramToolId>5</ProgramToolId>
-    <ArchiveName />
-  </RequiredInfo>
-  <OptionalInfo>
-    <CompiledOn>1/8/2016 3:03:22 PM</CompiledOn>
-    <CompilerRev>1.0.0.27100</CompilerRev>
-  </OptionalInfo>
-</ProgramInfo>

PepperDashEssentials/References/PepperDashEssentialsBase.cplz/manifest.info

@@ -1,18 +0,0 @@
-MainAssembly=PepperDashEssentialsBase.dll:5d68a993ab03b4b88d0f95478188a439
-MainAssemblyMinFirmwareVersion=1.009.0029
-ü
-DependencySource=Crestron.SimplSharpPro.DeviceSupport.dll:caae4b4259aaf619059f0ae34473bfd2
-DependencyPath=PepperDashEssentialsBase.cplz:Crestron.SimplSharpPro.DeviceSupport.dll
-DependencyMainAssembly=Crestron.SimplSharpPro.DeviceSupport.dll:caae4b4259aaf619059f0ae34473bfd2
-ü
-DependencySource=Crestron.SimplSharpPro.DM.dll:bdf5acfa80cc3bb87f21deb891128b1d
-DependencyPath=PepperDashEssentialsBase.cplz:Crestron.SimplSharpPro.DM.dll
-DependencyMainAssembly=Crestron.SimplSharpPro.DM.dll:bdf5acfa80cc3bb87f21deb891128b1d
-ü
-DependencySource=Crestron.SimplSharpPro.EthernetCommunications.dll:36e663497195140ee6f1b4ebc53f5ea7
-DependencyPath=PepperDashEssentialsBase.cplz:Crestron.SimplSharpPro.EthernetCommunications.dll
-DependencyMainAssembly=Crestron.SimplSharpPro.EthernetCommunications.dll:36e663497195140ee6f1b4ebc53f5ea7
-ü
-DependencySource=Crestron.SimplSharpPro.UI.dll:089312a0cb0b4537072d4eb234e71e0e
-DependencyPath=PepperDashEssentialsBase.cplz:Crestron.SimplSharpPro.UI.dll
-DependencyMainAssembly=Crestron.SimplSharpPro.UI.dll:089312a0cb0b4537072d4eb234e71e0e

devjson commands.json

@@ -41,3 +41,4 @@ devjson:1 {"deviceKey":"commBridge", "methodName":"ExecuteJoinAction", "params":
 devjson:2 {"deviceKey":"display01Comm-com", "methodName":"SendText", "params": [ "I'M GETTING TIRED OF THIS" ]}
 
 devjson:10 {"deviceKey":"dmLink-ssh", "methodName":"Connect", "params": []} 
+

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/DeviceFeedbackExtensions.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+
+using PepperDash.Core;
+
+namespace PepperDash.Essentials.Core
+{
+    public static class DeviceFeedbackExtensions
+    {
+        /// <summary>
+        /// Attempts to get and return a feedback property from a device by name.
+        /// If unsuccessful, returns null.
+        /// </summary>
+        /// <param name="device"></param>
+        /// <param name="propertyName"></param>
+        /// <returns></returns>
+        public static Feedback GetFeedbackProperty(this Device device, string propertyName)
+        {
+            var feedback = DeviceJsonApi.GetPropertyByName(device.Key, propertyName) as Feedback;
+
+            if (feedback != null)
+            {
+                return feedback;
+            }
+
+            return null;
+        }
+    }
+}

essentials-framework/Essentials Core/PepperDashEssentialsBase/Devices/DeviceJsonApi.cs

@@ -59,7 +59,7 @@ namespace PepperDash.Essentials.Core
 		}
 
 		/// <summary>
-		/// 
+		/// Gets the properties on a device
 		/// </summary>
 		/// <param name="key"></param>
 		/// <returns></returns>
@@ -76,7 +76,33 @@ namespace PepperDash.Essentials.Core
 		}
 
         /// <summary>
-		/// 
+        /// Gets a property from a device path by name
+        /// </summary>
+        /// <param name="deviceObjectPath"></param>
+        /// <param name="propertyName"></param>
+        /// <returns></returns>
+        public static object GetPropertyByName(string deviceObjectPath, string propertyName)
+        {
+            var obj = FindObjectOnPath(deviceObjectPath);
+            if(obj == null)
+                return "{ \"error\":\"No Device\"}";
+
+            CType t = obj.GetType();
+
+            var prop = t.GetProperty(propertyName);
+            if (prop != null)
+            {
+                return prop;
+            }
+            else
+            {
+                Debug.Console(1, "Unable to find Property: {0} on Device with path: {1}", propertyName, deviceObjectPath);
+                return null;
+            }
+        }
+
+		/// <summary>
+		/// Gets the methods on a device
 		/// </summary>
 		/// <param name="key"></param>
 		/// <returns></returns>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Factory/DeviceFactory.cs

@@ -9,6 +9,7 @@ using PepperDash.Core;
 using PepperDash.Essentials.Core;
 using PepperDash.Essentials.Core.Config;
 using PepperDash.Essentials.Core.CrestronIO;
+using PepperDash.Essentials.Core.Touchpanels;
 
 namespace PepperDash.Essentials.Core
 {
@@ -47,13 +48,21 @@ namespace PepperDash.Essentials.Core
 
             var typeName = dc.Type.ToLower();
 
-			// Check "core" types first
+
+            // Check for types that have been added by plugin dlls. 
+            if (FactoryMethods.ContainsKey(typeName))
+            {
+                Debug.Console(0, Debug.ErrorLogLevel.Notice, "Loading '{0}' from plugin", dc.Type);
+                return FactoryMethods[typeName](dc);
+            }
+
+			// Check "core" types 
             if (typeName == "genericcomm")
             {
                 Debug.Console(1, "Factory Attempting to create new Generic Comm Device");
                 return new GenericComm(dc);
             }
-            else if (typeName == "ceniodigin104")
+            if (typeName == "ceniodigin104")
             {
                 var control = CommFactory.GetControlPropertiesConfig(dc);
                 var ipid = control.IpIdInt;
@@ -75,13 +84,6 @@ namespace PepperDash.Essentials.Core
 		        return new C2nRthsController(key, name, new C2nRths(cresnetId, Global.ControlSystem));
 		    }
 
-			// then check for types that have been added by plugin dlls. 
-			if (FactoryMethods.ContainsKey(typeName))
-			{
-				Debug.Console(0, Debug.ErrorLogLevel.Notice, "Loading '{0}' from plugin", dc.Type);
-				return FactoryMethods[typeName](dc);
-			}
-
             return null;
         }
     }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Feedbacks/BoolFeedback.cs

@@ -32,6 +32,8 @@ namespace PepperDash.Essentials.Core
         List<BoolInputSig> LinkedInputSigs = new List<BoolInputSig>();
         List<BoolInputSig> LinkedComplementInputSigs = new List<BoolInputSig>();
 
+        List<Crestron.SimplSharpPro.DeviceSupport.Feedback> LinkedCrestronFeedbacks = new List<Crestron.SimplSharpPro.DeviceSupport.Feedback>();
+
         public BoolFeedback(Func<bool> valueFunc)
             : this(null, valueFunc)
         {
@@ -56,28 +58,63 @@ namespace PepperDash.Essentials.Core
             }
         }
 
+        /// <summary>
+        /// Links an input sig
+        /// </summary>
+        /// <param name="sig"></param>
         public void LinkInputSig(BoolInputSig sig)
         {
             LinkedInputSigs.Add(sig);
             UpdateSig(sig);
         }
 
+        /// <summary>
+        /// Unlinks an inputs sig
+        /// </summary>
+        /// <param name="sig"></param>
         public void UnlinkInputSig(BoolInputSig sig)
         {
             LinkedInputSigs.Remove(sig);
         }
 
+        /// <summary>
+        /// Links an input sig to the complement value
+        /// </summary>
+        /// <param name="sig"></param>
         public void LinkComplementInputSig(BoolInputSig sig)
         {
             LinkedComplementInputSigs.Add(sig);
             UpdateComplementSig(sig);
         }
 
+        /// <summary>
+        /// Unlinks an input sig to the complement value
+        /// </summary>
+        /// <param name="sig"></param>
         public void UnlinkComplementInputSig(BoolInputSig sig)
         {
             LinkedComplementInputSigs.Remove(sig);
         }
 
+        /// <summary>
+        /// Links a Crestron Feedback object
+        /// </summary>
+        /// <param name="feedback"></param>
+        public void LinkCrestronFeedback(Crestron.SimplSharpPro.DeviceSupport.Feedback feedback)
+        {
+            LinkedCrestronFeedbacks.Add(feedback);
+            UpdateCrestronFeedback(feedback);
+        }
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="feedback"></param>
+        public void UnlinkCrestronFeedback(Crestron.SimplSharpPro.DeviceSupport.Feedback feedback)
+        {
+            LinkedCrestronFeedbacks.Remove(feedback);
+        }
+
         public override string ToString()
         {
             return (InTestMode ? "TEST -- " : "") + BoolValue.ToString();
@@ -103,6 +140,11 @@ namespace PepperDash.Essentials.Core
         {
             sig.BoolValue = !_BoolValue;
         }
+
+        void UpdateCrestronFeedback(Crestron.SimplSharpPro.DeviceSupport.Feedback feedback)
+        {
+            feedback.State = _BoolValue;
+        }
     }
 
 }

essentials-framework/Essentials Core/PepperDashEssentialsBase/Fusion/EssentialsHuddleSpaceFusionSystemControllerBase.cs

@@ -439,7 +439,7 @@ namespace PepperDash.Essentials.Core.Fusion
 
         void GetTouchpanelInfo()
         {
-            // TODO Get IP and Project Name from TP
+            // TODO: Get IP and Project Name from TP
         }
 
         protected void FusionRoom_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)

essentials-framework/Essentials Core/PepperDashEssentialsBase/PepperDash_Essentials_Core.csproj

@@ -131,6 +131,7 @@
     <Compile Include="Devices\CodecInterfaces.cs" />
     <Compile Include="Devices\CrestronProcessor.cs" />
     <Compile Include="Devices\DeviceApiBase.cs" />
+    <Compile Include="Devices\DeviceFeedbackExtensions.cs" />
     <Compile Include="Devices\PC\InRoomPc.cs" />
     <Compile Include="Devices\PC\Laptop.cs" />
     <Compile Include="Devices\ReconfigurableDevice.cs" />
@@ -236,6 +237,7 @@
     <Compile Include="Touchpanels\CrestronTouchpanelPropertiesConfig.cs" />
     <Compile Include="Touchpanels\Interfaces.cs" />
     <Compile Include="Touchpanels\Keyboards\HabaneroKeyboardController.cs" />
+    <Compile Include="Touchpanels\Mpc3Touchpanel.cs" />
     <Compile Include="Touchpanels\TriListExtensions.cs" />
     <Compile Include="UI PageManagers\BlurayPageManager.cs" />
     <Compile Include="UI PageManagers\SetTopBoxThreePanelPageManager.cs" />

essentials-framework/Essentials Core/PepperDashEssentialsBase/Properties/AssemblyInfo.cs

@@ -1,7 +1,11 @@
 using System.Reflection;
+using Crestron.SimplSharp.Reflection;
+
+[assembly: System.Reflection.AssemblyTitle("PepperDashEssentialsBase")]
+[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
+[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
+[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
+[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
+[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
+[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
 
-[assembly: AssemblyTitle("PepperDashEssentialsBase")]
-[assembly: AssemblyCompany("PepperDash Technology Corp")]
-[assembly: AssemblyProduct("PepperDashEssentialsBase")]
-[assembly: AssemblyCopyright("Copyright © Pepperdash 2019")]
-[assembly: AssemblyVersion("1.4.0.*")]

essentials-framework/Essentials Core/PepperDashEssentialsBase/References/SSMonoIOLibrary.clz/SSMonoIOLibrary.config

@@ -1,16 +0,0 @@
-<ProgramInfo>
-  <RequiredInfo>
-    <FriendlyName>SSMonoIOLibrary</FriendlyName>
-    <SystemName>SSMonoIOLibrary</SystemName>
-    <EntryPoint>SSMonoIOLibrary</EntryPoint>
-    <MinFirmwareVersion>1.007.0017</MinFirmwareVersion>
-    <ProgramTool>SIMPL# Plugin</ProgramTool>
-    <DesignToolId>5</DesignToolId>
-    <ProgramToolId>5</ProgramToolId>
-    <ArchiveName />
-  </RequiredInfo>
-  <OptionalInfo>
-    <CompiledOn>4/6/2016 7:49:24 AM</CompiledOn>
-    <CompilerRev>1.0.0.14081</CompilerRev>
-  </OptionalInfo>
-</ProgramInfo>

essentials-framework/Essentials Core/PepperDashEssentialsBase/References/SSMonoIOLibrary.clz/manifest.info

@@ -1,18 +0,0 @@
-MainAssembly=SSMonoIOLibrary.dll:6c69af117dca3f74ebca99f7a0e3181c
-MainAssemblyMinFirmwareVersion=1.007.0017
-ü
-DependencySource=SimplSharpCustomAttributesInterface.dll:9c4b4d4c519b655af90016edca2d66b9
-DependencyPath=SSMonoIOLibrary.clz:SimplSharpCustomAttributesInterface.dll
-DependencyMainAssembly=SimplSharpCustomAttributesInterface.dll:9c4b4d4c519b655af90016edca2d66b9
-ü
-DependencySource=SimplSharpHelperInterface.dll:aed72eb0e19559a3f56708be76445dcd
-DependencyPath=SSMonoIOLibrary.clz:SimplSharpHelperInterface.dll
-DependencyMainAssembly=SimplSharpHelperInterface.dll:aed72eb0e19559a3f56708be76445dcd
-ü
-DependencySource=SimplSharpReflectionInterface.dll:e3ff8edbba84ccd7155b9984e67488b2
-DependencyPath=SSMonoIOLibrary.clz:SimplSharpReflectionInterface.dll
-DependencyMainAssembly=SimplSharpReflectionInterface.dll:e3ff8edbba84ccd7155b9984e67488b2
-ü
-DependencySource=SSharpCrestronExtensionsLibrary.dll:655a49edee523f150d1c03bcb5db87d0
-DependencyPath=SSMonoIOLibrary.clz:SSharpCrestronExtensionsLibrary.dll
-DependencyMainAssembly=SSharpCrestronExtensionsLibrary.dll:655a49edee523f150d1c03bcb5db87d0

essentials-framework/Essentials Core/PepperDashEssentialsBase/References/SSMonoProTaskLibrary.cplz/SSMonoProTaskLibrary.config

@@ -1,16 +0,0 @@
-<ProgramInfo>
-  <RequiredInfo>
-    <FriendlyName>SSMonoProTaskLibrary</FriendlyName>
-    <SystemName>SSMonoProTaskLibrary</SystemName>
-    <EntryPoint>SSMonoProTaskLibrary</EntryPoint>
-    <MinFirmwareVersion>1.009.0029</MinFirmwareVersion>
-    <ProgramTool>SIMPL# Plugin</ProgramTool>
-    <DesignToolId>5</DesignToolId>
-    <ProgramToolId>5</ProgramToolId>
-    <ArchiveName />
-  </RequiredInfo>
-  <OptionalInfo>
-    <CompiledOn>4/6/2016 7:55:41 AM</CompiledOn>
-    <CompilerRev>1.0.0.14269</CompilerRev>
-  </OptionalInfo>
-</ProgramInfo>

essentials-framework/Essentials Core/PepperDashEssentialsBase/References/SSMonoProTaskLibrary.cplz/manifest.info

@@ -1,30 +0,0 @@
-MainAssembly=SSMonoProTaskLibrary.dll:5d3a301400516bd812bf1566c72ccbf2
-MainAssemblyMinFirmwareVersion=1.009.0029
-ü
-DependencySource=SimplSharpReflectionInterface.dll:e3ff8edbba84ccd7155b9984e67488b2
-DependencyPath=SSMonoProTaskLibrary.cplz:SimplSharpReflectionInterface.dll
-DependencyMainAssembly=SimplSharpReflectionInterface.dll:e3ff8edbba84ccd7155b9984e67488b2
-ü
-DependencySource=SSharpCrestronExtensionsLibrary.dll:776d0247d8d42164c46c7cc1dfadbd03
-DependencyPath=SSMonoProTaskLibrary.cplz:SSharpCrestronExtensionsLibrary.dll
-DependencyMainAssembly=SSharpCrestronExtensionsLibrary.dll:776d0247d8d42164c46c7cc1dfadbd03
-ü
-DependencySource=SSMonoConcurrentCollectionsLibrary.dll:b0afcd989b081899c9eb29f9e4c8b799
-DependencyPath=SSMonoProTaskLibrary.cplz:SSMonoConcurrentCollectionsLibrary.dll
-DependencyMainAssembly=SSMonoConcurrentCollectionsLibrary.dll:b0afcd989b081899c9eb29f9e4c8b799
-ü
-DependencySource=SSMonoProConcurrentCollectionsLibrary.dll:8b718ce29f938bbf9cb5b8fc2d89332f
-DependencyPath=SSMonoProTaskLibrary.cplz:SSMonoProConcurrentCollectionsLibrary.dll
-DependencyMainAssembly=SSMonoProConcurrentCollectionsLibrary.dll:8b718ce29f938bbf9cb5b8fc2d89332f
-ü
-DependencySource=SSMonoSupportLibrary.dll:59362515f2c1d61583b2e40793987917
-DependencyPath=SSMonoProTaskLibrary.cplz:SSMonoSupportLibrary.dll
-DependencyMainAssembly=SSMonoSupportLibrary.dll:59362515f2c1d61583b2e40793987917
-ü
-DependencySource=SSMonoThreadingLibrary.dll:ea2ae2e1d9c425236f39de9192591062
-DependencyPath=SSMonoProTaskLibrary.cplz:SSMonoThreadingLibrary.dll
-DependencyMainAssembly=SSMonoThreadingLibrary.dll:ea2ae2e1d9c425236f39de9192591062
-ü
-DependencySource=SSMonoTupleLibrary.dll:2a3b419fff4199838079879053fcb41d
-DependencyPath=SSMonoProTaskLibrary.cplz:SSMonoTupleLibrary.dll
-DependencyMainAssembly=SSMonoTupleLibrary.dll:2a3b419fff4199838079879053fcb41d

essentials-framework/Essentials Core/PepperDashEssentialsBase/Timers/CountdownTimer.cs

@@ -50,7 +50,18 @@ namespace PepperDash.Essentials.Core
                     if (StartTime == null || FinishTime == null)
                         return "";
                     var timeSpan = FinishTime - DateTime.Now;
+
+                    if (timeSpan.TotalSeconds < 60)
+                    {
                         return Math.Round(timeSpan.TotalSeconds).ToString();
+                    }
+                    else
+                    {
+                        Debug.Console(2, this, "timeSpan.Minutes == {0}, timeSpan.Seconds == {1}", timeSpan.Minutes, timeSpan.Seconds);
+                        return String.Format("{0:D2}:{1:D2}",
+                            timeSpan.Minutes,
+                            timeSpan.Seconds);
+                    }
                 });
 
             PercentFeedback = new IntFeedback(() =>

essentials-framework/Essentials Core/PepperDashEssentialsBase/Touchpanels/Mpc3Touchpanel.cs

@@ -0,0 +1,145 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Crestron.SimplSharp;
+using Crestron.SimplSharpPro;
+
+using PepperDash.Core;
+using PepperDash.Essentials.Core;
+
+namespace PepperDash.Essentials.Core.Touchpanels
+{
+    /// <summary>
+    /// A wrapper class for the touchpanel portion of an MPC3 class process to allow for configurable
+    /// behavior of the keybad buttons
+    /// </summary>
+    public class Mpc3TouchpanelController : Device
+    {
+        MPC3Basic _Touchpanel;
+
+        Dictionary<string, KeypadButton> _Buttons;
+
+        public Mpc3TouchpanelController(string key, string name, CrestronControlSystem processor, Dictionary<string, KeypadButton> buttons)
+            : base(key, name)
+        {
+            _Touchpanel = processor.ControllerTouchScreenSlotDevice as MPC3Basic;
+            _Buttons = buttons;
+
+            _Touchpanel.ButtonStateChange += new Crestron.SimplSharpPro.DeviceSupport.ButtonEventHandler(_Touchpanel_ButtonStateChange);
+
+
+            AddPostActivationAction(() =>
+                {
+                    // Link up the button feedbacks to the specified BoolFeedbacks
+                    foreach (var button in _Buttons)
+                    {
+                        var feedbackConfig = button.Value.Feedback;
+                        var device = DeviceManager.GetDeviceForKey(feedbackConfig.DeviceKey) as Device;
+                        if (device != null)
+                        {
+                            var bKey = button.Key.ToLower();
+
+                            var feedback = device.GetFeedbackProperty(feedbackConfig.BoolFeedbackName);
+
+                            var bFeedback = feedback as BoolFeedback;
+                            var iFeedback = feedback as IntFeedback;
+                            if (bFeedback != null)
+                            {
+
+                                if (bKey == "power")
+                                {
+                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackPower);
+                                    continue;
+                                }
+                                else if (bKey == "mute")
+                                {
+                                    bFeedback.LinkCrestronFeedback(_Touchpanel.FeedbackMute);
+                                    continue;
+                                }
+
+                                // Link to the Crestron Feedback corresponding to the button number
+                                bFeedback.LinkCrestronFeedback(_Touchpanel.Feedbacks[UInt16.Parse(button.Key)]);
+                            }
+                            else if (iFeedback != null)
+                            {
+                                if (bKey == "volumefeedback")
+                                {
+                                    var volFeedback = feedback as IntFeedback;
+                                    // TODO: Figure out how to subsribe to a volume IntFeedback and link it to the voluem
+                                    volFeedback.LinkInputSig(_Touchpanel.VolumeBargraph);
+                                }
+                            }
+                            else
+                            {
+                                Debug.Console(1, this, "Unable to get BoolFeedback with name: {0} from device: {1}", feedbackConfig.BoolFeedbackName, device.Key);
+                            }
+                        }
+                        else
+                        {
+                            Debug.Console(1, this, "Unable to get device with key: {0}", feedbackConfig.DeviceKey);
+                        }
+                    }
+                });
+        }
+
+        void _Touchpanel_ButtonStateChange(GenericBase device, Crestron.SimplSharpPro.DeviceSupport.ButtonEventArgs args)
+        {
+            Debug.Console(1, this, "Button {0} ({1}), {2}", args.Button.Number, args.Button.Name, args.NewButtonState);
+            var type = args.NewButtonState.ToString();
+
+            if (_Buttons.ContainsKey(args.Button.Number.ToString()))
+            {
+                Press(args.Button.Number.ToString(), type);
+            }
+            else if(_Buttons.ContainsKey(args.Button.Name.ToString()))
+            {
+                Press(args.Button.Name.ToString(), type);
+            }
+        }
+
+        /// <summary>
+        /// Runs the function associated with this button/type. One of the following strings:
+        /// Pressed, Released, Tapped, DoubleTapped, Held, HeldReleased    
+        /// </summary>
+        /// <param name="number"></param>
+        /// <param name="type"></param>
+        public void Press(string number, string type)
+        {
+            // TODO: In future, consider modifying this to generate actions at device activation time
+            //       to prevent the need to dynamically call the method via reflection on each button press
+            if (!_Buttons.ContainsKey(number)) { return; }
+            var but = _Buttons[number];
+            if (but.EventTypes.ContainsKey(type))
+            {
+                foreach (var a in but.EventTypes[type]) { DeviceJsonApi.DoDeviceAction(a); }
+            }
+        }
+
+
+    }
+
+    /// <summary>
+    /// Represents the configuration of a keybad buggon
+    /// </summary>
+    public class KeypadButton
+    {
+        public Dictionary<string, DeviceActionWrapper[]> EventTypes { get; set; }
+        public KeypadButtonFeedback Feedback { get; set; }
+
+        public KeypadButton()
+        {
+            EventTypes = new Dictionary<string, DeviceActionWrapper[]>();
+            Feedback = new KeypadButtonFeedback();
+        }
+    }
+
+    /// <summary>
+    /// 
+    /// </summary>
+    public class KeypadButtonFeedback
+    {
+        public string DeviceKey { get; set; }
+        public string BoolFeedbackName { get; set; }
+    }
+}

essentials-framework/Essentials DM/Essentials_DM/AirMedia/AirMediaController.cs

@@ -46,6 +46,9 @@ namespace PepperDash.Essentials.DM.AirMedia
 
             PropertiesConfig = props;
 
+            InputPorts = new RoutingPortCollection<RoutingInputPort>();
+            OutputPorts = new RoutingPortCollection<RoutingOutputPort>();
+
             InputPorts.Add(new RoutingInputPort(DmPortName.Osd, eRoutingSignalType.Audio | eRoutingSignalType.Video,
                 eRoutingPortConnectionType.None, new Action(SelectPinPointUxLandingPage), this));
 

essentials-framework/Essentials DM/Essentials_DM/Chassis/DmChassisController.cs

@@ -1,18 +1,11 @@
-using System;
+
+using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using Crestron.SimplSharp;
-using Crestron.SimplSharpPro;
 using Crestron.SimplSharpPro.DM;
 using Crestron.SimplSharpPro.DM.Cards;
-using Crestron.SimplSharpPro.DM.Endpoints;
-using Crestron.SimplSharpPro.DM.Endpoints.Receivers;
-
 using PepperDash.Core;
 using PepperDash.Essentials.Core;
-//using PepperDash.Essentials.DM.Cards;
-
 using PepperDash.Essentials.DM.Config;
 
 namespace PepperDash.Essentials.DM
@@ -39,16 +32,15 @@ namespace PepperDash.Essentials.DM
         public Dictionary<uint, StringFeedback> OutputAudioRouteNameFeedbacks { get; private set; }
         public Dictionary<uint, IntFeedback> UsbOutputRoutedToFeebacks { get; private set; }
         public Dictionary<uint, IntFeedback> UsbInputRoutedToFeebacks { get; private set; }
+        public Dictionary<uint, BoolFeedback> OutputDisabledByHdcpFeedbacks { get; private set; }
 
         public IntFeedback SystemIdFeebdack { get; private set; }
         public BoolFeedback SystemIdBusyFeedback { get; private set; }
 
-
         public Dictionary<uint, IntFeedback> InputCardHdcpCapabilityFeedbacks { get; private set; }
 
         public Dictionary<uint, eHdcpCapabilityType> InputCardHdcpCapabilityTypes { get; private set; }
 
-		
         // Need a couple Lists of generic Backplane ports
         public RoutingPortCollection<RoutingInputPort> InputPorts { get; private set; }
         public RoutingPortCollection<RoutingOutputPort> OutputPorts { get; private set; }
@@ -83,37 +75,56 @@ namespace PepperDash.Essentials.DM
                 uint ipid = properties.Control.IpIdInt;
 
                 DmMDMnxn chassis = null;
-				if (type == "dmmd8x8") { chassis = new DmMd8x8(ipid, Global.ControlSystem); }
+                switch (type) {
-				else if (type == "dmmd8x8rps") { chassis = new DmMd8x8rps(ipid, Global.ControlSystem); }
+                    case "dmmd8x8":
-				else if (type == "dmmd8x8cpu3") { chassis = new DmMd8x8Cpu3(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8(ipid, Global.ControlSystem);
-				else if (type == "dmmd8x8cpu3rps") { chassis = new DmMd8x8Cpu3rps(ipid, Global.ControlSystem); }
+                        break;
-
+                    case "dmmd8x8rps":
-				else if (type == "dmmd16x16") { chassis = new DmMd16x16(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8rps(ipid, Global.ControlSystem);
-				else if (type == "dmmd16x16rps") { chassis = new DmMd16x16rps(ipid, Global.ControlSystem); }
+                        break;
-				else if (type == "dmmd16x16cpu3") { chassis = new DmMd16x16Cpu3(ipid, Global.ControlSystem); }
+                    case "dmmd8x8cpu3":
-				else if (type == "dmmd16x16cpu3rps") { chassis = new DmMd16x16Cpu3rps(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8Cpu3(ipid, Global.ControlSystem);
-
+                        break;
-				else if (type == "dmmd32x32") { chassis = new DmMd32x32(ipid, Global.ControlSystem); }
+                    case "dmmd8x8cpu3rps":
-				else if (type == "dmmd32x32rps") { chassis = new DmMd32x32rps(ipid, Global.ControlSystem); }
+                        chassis = new DmMd8x8Cpu3rps(ipid, Global.ControlSystem);
-				else if (type == "dmmd32x32cpu3") { chassis = new DmMd32x32Cpu3(ipid, Global.ControlSystem); }
+                        break;
-				else if (type == "dmmd32x32cpu3rps") { chassis = new DmMd32x32Cpu3rps(ipid, Global.ControlSystem); }
+                    case "dmmd16x16":
+                        chassis = new DmMd16x16(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd16x16rps":
+                        chassis = new DmMd16x16rps(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd16x16cpu3":
+                        chassis = new DmMd16x16Cpu3(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd16x16cpu3rps":
+                        chassis = new DmMd16x16Cpu3rps(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32":
+                        chassis = new DmMd32x32(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32rps":
+                        chassis = new DmMd32x32rps(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32cpu3":
+                        chassis = new DmMd32x32Cpu3(ipid, Global.ControlSystem);
+                        break;
+                    case "dmmd32x32cpu3rps":
+                        chassis = new DmMd32x32Cpu3rps(ipid, Global.ControlSystem);
+                        break;
+                }
 
                 if (chassis == null)
-                {
                     return null;
-                }
 
                 var controller = new DmChassisController(key, name, chassis);
 
                 // add the cards and port names
                 foreach (var kvp in properties.InputSlots)
-                {
                     controller.AddInputCard(kvp.Value, kvp.Key);
-                }
+                
                 foreach (var kvp in properties.OutputSlots)
-				{
                     controller.AddOutputCard(kvp.Value, kvp.Key);
-				}
 
                 foreach (var kvp in properties.VolumeControls)
                 {
@@ -130,6 +141,7 @@ namespace PepperDash.Essentials.DM
                         audio = (card as Dmc4kHdo).Audio;
                     if (audio == null)
                         continue;
+
                     // wire up the audio to something here...
                     controller.AddVolumeControl(outNum, audio);
                 }
@@ -143,19 +155,21 @@ namespace PepperDash.Essentials.DM
                     Debug.Console(1, controller, "Setting No Route Text value to: {0}", controller.NoRouteText);
                 }
                 else
+                {
                     Debug.Console(1, controller, "NoRouteText not specified.  Defaulting to blank string.", controller.NoRouteText);
+                }
 
                 controller.PropertiesConfig = properties;
                 return controller;
             }
-			catch (System.Exception e)
+            catch (Exception e)
             {
                 Debug.Console(0, "Error creating DM chassis:\r{0}", e);
             }
+
             return null;
         }
 
-
         /// <summary>
         /// 
         /// </summary>
@@ -179,6 +193,7 @@ namespace PepperDash.Essentials.DM
             AudioOutputFeedbacks = new Dictionary<uint, IntFeedback>();
             UsbOutputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
             UsbInputRoutedToFeebacks = new Dictionary<uint, IntFeedback>();
+            OutputDisabledByHdcpFeedbacks = new Dictionary<uint, BoolFeedback>();
             VideoInputSyncFeedbacks = new Dictionary<uint, BoolFeedback>();
             InputNameFeedbacks = new Dictionary<uint, StringFeedback>();
             OutputNameFeedbacks = new Dictionary<uint, StringFeedback>();
@@ -191,211 +206,170 @@ namespace PepperDash.Essentials.DM
             SystemIdBusyFeedback = new BoolFeedback(() => { return (Chassis as DmMDMnxn).SystemIdBusy.BoolValue; });
             InputCardHdcpCapabilityFeedbacks = new Dictionary<uint, IntFeedback>();
             InputCardHdcpCapabilityTypes = new Dictionary<uint, eHdcpCapabilityType>();
-		}
 
-        public override bool CustomActivate()
-        {
-            Debug.Console(2, this, "Setting up feedbacks.");
-
-            // Setup Output Card Feedbacks
             for (uint x = 1; x <= Chassis.NumberOfOutputs; x++)
             {
                 var tempX = x;
 
-                Debug.Console(2, this, "Setting up feedbacks for output slot: {0}", tempX);
-
                 if (Chassis.Outputs[tempX] != null)
                 {
-                    VideoOutputFeedbacks[tempX] = new IntFeedback(() =>
+                    VideoOutputFeedbacks[tempX] = new IntFeedback(() => {
-                    {
-                        if (Chassis.Outputs[tempX].VideoOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number; }
-                        else { return 0; };
-                    });
-                    AudioOutputFeedbacks[tempX] = new IntFeedback(() =>
-                    {
-                        if (Chassis.Outputs[tempX].AudioOutFeedback != null) { return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number; }
-                        else { return 0; };
-                    });
-                    UsbOutputRoutedToFeebacks[tempX] = new IntFeedback(() =>
-                    {
-                        if (Chassis.Outputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Outputs[tempX].USBRoutedToFeedback.Number; }
-                        else { return 0; };
-                    });
-
-                    OutputNameFeedbacks[tempX] = new StringFeedback(() =>
-                    {
-                        if (Chassis.Outputs[tempX].NameFeedback != null)
-                        {
-                            return Chassis.Outputs[tempX].NameFeedback.StringValue;
-                        }
-                        else
-                        {
-                            return "";
-                        }
-                    });
-                    OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() =>
-                    {
                         if (Chassis.Outputs[tempX].VideoOutFeedback != null)
-                        {
+                            return (ushort)Chassis.Outputs[tempX].VideoOutFeedback.Number;
-                            return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+
-                        }
+                        return 0;
-                        else
-                        {
-                            return NoRouteText;
-                        }
                     });
-                    OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() =>
+                    AudioOutputFeedbacks[tempX] = new IntFeedback(() => {
-                    {
                         if (Chassis.Outputs[tempX].AudioOutFeedback != null)
-                        {
+                            return (ushort)Chassis.Outputs[tempX].AudioOutFeedback.Number;
-                            return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
+
-                        }
+                        return 0;
-                        else
+                    });
-                        {
+                    UsbOutputRoutedToFeebacks[tempX] = new IntFeedback(() => {
+                        if (Chassis.Outputs[tempX].USBRoutedToFeedback != null)
+                            return (ushort)Chassis.Outputs[tempX].USBRoutedToFeedback.Number;
+
+                        return 0;
+                    });
+
+                    OutputNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].NameFeedback != null)
+                            return Chassis.Outputs[tempX].NameFeedback.StringValue;
+
+                        return "";
+                    });
+                    OutputVideoRouteNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].VideoOutFeedback != null)
+                            return Chassis.Outputs[tempX].VideoOutFeedback.NameFeedback.StringValue;
+
                         return NoRouteText;
-
-                        }
                     });
+                    OutputAudioRouteNameFeedbacks[tempX] = new StringFeedback(() => {
+                        if (Chassis.Outputs[tempX].AudioOutFeedback != null)
+                            return Chassis.Outputs[tempX].AudioOutFeedback.NameFeedback.StringValue;
 
-                    OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
+                        return NoRouteText;
-                    {
+                    });
-                        return Chassis.Outputs[tempX].EndpointOnlineFeedback;
+                    OutputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => Chassis.Outputs[tempX].EndpointOnlineFeedback);
+                    
+                    OutputDisabledByHdcpFeedbacks[tempX] = new BoolFeedback(() => {
+                        var output = Chassis.Outputs[tempX];
+
+                        var hdmiTxOutput = output as Card.HdmiTx;
+                        if (hdmiTxOutput != null)
+                            return hdmiTxOutput.HdmiOutput.DisabledByHdcp.BoolValue;
+
+                        var dmHdmiOutput = output as Card.DmHdmiOutput;
+                        if (dmHdmiOutput != null)
+                            return dmHdmiOutput.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmsDmOutAdvanced = output as Card.DmsDmOutAdvanced;
+                        if (dmsDmOutAdvanced != null)
+                            return dmsDmOutAdvanced.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmps3HdmiAudioOutput = output as Card.Dmps3HdmiAudioOutput;
+                        if (dmps3HdmiAudioOutput != null)
+                            return dmps3HdmiAudioOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmps3HdmiOutput = output as Card.Dmps3HdmiOutput;
+                        if (dmps3HdmiOutput != null)
+                            return dmps3HdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        var dmps3HdmiOutputBackend = output as Card.Dmps3HdmiOutputBackend;
+                        if (dmps3HdmiOutputBackend != null)
+                            return dmps3HdmiOutputBackend.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        // var hdRx4kX10HdmiOutput = output as HdRx4kX10HdmiOutput;
+                        // if (hdRx4kX10HdmiOutput != null)
+                        //     return hdRx4kX10HdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        // var hdMdNxMHdmiOutput = output as HdMdNxMHdmiOutput;
+                        // if (hdMdNxMHdmiOutput != null)
+                        //     return hdMdNxMHdmiOutput.HdmiOutputPort.DisabledByHdcpFeedback.BoolValue;
+
+                        return false;
                     });
                 }
-                else
-                {
-                    Debug.Console(2, this, "No Output Card defined in slot: {0}", tempX);
-                }
-            };
-
-            // Setup Input Card Feedbacks
-            for (uint x = 1; x <= Chassis.NumberOfInputs; x++)
-            {
-                var tempX = x;
-
-                Debug.Console(2, this, "Setting up feedbacks for input slot: {0}", tempX);
-
-                CheckForHdcp2Property(tempX);
 
                 if (Chassis.Inputs[tempX] != null)
                 {
+                    UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() => {
+                        if (Chassis.Inputs[tempX].USBRoutedToFeedback != null)
+                            return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number;
 
-                    UsbInputRoutedToFeebacks[tempX] = new IntFeedback(() =>
+                        return 0;
-                    {
-                        if (Chassis.Inputs[tempX].USBRoutedToFeedback != null) { return (ushort)Chassis.Inputs[tempX].USBRoutedToFeedback.Number; }
-                        else { return 0; };
                     });
-                    VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() =>
+                    VideoInputSyncFeedbacks[tempX] = new BoolFeedback(() => {
-                    {
                         if (Chassis.Inputs[tempX].VideoDetectedFeedback != null)
                             return Chassis.Inputs[tempX].VideoDetectedFeedback.BoolValue;
-                        else
+                        
                         return false;
                     });
-                    InputNameFeedbacks[tempX] = new StringFeedback(() =>
+                    InputNameFeedbacks[tempX] = new StringFeedback(() => {
-                    {
                         if (Chassis.Inputs[tempX].NameFeedback != null)
-                        {
                             return Chassis.Inputs[tempX].NameFeedback.StringValue;
-                        }
+
-                        else
-                        {
                         return "";
-                        }
                     });
 
-                    InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() =>
+                    InputEndpointOnlineFeedbacks[tempX] = new BoolFeedback(() => { return Chassis.Inputs[tempX].EndpointOnlineFeedback; });
-                    {
-                        return Chassis.Inputs[tempX].EndpointOnlineFeedback;
-                    });
 
-                    InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() =>
+                    InputCardHdcpCapabilityFeedbacks[tempX] = new IntFeedback(() => {
-                    {
                         var inputCard = Chassis.Inputs[tempX];
 
-                        Debug.Console(2, this, "Adding InputCardHdcpCapabilityFeedback for slot: {0}", inputCard);
-
                         if (inputCard.Card is DmcHd)
                         {
                             InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
 
                             if ((inputCard.Card as DmcHd).HdmiInput.HdcpSupportOnFeedback.BoolValue)
                                 return 1;
-                            else
                             return 0;
                         }
-                        else if (inputCard.Card is DmcHdDsp)
+
+                        if (inputCard.Card is DmcHdDsp)
                         {
                             InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
 
                             if ((inputCard.Card as DmcHdDsp).HdmiInput.HdcpSupportOnFeedback.BoolValue)
                                 return 1;
-                            else
                             return 0;
                         }
-                        else if (inputCard.Card is Dmc4kHdBase)
+                        if (inputCard.Card is Dmc4kHdBase)
                         {
                             InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.Hdcp2_2Support;
-
                             return (int)(inputCard.Card as Dmc4kHdBase).HdmiInput.HdcpReceiveCapability;
                         }
-                        else if (inputCard.Card is Dmc4kCBase)
+                        if (inputCard.Card is Dmc4kCBase)
                         {
                             if (PropertiesConfig.InputSlotSupportsHdcp2[tempX])
                             {
                                 InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
-
                                 return (int)(inputCard.Card as Dmc4kCBase).DmInput.HdcpReceiveCapability;
                             }
-                            else if ((inputCard.Card as Dmc4kCBase).DmInput.HdcpSupportOnFeedback.BoolValue)
+
+                            if ((inputCard.Card as Dmc4kCBase).DmInput.HdcpSupportOnFeedback.BoolValue)
                                 return 1;
-                            else
                             return 0;
                         }
-                        else if (inputCard.Card is Dmc4kCDspBase)
+                        if (inputCard.Card is Dmc4kCDspBase)
                         {
                             if (PropertiesConfig.InputSlotSupportsHdcp2[tempX])
                             {
                                 InputCardHdcpCapabilityTypes[tempX] = eHdcpCapabilityType.HdcpAutoSupport;
-
                                 return (int)(inputCard.Card as Dmc4kCDspBase).DmInput.HdcpReceiveCapability;
                             }
-                            else if ((inputCard.Card as Dmc4kCDspBase).DmInput.HdcpSupportOnFeedback.BoolValue)
+
+                            if ((inputCard.Card as Dmc4kCDspBase).DmInput.HdcpSupportOnFeedback.BoolValue)
                                 return 1;
-                            else
+                            
                             return 0;
                         }
-                        else
                         return 0;
                     });
                 }
-                else
-                {
-                    Debug.Console(2, this, "No Input Card defined in slot: {0}", tempX);
             }
         }
 
-            return base.CustomActivate();
-        }
-
-        /// <summary>
-        /// Checks for presence of config property defining if the input card supports HDCP2.
-        /// If not found, assumes false.
-        /// </summary>
-        /// <param name="inputSlot">Input Slot</param>
-        void CheckForHdcp2Property(uint inputSlot)
-        {
-            if (!PropertiesConfig.InputSlotSupportsHdcp2.ContainsKey(inputSlot))
-            {
-                Debug.Console(0, this, Debug.ErrorLogLevel.Warning,
-@"Properties Config does not define inputSlotSupportsHdcp2 entry for input card: {0}.  Assuming false.  
-If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", inputSlot);
-                PropertiesConfig.InputSlotSupportsHdcp2.Add(inputSlot, false);
-            }
-            else
-                Debug.Console(2, this, "inputSlotSupportsHdcp2 for input card: {0} = {1}", inputSlot, PropertiesConfig.InputSlotSupportsHdcp2[inputSlot]);
-        }
-
         /// <summary>
         /// 
         /// </summary>
@@ -517,7 +491,8 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             {
                 new DmcSdi(number, Chassis);
                 AddInputPortWithDebug(number, "sdiIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi);
-                AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Sdi, null);
+                AddOutputPortWithDebug(string.Format("inputCard{0}", number), "sdiOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Sdi, null);
                 AddInCardHdmiAndAudioLoopPorts(number);
             }
             else if (type == "dmcdvi")
@@ -577,6 +552,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat);
             AddInCardHdmiAndAudioLoopPorts(number);
         }
+
         void AddDmInCardPorts(uint number, ICec cecPort)
         {
             AddInputPortWithDebug(number, "dmIn", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, cecPort);
@@ -591,13 +567,15 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         void AddInCardHdmiAndAudioLoopPorts(uint number)
         {
-            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null);
             AddOutputPortWithDebug(string.Format("inputCard{0}", number), "audioLoopOut", eRoutingSignalType.Audio, eRoutingPortConnectionType.Hdmi, null);
         }
 
         void AddInCardHdmiLoopPort(uint number)
         {
-            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, null);
+            AddOutputPortWithDebug(string.Format("inputCard{0}", number), "hdmiLoopOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, null);
         }
 
         /// <summary>
@@ -617,13 +595,6 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                 var cecPort2 = outputCard.Card2.HdmiOutput;
                 AddDmcHdoPorts(number, cecPort1, cecPort2);
             }
-            else if (type == "dmc4kzhdo")
-            {
-                var outputCard = new Dmc4kzHdoSingle(number, Chassis);
-                var cecPort1 = outputCard.Card1.HdmiOutput;
-                var cecPort2 = outputCard.Card2.HdmiOutput;
-                AddDmcHdoPorts(number, cecPort1, cecPort2);
-            }
             else if (type == "dmchdo")
             {
                 var outputCard = new DmcHdoSingle(number, Chassis);
@@ -659,23 +630,29 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             {
                 var outputCard = new DmcSoHdSingle(number, Chassis);
                 var cecPort1 = outputCard.Card1.HdmiOutput;
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                    eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 1);
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-
+                    eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.DmMmFiber, 2 * (number - 1) + 2);
             }
             else if (type == "dmcs2ohd")
             {
                 var outputCard = new DmcS2oHdSingle(number, Chassis);
                 var cecPort1 = outputCard.Card1.HdmiOutput;
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                    eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 1);
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.DmSmFiber, 2 * (number - 1) + 2);
             }
             else if (type == "dmcstro")
             {
                 var outputCard = new DmcStroSingle(number, Chassis);
-                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
+                AddOutputPortWithDebug(string.Format("outputCard{0}", number), "streamOut", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                    eRoutingPortConnectionType.Streaming, 2 * (number - 1) + 1);
             }
 
             else
@@ -684,20 +661,26 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         void AddDmcHdoPorts(uint number, ICec cecPort1, ICec cecPort2)
         {
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 1);
+                eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut1", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio,
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio, 2 * (number - 1) + 2);
+                2 * (number - 1) + 1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 2, cecPort2);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "audioOut2", eRoutingSignalType.Audio, eRoutingPortConnectionType.LineAudio,
+                2 * (number - 1) + 2);
         }
 
         void AddDmcCoPorts(uint number, ICec cecPort1)
         {
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+                eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 1);
-            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video, eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "hdmiOut1", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.Hdmi, 2 * (number - 1) + 1, cecPort1);
+            AddOutputPortWithDebug(string.Format("outputCard{0}", number), "dmOut2", eRoutingSignalType.Audio | eRoutingSignalType.Video,
+                eRoutingPortConnectionType.DmCat, 2 * (number - 1) + 2);
         }
 
-
         /// <summary>
         /// Adds InputPort
         /// </summary>
@@ -719,16 +702,11 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             Debug.Console(2, this, "Adding input port '{0}'", portKey);
             var inputPort = new RoutingInputPort(portKey, sigType, portType, cardNum, this);
 
-            if (inputPort != null)
-            {
             if (cecPort != null)
                 inputPort.Port = cecPort;
 
             InputPorts.Add(inputPort);
         }
-            else
-                Debug.Console(2, this, "inputPort is null");
-        }
 
         /// <summary>
         /// Adds OutputPort
@@ -768,7 +746,6 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         //}
 
-
         void Chassis_DMSystemChange(Switch device, DMSystemEventArgs args)
         {
             switch (args.EventId)
@@ -790,8 +767,8 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
 
         void Chassis_DMInputChange(Switch device, DMInputEventArgs args)
         {
-				
+            switch (args.EventId)
-		    switch (args.EventId) {
+            {
                 case DMInputEventIds.EndpointOnlineEventId:
                 {
                     Debug.Console(2, this, "DM Input EndpointOnlineEventId for input: {0}. State: {1}", args.Number, device.Inputs[args.Number].EndpointOnlineFeedback);
@@ -819,7 +796,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                 case DMInputEventIds.UsbRoutedToEventId:
                 {
                     Debug.Console(2, this, "DM Input {0} UsbRoutedToEventId", args.Number);
-                        if(UsbInputRoutedToFeebacks[args.Number] != null)
+                    if (UsbInputRoutedToFeebacks[args.Number] != null)
                         UsbInputRoutedToFeebacks[args.Number].FireUpdate();
                     else
                         Debug.Console(1, this, "No index of {0} found in UsbInputRoutedToFeedbacks");
@@ -841,6 +818,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                 }
             }
         }
+
         /// 
         /// </summary>
         void Chassis_DMOutputChange(Switch device, DMOutputEventArgs args)
@@ -855,51 +833,47 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                     {
                         VolumeControls[args.Number].VolumeEventFromChassis();
                     }
+
                     break;
                 }
                 case DMOutputEventIds.EndpointOnlineEventId:
                 {
-                    Debug.Console(2, this, "Output {0} DMOutputEventIds.EndpointOnlineEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
+                    Debug.Console(2, this, "Output {0} DMOutputEventIds.EndpointOnlineEventId fired. State: {1}", args.Number,
+                        Chassis.Outputs[output].EndpointOnlineFeedback);
                     OutputEndpointOnlineFeedbacks[output].FireUpdate();
                     break;
                 }
                 case DMOutputEventIds.OnlineFeedbackEventId:
                 {
-                    Debug.Console(2, this, "Output {0} DMInputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number, Chassis.Outputs[output].EndpointOnlineFeedback);
+                    Debug.Console(2, this, "Output {0} DMInputEventIds.OnlineFeedbackEventId fired. State: {1}", args.Number,
+                        Chassis.Outputs[output].EndpointOnlineFeedback);
                     OutputEndpointOnlineFeedbacks[output].FireUpdate();
                     break;
                 }
                 case DMOutputEventIds.VideoOutEventId:
                 {
                     if (Chassis.Outputs[output].VideoOutFeedback != null)
-                    {
                         Debug.Console(2, this, "DMSwitchVideo:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].VideoOutFeedback.Number, output);
-                    }
+
                     if (VideoOutputFeedbacks.ContainsKey(output))
-                    {
                         VideoOutputFeedbacks[output].FireUpdate();
 
-                    }
                     if (OutputVideoRouteNameFeedbacks.ContainsKey(output))
-                    {
                         OutputVideoRouteNameFeedbacks[output].FireUpdate();
-                    }
+
                     break;
                 }
                 case DMOutputEventIds.AudioOutEventId:
                 {
                     if (Chassis.Outputs[output].AudioOutFeedback != null)
-                    {
                         Debug.Console(2, this, "DMSwitchAudio:{0} Routed Input:{1} Output:{2}'", this.Name, Chassis.Outputs[output].AudioOutFeedback.Number, output);
-                    }
+
                     if (AudioOutputFeedbacks.ContainsKey(output))
-                    {
                         AudioOutputFeedbacks[output].FireUpdate();
-                    }
+
                     if (OutputAudioRouteNameFeedbacks.ContainsKey(output))
-                    {
                         OutputAudioRouteNameFeedbacks[output].FireUpdate();
-                    }
+
                     break;
                 }
                 case DMOutputEventIds.OutputNameEventId:
@@ -914,13 +888,18 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                     UsbOutputRoutedToFeebacks[args.Number].FireUpdate();
                     break;
                 }
+                case DMOutputEventIds.DisabledByHdcpEventId:
+                {
+                    Debug.Console(2, this, "DM Output {0} DisabledByHdcpEventId", args.Number);
+                    OutputDisabledByHdcpFeedbacks[args.Number].FireUpdate();
+                    break;
+                }
                 default:
                 {
                     Debug.Console(2, this, "DMOutputChange fired for Output {0} with Unhandled EventId: {1}", args.Number, args.EventId);
                     break;
                 }
             }
-
         }
 
         /// <summary>
@@ -931,13 +910,9 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
         {
             if (RouteOffTimers.ContainsKey(pnt))
                 return;
-			RouteOffTimers[pnt] = new CTimer(o =>
+            RouteOffTimers[pnt] = new CTimer(o => { ExecuteSwitch(0, pnt.Number, pnt.Type); }, RouteOffTime);
-			{
-				ExecuteSwitch(0, pnt.Number, pnt.Type);
-			}, RouteOffTime);
         }
 
-
         // Send out sigs when coming online
         void IsOnline_OutputChange(object sender, EventArgs e)
         {
@@ -950,19 +925,19 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
                     foreach (var kvp in InputNames)
                         Chassis.Inputs[kvp.Key].Name.StringValue = kvp.Value;
                 if (OutputNames != null)
-					foreach(var kvp in OutputNames)
+                    foreach (var kvp in OutputNames)
                         Chassis.Outputs[kvp.Key].Name.StringValue = kvp.Value;
             }
         }
 
         #region IRouting Members
-
         public void ExecuteSwitch(object inputSelector, object outputSelector, eRoutingSignalType sigType)
         {
             Debug.Console(2, this, "Making an awesome DM route from {0} to {1} {2}", inputSelector, outputSelector, sigType);
 
             var input = Convert.ToUInt32(inputSelector); // Cast can sometimes fail
             var output = Convert.ToUInt32(outputSelector);
+
             // Check to see if there's an off timer waiting on this and if so, cancel
             var key = new PortNumberType(output, sigType);
             if (input == 0)
@@ -971,7 +946,7 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             }
             else
             {
-				if(RouteOffTimers.ContainsKey(key))
+                if (RouteOffTimers.ContainsKey(key))
                 {
                     Debug.Console(2, this, "{0} cancelling route off due to new source", output);
                     RouteOffTimers[key].Stop();
@@ -1005,11 +980,10 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
             if ((sigType | eRoutingSignalType.UsbInput) == eRoutingSignalType.UsbInput)
             {
                 Chassis.USBEnter.BoolValue = true;
-                if(Chassis.Inputs[input] != null)
+                if (Chassis.Inputs[input] != null)
                     Chassis.Inputs[input].USBRoutedTo = outCard;
             }
         }
-
         #endregion
     }
 
@@ -1018,10 +992,12 @@ If HDCP2 is required, HDCP control/feedback will not fucntion correctly!", input
         public uint Number { get; private set; }
         public eRoutingSignalType Type { get; private set; }
 
-		public PortNumberType(uint number, eRoutingSignalType type) : this()
+        public PortNumberType(uint number, eRoutingSignalType type)
+            : this()
         {
             Number = number;
             Type = type;
         }
     }
+
 }

essentials-framework/Essentials DM/Essentials_DM/Config/DeviceFactory.cs

@@ -29,15 +29,18 @@ namespace PepperDash.Essentials.DM
 			var typeName = dc.Type.ToLower();
 
             if (typeName.StartsWith("am"))
+            {
+                if (typeName == "am200" || typeName == "am300")
                 {
                     var props = JsonConvert.DeserializeObject<AirMediaPropertiesConfig>(properties.ToString());
                     AmX00 amDevice = null;
                     if (typeName == "am200")
                         amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am200(props.Control.IpIdInt, Global.ControlSystem);
-                else if(typeName == "am300")
+                    else if (typeName == "am300")
                         amDevice = new Crestron.SimplSharpPro.DM.AirMedia.Am300(props.Control.IpIdInt, Global.ControlSystem);
 
                     return new AirMediaController(key, name, amDevice, dc, props);
+                }
             }
 			else if (typeName.StartsWith("dmmd8x") || typeName.StartsWith("dmmd16x") || typeName.StartsWith("dmmd32x"))
 			{

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx200Controller.cs

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM
     /// <summary>
     /// Controller class for all DM-TX-201C/S/F transmitters
     /// </summary>
-    public class DmTx200Controller : DmTxControllerBase, ITxRouting, IHasFeedback
+    public class DmTx200Controller : DmTxControllerBase, ITxRouting, IHasFeedback, IHasFreeRun, IVgaBrightnessContrastControls
     {
         public DmTx200C2G Tx { get; private set; }
 
@@ -32,8 +32,10 @@ namespace PepperDash.Essentials.DM
         public IntFeedback AudioSourceNumericFeedback { get; protected set; }
         public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
 
-        //public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
-        //public override ushort HdcpSupportCapability { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+        public IntFeedback VgaContrastFeedback { get; protected set; }
 
         /// <summary>
         /// Helps get the "real" inputs, including when in Auto
@@ -123,6 +125,14 @@ namespace PepperDash.Essentials.DM
 
             HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
 
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
+
+
             var combinedFuncs = new VideoStatusFuncsWrapper
             {
                 HdcpActiveFeedbackFunc = () =>
@@ -170,6 +180,21 @@ namespace PepperDash.Essentials.DM
             DmOutput.Port = Tx.DmOutput;
         }
 
+        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
+            {
+                VgaBrightnessFeedback.FireUpdate();
+            }
+            else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
+            {
+                VgaContrastFeedback.FireUpdate();
+            }
+        }
+
         void Tx_OnlineStatusChange(GenericBase currentDevice, OnlineOfflineEventArgs args)
         {
             ActiveVideoInputFeedback.FireUpdate();
@@ -191,6 +216,40 @@ namespace PepperDash.Essentials.DM
             return base.CustomActivate();
         }
 
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
+        public void SetFreeRunEnabled(bool enable)
+        {
+            if (enable)
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
+            }
+            else
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
+            }
+        }
+
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
         public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
         {
             Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx401CController.cs

@@ -17,7 +17,7 @@ namespace PepperDash.Essentials.DM
 {
 	using eVst = DmTx401C.eSourceSelection;
 
-    public class DmTx401CController : DmTxControllerBase, ITxRouting, IHasFeedback, IIROutputPorts, IComPorts
+    public class DmTx401CController : DmTxControllerBase, ITxRouting, IHasFeedback, IIROutputPorts, IComPorts, IHasFreeRun, IVgaBrightnessContrastControls
 	{
 		public DmTx401C Tx { get; private set; }
 
@@ -34,6 +34,11 @@ namespace PepperDash.Essentials.DM
         public IntFeedback AudioSourceNumericFeedback { get; protected set; }
         public IntFeedback HdmiInHdcpCapabilityFeedback { get; protected set; }
 
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+        public IntFeedback VgaContrastFeedback { get; protected set; }
+
 		/// <summary>
 		/// Helps get the "real" inputs, including when in Auto
 		/// </summary>
@@ -130,6 +135,13 @@ namespace PepperDash.Essentials.DM
 
             HdcpSupportCapability = eHdcpCapabilityType.HdcpAutoSupport;
 
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
+
 			var combinedFuncs = new VideoStatusFuncsWrapper
 			{
 				HdcpActiveFeedbackFunc = () =>
@@ -269,6 +281,55 @@ namespace PepperDash.Essentials.DM
             }
 		}
 
+        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
+            {
+                VgaBrightnessFeedback.FireUpdate();
+            }
+            else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
+            {
+                VgaContrastFeedback.FireUpdate();
+            }
+        }
+
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
+        public void SetFreeRunEnabled(bool enable)
+        {
+            if (enable)
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
+            }
+            else
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
+            }
+        }
+
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
 		/// <summary>
 		/// Relays the input stream change to the appropriate RoutingInputPort.
 		/// </summary>

essentials-framework/Essentials DM/Essentials_DM/Endpoints/Transmitters/DmTx4k302CController.cs

@@ -19,7 +19,7 @@ namespace PepperDash.Essentials.DM
     using eAst = Crestron.SimplSharpPro.DeviceSupport.eX02AudioSourceType;
 
     public class DmTx4k302CController : DmTxControllerBase, ITxRouting, IHasFeedback, 
-		IIROutputPorts, IComPorts
+		IIROutputPorts, IComPorts, IHasFreeRun, IVgaBrightnessContrastControls
 	{
 		public DmTx4k302C Tx { get; private set; }
 
@@ -35,8 +35,10 @@ namespace PepperDash.Essentials.DM
         public IntFeedback HdmiIn1HdcpCapabilityFeedback { get; protected set; }
         public IntFeedback HdmiIn2HdcpCapabilityFeedback { get; protected set; }
 
-        //public override IntFeedback HdcpSupportAllFeedback { get; protected set; }
+        public BoolFeedback FreeRunEnabledFeedback { get; protected set; }
-        //public override ushort HdcpSupportCapability { get; protected set; }
+
+        public IntFeedback VgaBrightnessFeedback { get; protected set; }
+        public IntFeedback VgaContrastFeedback { get; protected set; }
 
 		/// <summary>
 		/// Helps get the "real" inputs, including when in Auto
@@ -122,6 +124,13 @@ namespace PepperDash.Essentials.DM
 
             HdcpSupportCapability = eHdcpCapabilityType.Hdcp2_2Support;
 
+            FreeRunEnabledFeedback = new BoolFeedback(() => tx.VgaInput.FreeRunFeedback == eDmFreeRunSetting.Enabled);
+
+            VgaBrightnessFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.BrightnessFeedback.UShortValue);
+            VgaContrastFeedback = new IntFeedback(() => tx.VgaInput.VideoControls.ContrastFeedback.UShortValue);
+
+            tx.VgaInput.VideoControls.ControlChange += new Crestron.SimplSharpPro.DeviceSupport.GenericEventHandler(VideoControls_ControlChange);
+
 
 			var combinedFuncs = new VideoStatusFuncsWrapper
 			{
@@ -181,6 +190,21 @@ namespace PepperDash.Essentials.DM
             DmOut.Port = Tx.DmOutput;
 		}
 
+        void VideoControls_ControlChange(object sender, Crestron.SimplSharpPro.DeviceSupport.GenericEventArgs args)
+        {
+            var id = args.EventId;
+            Debug.Console(2, this, "EventId {0}", args.EventId);
+
+            if (id == VideoControlsEventIds.BrightnessFeedbackEventId)
+            {
+                VgaBrightnessFeedback.FireUpdate();
+            }
+            else if (id == VideoControlsEventIds.ContrastFeedbackEventId)
+            {
+                VgaContrastFeedback.FireUpdate();
+            }
+        }
+
 
 
 		public override bool CustomActivate()
@@ -199,6 +223,42 @@ namespace PepperDash.Essentials.DM
 			return base.CustomActivate();
 		}
 
+        /// <summary>
+        /// Enables or disables free run
+        /// </summary>
+        /// <param name="enable"></param>
+        public void SetFreeRunEnabled(bool enable)
+        {
+            if (enable)
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Enabled;
+            }
+            else
+            {
+                Tx.VgaInput.FreeRun = eDmFreeRunSetting.Disabled;
+            }
+        }
+
+        /// <summary>
+        /// Sets the VGA brightness level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaBrightness(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Brightness.UShortValue = level;
+        }
+
+        /// <summary>
+        /// Sets the VGA contrast level
+        /// </summary>
+        /// <param name="level"></param>
+        public void SetVgaContrast(ushort level)
+        {
+            Tx.VgaInput.VideoControls.Contrast.UShortValue = level;
+        }
+
+
+
         public void ExecuteNumericSwitch(ushort input, ushort output, eRoutingSignalType type)
         {
             Debug.Console(2, this, "Executing Numeric Switch to input {0}.", input);

essentials-framework/Essentials DM/Essentials_DM/Essentials_DM.csproj

@@ -82,6 +82,10 @@
       <HintPath>..\..\..\..\..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpPro.exe</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="SimplSharpReflectionInterface, Version=1.0.5583.25238, Culture=neutral, PublicKeyToken=1099c178b3b54c3b, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\..\..\ProgramData\Crestron\SDK\SimplSharpReflectionInterface.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Data" />

essentials-framework/Essentials DM/Essentials_DM/Properties/AssemblyInfo.cs

@@ -1,7 +1,10 @@
 using System.Reflection;
+using Crestron.SimplSharp.Reflection;
 
-[assembly: AssemblyTitle("Essentials_DM")]
+[assembly: System.Reflection.AssemblyTitle("Essentials_DM")]
-[assembly: AssemblyCompany("PepperDash Technology Corp")]
+[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
-[assembly: AssemblyProduct("Essentials_DM")]
+[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
-[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
-[assembly: AssemblyVersion("1.3.*")]
+[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
+[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
+[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOccupancySensorBaseController.cs

@@ -103,6 +103,18 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
                 PirSensitivityInOccupiedStateFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.PirSensitivityInVacantStateFeedbackEventId)
                 PirSensitivityInVacantStateFeedback.FireUpdate();
+        }
+
+        protected virtual void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+        {
+            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
+
+            if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId 
+                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
+            {
+                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
+                RoomIsOccupiedFeedback.FireUpdate();
+            }
             else if (args.EventId == GlsOccupancySensorBase.TimeoutFeedbackEventId)
                 CurrentTimeoutFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.TimeoutLocalFeedbackEventId)
@@ -117,18 +129,6 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
                 ExternalPhotoSensorValue.FireUpdate();
         }
 
-        void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
-        {
-            Debug.Console(2, this, "GlsOccupancySensorChange  EventId: {0}", args.EventId);
-
-            if (args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomOccupiedFeedbackEventId 
-                || args.EventId == Crestron.SimplSharpPro.GeneralIO.GlsOccupancySensorBase.RoomVacantFeedbackEventId)
-            {
-                Debug.Console(1, this, "Occupancy State: {0}", OccSensor.OccupancyDetectedFeedback.BoolValue);
-                RoomIsOccupiedFeedback.FireUpdate();
-            }
-        }
-
         public void SetTestMode(bool mode)
         {
             InTestMode = mode;

essentials-framework/Essentials Devices Common/Essentials Devices Common/Occupancy/GlsOdtOccupancySensorController.cs

@@ -69,10 +69,6 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
                 UltrasonicAEnabledFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.UsBEnabledFeedbackEventId)
                 UltrasonicBEnabledFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
-                RawOccupancyPirFeedback.FireUpdate();
-            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
-                RawOccupancyUsFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInOccupiedStateFeedbackEventId)
                 UltrasonicSensitivityInOccupiedStateFeedback.FireUpdate();
             else if (args.EventId == GlsOccupancySensorBase.UsSensitivityInVacantStateFeedbackEventId)
@@ -81,6 +77,22 @@ namespace PepperDash.Essentials.Devices.Common.Occupancy
             base.OccSensor_GlsOccupancySensorChange(device, args);
         }
 
+        /// <summary>
+        /// Overrides the base class event delegate to fire feedbacks for event IDs that pertain to this extended class.
+        /// Then calls the base delegate method to ensure any common event IDs are captured.
+        /// </summary>
+        /// <param name="device"></param>
+        /// <param name="args"></param>
+        protected override void OccSensor_BaseEvent(Crestron.SimplSharpPro.GenericBase device, Crestron.SimplSharpPro.BaseEventArgs args)
+        {
+             if (args.EventId == GlsOccupancySensorBase.RawOccupancyPirFeedbackEventId)
+                RawOccupancyPirFeedback.FireUpdate();
+            else if (args.EventId == GlsOccupancySensorBase.RawOccupancyUsFeedbackEventId)
+                RawOccupancyUsFeedback.FireUpdate();
+
+            base.OccSensor_BaseEvent(device, args);
+        }
+
         /// <summary>
         /// Sets the OrWhenVacated state
         /// </summary>

essentials-framework/Essentials Devices Common/Essentials Devices Common/Properties/AssemblyInfo.cs

@@ -1,7 +1,10 @@
 using System.Reflection;
+using Crestron.SimplSharp.Reflection;
 
-[assembly: AssemblyTitle("Essentials_Devices_Common")]
+[assembly: System.Reflection.AssemblyTitle("Essentials_Devices_Common")]
-[assembly: AssemblyCompany("PepperDash Technology Corp")]
+[assembly: System.Reflection.AssemblyCompany("PepperDash Technology Corp")]
-[assembly: AssemblyProduct("Essentials_Devices_Common")]
+[assembly: System.Reflection.AssemblyProduct("PepperDashEssentials")]
-[assembly: AssemblyCopyright("Copyright ©  2019")]
+[assembly: System.Reflection.AssemblyCopyright("Copyright © PepperDash Technology Corp 2020")]
-[assembly: AssemblyVersion("1.4.*")]
+[assembly: System.Reflection.AssemblyVersion("0.0.0.*")]
+[assembly: System.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]
+[assembly: Crestron.SimplSharp.Reflection.AssemblyInformationalVersion("0.0.0-buildType-buildNumber")]

essentials-framework/Essentials Devices Common/Essentials Devices Common/SetTopBox/IRSetTopBoxBase.cs

@@ -12,7 +12,7 @@ using PepperDash.Essentials.Core.Routing;
 
 namespace PepperDash.Essentials.Devices.Common
 {
-	public class IRSetTopBoxBase : Device, ISetTopBoxControls, IUiDisplayInfo, IRoutingOutputs, IUsageTracking
+	public class IRSetTopBoxBase : Device, ISetTopBoxControls, IUiDisplayInfo, IRoutingOutputs, IUsageTracking, IPower
 	{
 		public IrOutputPortController IrPort { get; private set; }
 
@@ -339,5 +339,33 @@ namespace PepperDash.Essentials.Devices.Common
         public UsageTracking UsageTracker { get; set; }
 
         #endregion
+
+        #region IPower Members
+
+        public void PowerOn()
+        {
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_ON, true);
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_ON, false);
+
+        }
+
+        public void PowerOff()
+        {
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_OFF, true);
+            IrPort.PressRelease(IROutputStandardCommands.IROut_POWER_OFF, false);
+
+        }
+
+        public void PowerToggle()
+        {
+            throw new NotImplementedException(); 
+        }
+
+        public BoolFeedback PowerIsOnFeedback
+        {
+            get { throw new NotImplementedException(); }
+        }
+
+        #endregion
     }
 }