private void ResolveCertificatePaths(MachineConfiguration info)
{
var storePath = info.AuthConfig.StorePath;
var caCertPath = Path.Combine(storePath, DefaultCaCertName);
var clientCertPath = Path.Combine(storePath, DefaultClientCertName);
var clientKeyPath = Path.Combine(storePath, DefaultClientKeyName);
if (File.Exists(clientCertPath) && File.Exists(caCertPath) && File.Exists(clientKeyPath))
{
// Check if ca, client and key is in the store path
// if so use those instead.
Certificates = new CertificatePaths
{
CaCertificate = info.AuthConfig.CaCertPath,
ClientCertificate = info.AuthConfig.ClientCertPath,
ClientKey = info.AuthConfig.ClientKeyPath
};
return;
}
// Otherwise use the defaults
Certificates = new CertificatePaths
{
CaCertificate = info.AuthConfig.CaCertPath,
ClientCertificate = info.AuthConfig.ClientCertPath,
ClientKey = info.AuthConfig.ClientKeyPath
};
}
public override void UserConfigLoad()
{
//** Define Machines/Presses and the MAC address for the ADAM Module
//** Example
//** var Z11 = AddMachine("Z-1-1","Press","FF-FF-FF-FF-FF")
_defaultDepartment = "Test Department";
MachineIsRunningGracePeriodInSeconds = 90;
EmailServerConfiguration = new EmailServerConfiguration()
{
EmailServer = "smtp.ipower.com",
EmailServerPort = 587,
Credentials = ("*****@*****.**", "Betz-320")
};
DatabaseConfiguration = new DatabaseConfiguration("172.16.28.250", "RALSystem", "1234", "TRMI_RAL_System_Dev");
var listOfStackLightConfigs = new StackLightConfiguration[]
{
AddStackLight("172.16.28.151", "Row 1 Stack Light"),
AddStackLight("172.16.28.152", "Row 2 Stack Light"),
AddStackLight("172.16.28.153", "Row 3 Stack Light"),
AddStackLight("172.16.28.154", "Row 4 Stack Light"),
AddStackLight("172.16.28.155", "Row 5 Stack Light"),
AddStackLight("172.16.28.156", "Row 6 Stack Light"),
AddStackLight("172.16.28.157", "Row 7 Stack Light"),
AddStackLight("172.16.28.158", "Row 8 Stack Light")
};
int Converter = 0;
int StackLightNumber = 0;
int LightOnStackLight = 0;
for (int i = 0; i < 40; i++)
{
Converter = Converter < 8 ? Converter : 0;
StackLightNumber = LightOnStackLight < 5 ? StackLightNumber : ++StackLightNumber;
LightOnStackLight = LightOnStackLight < 5 ? LightOnStackLight : 0;
string MAC = "00-D0-C9-FC-A9-BA";
if (i >= 36)
{
if (i == 36)
{
Converter = 0;
}
MAC = "00-D0-C9-FC-A9-C0";
}
var Press = new MachineConfiguration($"Test Line {i + 1}", "Press", MAC, _defaultDepartment, new RAL.Devices.Adam.Mocks.Adam6051StatusConverterForPressMock(Converter++ + 1));
MachineConfigs.Add(Press);
AddLightToMachineMap(Press, (StackLight5Lights.LightNumber)LightOnStackLight++, listOfStackLightConfigs[StackLightNumber]);
}
AddEmailReport(new [] { "*****@*****.**" }, new[] { "*****@*****.**" });
}
public LambdaStateChangedHandlerTests()
{
_config = new MachineConfiguration<TestArgs>();
var args = new TestArgs();
var stateProvider = new ScanningStateProvider<TestArgs>();
_machine = new StateMachine<TestArgs>(_config, stateProvider, args);
}
/// <summary>
/// Create a new machine configuration representation in memory from a file on disk
/// </summary>
/// <param name="PathToFile">The path to the configuration XML file</param>
public void LoadConfig(string PathToFile)
{
MachineConfiguration config = MachineConfiguration.FromFile(PathToFile);
_config = config;
_num_balls_total = config.PRGame.numBalls;
//setup machine items
(PROC as ProcDevice).SetupProcMachine(config, _coils, _switches, _lamps, _leds, _gi);
}
private void btnAddMachine_Click(object sender, EventArgs e)
{
var newMachine = new MachineConfiguration();
newMachine.MachineName = "HostName";
newMachine.UserName = "******";
newMachine.Password = "******";
newMachine.NextConnectionDue = DateTime.Now;
newMachine.LastKnownStatus = "Just Added";
Machines.Add(newMachine);
}
public void AddTwoMachineConfigurationsWithSameMachineName()
{
MachineConfiguration machineConfiguration1 = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
MachineConfiguration machineConfiguration2 = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration1);
repository.Save(machineConfiguration2);
}
}
public void Load()
{
machineConfiguration = LoadMachineConfiguration();
List<ProductionStopViewEntity> productionStops = new List<ProductionStopViewEntity>();
foreach (ProductionStop p in machineConfiguration.AvailableProductionStops)
{
if (p != null)
productionStops.Add(new ProductionStopViewEntity(p));
}
productionStopViewEntityBindingSource.DataSource = productionStops;
}
public void AddNewMachineConfigurations()
{
MachineConfiguration machineConfiguration1 = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
MachineConfiguration machineConfiguration2 = new MachineConfiguration("Machine B", new ProductionStop[] { productionStop1, productionStop2 });
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration1);
repository.Save(machineConfiguration2);
}
Assert.AreNotEqual(machineConfiguration1.Id, machineConfiguration2.Id);
}
public static StateMachine<CreditRequest> Create(CreditRequest request)
{
var provider = new ScanningStateProvider<CreditRequest>();
var config = new MachineConfiguration<CreditRequest>();
config.OnStateChange(
reset: (sender, args) => args.Switches.State = args.Next.GetType(),
enter: (sender, args) => args.Switches.State = args.Next.GetType()
);
var machine = new StateMachine<CreditRequest>(config, provider, request);
machine.ResetTo(request.State);
return machine;
}
public void AddNewMachineConfiguration()
{
MachineConfiguration machineConfiguration = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
Assert.AreEqual(0, machineConfiguration.Id);
Assert.AreEqual(0, machineConfiguration.Version);
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration);
}
Assert.AreNotEqual(0, machineConfiguration.Id);
Assert.AreNotEqual(0, machineConfiguration.Version);
}
public void GetGlobals(MachineConfiguration config)
{
if (config.PRDriverGlobals != null)
{
lamp_matrix_strobe_time = config.PRDriverGlobals.lamp_matrix_strobe_time;
watchdog_time = config.PRDriverGlobals.watchdog_time;
use_watchdog = config.PRDriverGlobals.use_watchdog;
}
else
{
lamp_matrix_strobe_time = 200;
watchdog_time = 1000;
use_watchdog = true;
}
}
static async Task Main(string[] args)
{
ProcDevice PROC = null;
try
{
Console.WriteLine("Creating PROC");
PROC = new ProcDevice(MachineType.PDB);
await Task.Delay(100);
PROC?.Reset(1);
//load machine config.
var config = MachineConfiguration.FromFile("machine.json");
//create collections to pass into the setup.
//The GameController does this for you in LoadConfig, but this is to test without a game
_switches = new AttrCollection <ushort, string, Switch>();
_leds = new AttrCollection <ushort, string, LED>();
_coils = new AttrCollection <ushort, string, IDriver>();
//setup machine items to be able to process events.
(PROC as ProcDevice).SetupProcMachine(config, _switches: _switches, _leds: _leds, _coils: _coils);
//listen for cancel keypress and end run loop
Console.CancelKeyPress += (sender, eventArgs) =>
{
Console.WriteLine("ctrl+C triggered");
source.Cancel();
eventArgs.Cancel = true;
};
//run game loop
await RunLoop(PROC);
//close console
Console.WriteLine("netprocgame closing...");
await Task.Delay(500);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
public void When_finding_custom_states()
{
var scanner = new ScanningStateProvider<CreditRequest>();
var provider = new MappingStateProvider(scanner);
var config = new MachineConfiguration<CreditRequest>();
config.OnStateChange(
reset: (sender, args) => args.Switches.Progress = ((CustomState<CreditRequest>)args.Next).Type,
enter: (sender, args) => args.Switches.Progress = ((CustomState<CreditRequest>)args.Next).Type
);
var request = LoadFromDatabase();
var machine = new StateMachine<CreditRequest>(provider, request);
machine.ResetTo(provider.StateFrom(request.Progress).GetType());
machine.CurrentState.ShouldBeOfType<Approved>();
}
private static MachineConfiguration AddMachineConfiguration(DeviceElement adaptDeviceElement, DeviceElementHierarchy deviceHierarchy, AgGateway.ADAPT.ApplicationDataModel.ADM.Catalog catalog)
{
MachineConfiguration machineConfig = new MachineConfiguration();
//Description
machineConfig.Description = $"{deviceHierarchy.DeviceElement.Device.DeviceDesignator} : {deviceHierarchy.DeviceElement.DeviceElementDesignator}";
//Device Element ID
machineConfig.DeviceElementId = adaptDeviceElement.Id.ReferenceId;
//Offsets
if (deviceHierarchy.XOffset.HasValue ||
deviceHierarchy.YOffset.HasValue ||
deviceHierarchy.ZOffset.HasValue)
{
machineConfig.Offsets = new List <NumericRepresentationValue>();
if (deviceHierarchy.XOffset != null)
{
machineConfig.Offsets.Add(deviceHierarchy.XOffsetRepresentation);
}
if (deviceHierarchy.YOffset != null)
{
machineConfig.Offsets.Add(deviceHierarchy.YOffsetRepresentation);
}
if (deviceHierarchy.ZOffset != null)
{
machineConfig.Offsets.Add(deviceHierarchy.ZOffsetRepresentation);
}
}
//GPS Offsets
if (deviceHierarchy.Children != null && deviceHierarchy.Children.Any(h => h.DeviceElement != null && h.DeviceElement.DeviceElementType == ISODeviceElementType.Navigation))
{
DeviceElementHierarchy navigation = (deviceHierarchy.Children.First(h => h.DeviceElement.DeviceElementType == ISODeviceElementType.Navigation));
machineConfig.GpsReceiverXOffset = navigation.XOffsetRepresentation;
machineConfig.GpsReceiverYOffset = navigation.YOffsetRepresentation;
machineConfig.GpsReceiverZOffset = navigation.ZOffsetRepresentation;
}
catalog.DeviceElementConfigurations.Add(machineConfig);
return(machineConfig);
}
// Constructor
public Machine(IDevice device, GatewayHubHandler gatewayHubCommunication, MachineConfiguration machineConfiguration)
{
_device = device;
_machineStateStarted = DateTime.Now;
MachineConfiguration = machineConfiguration;
_gatewayHubCommunication = gatewayHubCommunication;
device.Inputs[machineConfiguration.CycleInputPin].InputChanged += InputInterpretation;
CurrentMachineState = DataAccess.MachineStateHistory.State.Stopped;
LastMachineStateInMachineStateHistory = DataAccess.MachineStateHistory.State.Stopped;
MachineStateHistory = new List <MachineStateHistory>();
_timerCycleTimeOut = ThreadPoolTimer.CreatePeriodicTimer(CycleTimeOut,
TimeSpan.FromMilliseconds(machineConfiguration.MachineStateTimeout));
_timerMachineDataPublish = ThreadPoolTimer.CreatePeriodicTimer(PublishActualMachineData,
TimeSpan.FromMilliseconds(machineConfiguration.PublishingIntervall));
}
public void DeleteMachineConfigurations()
{
MachineConfiguration machineConfiguration1 = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
MachineConfiguration machineConfiguration2 = new MachineConfiguration("Machine B", new ProductionStop[] { productionStop1, productionStop2 });
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration1);
repository.Save(machineConfiguration2);
}
List<MachineConfiguration> list = null;
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
list = new List<MachineConfiguration>(repository.LoadAll());
}
CollectionAssert.AreEquivalent(new MachineConfiguration[] { machineConfiguration1, machineConfiguration2 }, list);
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Delete(machineConfiguration2);
}
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
list = new List<MachineConfiguration>(repository.LoadAll());
}
CollectionAssert.AreEquivalent(new MachineConfiguration[] { machineConfiguration1 }, list);
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Delete(machineConfiguration1);
}
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
list = new List<MachineConfiguration>(repository.LoadAll());
}
CollectionAssert.AreEquivalent(new MachineConfiguration[] { }, list);
}
/// <summary>
/// Create a new machine configuration representation in memory from a file on disk
/// </summary>
/// <param name="PathToFile">The path to the configuration XML file</param>
public void LoadConfig(string PathToFile)
{
MachineConfiguration config = MachineConfiguration.FromFile(PathToFile);
foreach (CoilConfigFileEntry ce in config.PRCoils)
{
Driver d = new Driver(this, ce.Name, PinProc.PRDecode(_machineType, ce.Number));
Log("Adding driver " + d.ToString());
_coils.Add(d.Number, d.Name, d);
}
foreach (LampConfigFileEntry le in config.PRLamps)
{
Driver d = new Driver(this, le.Name, PinProc.PRDecode(_machineType, le.Number));
Log("Adding lamp " + d.ToString());
_lamps.Add(d.Number, d.Name, d);
}
foreach (GIConfigFileEntry ge in config.PRGI)
{
Driver d = new Driver(this, ge.Name, PinProc.PRDecode(_machineType, ge.Number));
_gi.Add(d.Number, d.Name, d);
}
foreach (SwitchConfigFileEntry se in config.PRSwitches)
{
Switch s = new Switch(this, se.Name, PinProc.PRDecode(_machineType, se.Number), se.Type);
_proc.switch_update_rule(s.Number,
EventType.SwitchClosedDebounced,
new SwitchRule {
NotifyHost = true, ReloadActive = false
},
null,
false
);
_proc.switch_update_rule(s.Number,
EventType.SwitchOpenDebounced,
new SwitchRule {
NotifyHost = true, ReloadActive = false
},
null,
false
);
Log("Adding switch " + s.ToString());
_switches.Add(s.Number, s.Name, s);
}
/// TODO: THIS SHOULD RETURN A LIST OF STATES
EventType[] states = _proc.switch_get_states();
foreach (Switch s in _switches.Values)
{
s.SetState(states[s.Number] == EventType.SwitchClosedDebounced);
}
_num_balls_total = config.PRGame.numBalls;
_config = config;
if (_config.PRGame.displayMonitor)
{
}
}
private void ExportDeviceProperties(ISODeviceElement isoDeviceElement, DeviceElement adaptDeviceElement)
{
//Connectors
if (isoDeviceElement.ChildDeviceElements != null)
{
foreach (ISODeviceElement connectorElement in isoDeviceElement.ChildDeviceElements.Where(d => d.DeviceElementType == ISODeviceElementType.Connector))
{
int?connectorID = TaskDataMapper.InstanceIDMap.GetADAPTID(connectorElement.DeviceElementId);
if (connectorID.HasValue)
{
Connector connector = DataModel.Catalog.Connectors.First(c => c.Id.ReferenceId == connectorID.Value);
HitchPoint hitch = DataModel.Catalog.HitchPoints.FirstOrDefault(h => h.Id.ReferenceId == connector.HitchPointId);
if (hitch != null && hitch.ReferencePoint != null)
{
ExportDeviceProperty(connectorElement, hitch.ReferencePoint.XOffset, ++_devicePropertyObjectID);
ExportDeviceProperty(connectorElement, hitch.ReferencePoint.YOffset, ++_devicePropertyObjectID);
ExportDeviceProperty(connectorElement, hitch.ReferencePoint.ZOffset, ++_devicePropertyObjectID);
}
}
}
}
//Device Element Widths & Offsets
IEnumerable <DeviceElementConfiguration> configs = DataModel.Catalog.DeviceElementConfigurations.Where(c => c.DeviceElementId == adaptDeviceElement.Id.ReferenceId);
foreach (DeviceElementConfiguration config in configs)
{
if (config is MachineConfiguration)
{
MachineConfiguration machineConfig = config as MachineConfiguration;
ISODeviceElement navigationElement = isoDeviceElement.Device.DeviceElements.FirstOrDefault(d => d.DeviceElementType == ISODeviceElementType.Navigation);
if (navigationElement == null)
{
if (machineConfig.GpsReceiverXOffset != null)
{
ExportDeviceProperty(navigationElement, machineConfig.GpsReceiverXOffset, ++_devicePropertyObjectID);
}
if (machineConfig.GpsReceiverYOffset != null)
{
ExportDeviceProperty(navigationElement, machineConfig.GpsReceiverYOffset, ++_devicePropertyObjectID);
}
if (machineConfig.GpsReceiverZOffset != null)
{
ExportDeviceProperty(navigationElement, machineConfig.GpsReceiverZOffset, ++_devicePropertyObjectID);
}
}
}
else if (config is ImplementConfiguration)
{
ImplementConfiguration implementConfig = config as ImplementConfiguration;
if (implementConfig.Width != null)
{
ExportDeviceProperty(isoDeviceElement, implementConfig.Width, ++_devicePropertyObjectID);
}
if (implementConfig.Offsets != null)
{
implementConfig.Offsets.ForEach(o => ExportDeviceProperty(isoDeviceElement, o, ++_devicePropertyObjectID));
}
}
else if (config is SectionConfiguration)
{
SectionConfiguration sectionConfig = config as SectionConfiguration;
if (sectionConfig.InlineOffset != null)
{
ExportDeviceProperty(isoDeviceElement, sectionConfig.InlineOffset, ++_devicePropertyObjectID);
}
if (sectionConfig.LateralOffset != null)
{
ExportDeviceProperty(isoDeviceElement, sectionConfig.LateralOffset, ++_devicePropertyObjectID);
}
if (sectionConfig.SectionWidth != null)
{
ExportDeviceProperty(isoDeviceElement, sectionConfig.SectionWidth, ++_devicePropertyObjectID);
}
}
}
}
public void LoadMachineConfiguration()
{
MachineConfiguration machineConfiguration1 = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
MachineConfiguration machineConfiguration2 = new MachineConfiguration("Machine B", new ProductionStop[] { productionStop2, productionStop1 });
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration1);
repository.Save(machineConfiguration2);
}
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
foreach (MachineConfiguration machineConfiguration in new MachineConfiguration[] { machineConfiguration1, machineConfiguration2 })
{
MachineConfiguration loadedMachineConfiguration = repository.Load(machineConfiguration.Id);
Assert.AreNotSame(machineConfiguration, loadedMachineConfiguration);
Assert.AreEqual(machineConfiguration, loadedMachineConfiguration);
Assert.AreEqual(machineConfiguration.MachineName, loadedMachineConfiguration.MachineName);
CollectionAssert.AreEqual(new List<ProductionStop>(machineConfiguration.AvailableProductionStops), new List<ProductionStop>(loadedMachineConfiguration.AvailableProductionStops));
}
}
}
private void LoadEntities()
{
_repositoryFactory = new RepositoryFactory();
using (IEntityRepository<ProductionTeam> productionTeamRepository = _repositoryFactory.CreateEntityRepository<ProductionTeam>())
{
_availableTeams = productionTeamRepository.LoadAll();
}
using (IEntityRepository<MachineConfiguration> repository = _repositoryFactory.CreateEntityRepository<MachineConfiguration>())
{
List<MachineConfiguration> list = new List<MachineConfiguration>(repository.LoadAll());
if (list.Count > 0)
_machineConfiguration = list[0];
else
_machineConfiguration = new MachineConfiguration(Strings.UnknownMachine, new ProductionStop[0]);
}
}
public void UpdateMachineConfiguration()
{
MachineConfiguration machineConfiguration = new MachineConfiguration("Machine A", new ProductionStop[] { productionStop1, productionStop2 });
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration);
}
machineConfiguration.MachineName = "Machine B";
machineConfiguration.AvailableProductionStops = new ProductionStop[] { productionStop1 };
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
repository.Save(machineConfiguration);
}
using (IEntityRepository<MachineConfiguration> repository = factory.CreateEntityRepository<MachineConfiguration>())
{
MachineConfiguration loadedMachineConfiguration = repository.Load(machineConfiguration.Id);
Assert.AreNotSame(machineConfiguration, loadedMachineConfiguration);
Assert.AreEqual(machineConfiguration, loadedMachineConfiguration);
Assert.AreEqual(machineConfiguration.MachineName, loadedMachineConfiguration.MachineName);
CollectionAssert.AreEqual(new List<ProductionStop>(machineConfiguration.AvailableProductionStops), new List<ProductionStop>(loadedMachineConfiguration.AvailableProductionStops));
}
}
public void SetWidthsAndOffsetsFromSpatialData(IEnumerable <ISOSpatialRow> isoRecords, DeviceElementConfiguration config, RepresentationMapper representationMapper)
{
//Set values on this object and associated DeviceElementConfiguration
if (Width == null)
{
Width = GetWidthFromSpatialData(isoRecords, DeviceElement.DeviceElementId, representationMapper);
}
if (config.Offsets == null)
{
config.Offsets = new List <NumericRepresentationValue>();
}
if (XOffset == null)
{
XOffset = GetXOffsetFromSpatialData(isoRecords, DeviceElement.DeviceElementId, representationMapper);
if (XOffsetRepresentation != null)
{
config.Offsets.Add(XOffsetRepresentation);
}
}
if (YOffset == null)
{
YOffset = GetYOffsetFromSpatialData(isoRecords, DeviceElement.DeviceElementId, representationMapper);
if (YOffsetRepresentation != null)
{
config.Offsets.Add(YOffsetRepresentation);
}
}
if (ZOffset == null)
{
ZOffset = GetZOffsetFromSpatialData(isoRecords, DeviceElement.DeviceElementId, representationMapper);
if (ZOffsetRepresentation != null)
{
config.Offsets.Add(ZOffsetRepresentation);
}
}
//Update config values as appropriate
if (this.DeviceElement.DeviceElementType == ISODeviceElementType.Navigation)
{
MachineConfiguration machineConfig = config as MachineConfiguration;
if (machineConfig.GpsReceiverXOffset == null)
{
machineConfig.GpsReceiverXOffset = XOffsetRepresentation;
}
if (machineConfig.GpsReceiverYOffset == null)
{
machineConfig.GpsReceiverYOffset = YOffsetRepresentation;
}
if (machineConfig.GpsReceiverZOffset == null)
{
machineConfig.GpsReceiverZOffset = ZOffsetRepresentation;
}
}
else
{
if (config is SectionConfiguration)
{
SectionConfiguration sectionConfig = config as SectionConfiguration;
if (sectionConfig.SectionWidth == null)
{
sectionConfig.SectionWidth = WidthRepresentation;
}
if (sectionConfig.InlineOffset == null)
{
sectionConfig.InlineOffset = XOffsetRepresentation;
}
if (sectionConfig.LateralOffset == null)
{
sectionConfig.LateralOffset = YOffsetRepresentation;
}
}
else if (config is ImplementConfiguration)
{
ImplementConfiguration implementConfig = config as ImplementConfiguration;
if (implementConfig.Width == null)
{
implementConfig.Width = WidthRepresentation;
}
}
}
}
public static void DescribeImplement(Catalog catalog, LoggedData loggedData)
{
Console.WriteLine();
Console.WriteLine("-----------------------");
Console.WriteLine("Equipment Configuration");
Console.WriteLine("-----------------------");
Console.WriteLine();
//A LoggedData will have a single EquipmentConfigurationGroup that contains any EquipmentConfigurations in the file
EquipmentConfigurationGroup equipConfigGroup = loggedData.EquipmentConfigurationGroup;
//The configuration of the equipment can vary by each region, although it is likely that the equipment configuration remains consistent across many regions
//Any distinct configurations represented in the field operation will be EquipmentConfigurations within this group
List <EquipmentConfiguration> distinctConfigurations = equipConfigGroup.EquipmentConfigurations;
Console.WriteLine($"Field operation has {distinctConfigurations.Count} distinct equipment configuration(s).");
Console.WriteLine();
//While a single OperationData object supports a list of EquipmentConfigurations, the 2020 plugin will always reference a single EquipmentConfiguration on any one OperationData.
//This allows the consumer to predictively map data based a known equipment definition for that data.
//Going deeper on the first OperationData
Console.WriteLine("The first region and OperationData within the field operation has this configuration:");
EquipmentConfiguration equipConfig = distinctConfigurations.SingleOrDefault(c => c.Id.ReferenceId == loggedData.OperationData.First().EquipmentConfigurationIds.Single());
//The equipment configuration maps to 2 connectors, explaining what machinery was hitched together
Connector connector1 = catalog.Connectors.SingleOrDefault(c => c.Id.ReferenceId == equipConfig.Connector1Id);
Connector connector2 = catalog.Connectors.SingleOrDefault(c => c.Id.ReferenceId == equipConfig.Connector2Id);
//Each connector contains two pieces of information, the DeviceElementConfiguration that connector/hitch is a part of, and metadata on a specific hitch point.
DeviceElementConfiguration deviceElementConfiguration1 = catalog.DeviceElementConfigurations.SingleOrDefault(c => c.Id.ReferenceId == connector1.DeviceElementConfigurationId);
HitchPoint hitchPoint1 = catalog.HitchPoints.SingleOrDefault(h => h.Id.ReferenceId == connector1.HitchPointId);
DeviceElementConfiguration deviceElementConfiguration2 = catalog.DeviceElementConfigurations.SingleOrDefault(c => c.Id.ReferenceId == connector2.DeviceElementConfigurationId);
HitchPoint hitchPoint2 = catalog.HitchPoints.SingleOrDefault(h => h.Id.ReferenceId == connector2.HitchPointId);
//DeviceElementConfigurations are a polymorphic object within ADAPT.
//A DeviceElementConfiguration may be of type
// MachineConfiguration (describing a tractor/vehicle)
// ImplementConfiguration (describing an entire implement)
// SectionConfiguration (describing a subsection or individual row of an implement)
//DeviceElementConfigurations are part of a 3-object hierarchy that describes a piece of equipment
//1. DeviceModel - A high-level description of the equipment: brand, manufacturer, description. Any single piece of equipment has only 1 device model.
//2. DeviceElement -A hierarchical descripion part of the equipment: brand, manufacturer, description, and type of element (section, machine, implement, etc.).
// A DeviceElement maps to a single DeviceModel, and may be a parent and/or child of other DeviceElements.
// E.g., each section is a child of the root implement DeviceElement
//3. DeviceElementConfigurations - The DeviceElementConfiguration is an extension of the DeviceElement, each mapping to a single DeviceElement,
// but having specific phyproperties such as width and offsets.
//The 2020 equipment configuration will always have a Machine/Vehicle as the Connector1 and an Implement as the Connector2.
MachineConfiguration vehicleConfiguration = deviceElementConfiguration1 as MachineConfiguration;
ImplementConfiguration implementConfiguration = deviceElementConfiguration2 as ImplementConfiguration;
HitchPoint vehicleHitch = hitchPoint1;
HitchPoint implementHitch = hitchPoint2;
//The DeviceElements expose the hierarchy between parts of the equipment
Console.WriteLine();
Console.WriteLine("Vehicle DeviceElement Hierarchy:");
DeviceElement vehicleDeviceElement = catalog.DeviceElements.SingleOrDefault(d => d.Id.ReferenceId == vehicleConfiguration.DeviceElementId);
DescribeDeviceHierarchy(catalog, vehicleDeviceElement, 0, new List <DeviceElement>());
Console.WriteLine();
Console.WriteLine("Implement DeviceElement Hierarchy:");
List <DeviceElement> implementChildElements = new List <DeviceElement>();
DeviceElement implementDeviceElement = catalog.DeviceElements.SingleOrDefault(d => d.Id.ReferenceId == implementConfiguration.DeviceElementId);
DescribeDeviceHierarchy(catalog, implementDeviceElement, 0, implementChildElements);
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("-----------------------");
Console.WriteLine("Implement Width Values");
Console.WriteLine("-----------------------");
Console.WriteLine();
//The Implement and Section DeviceElementConfigurations carry width information.
Console.WriteLine($"The {implementConfiguration.Description} is {implementConfiguration.PhysicalWidth.Value.Value} {implementConfiguration.PhysicalWidth.Value.UnitOfMeasure.Code} wide.");
foreach (DeviceElement childElement in implementChildElements)
{
DeviceElementConfiguration deviceElementConfiguration = catalog.DeviceElementConfigurations.SingleOrDefault(c => c.DeviceElementId == childElement.Id.ReferenceId);
if (deviceElementConfiguration != null)
{
SectionConfiguration sectionConfiguration = deviceElementConfiguration as SectionConfiguration;
if (sectionConfiguration != null)
{
Console.WriteLine($"{sectionConfiguration.Description} is {sectionConfiguration.SectionWidth.Value.Value} {sectionConfiguration.SectionWidth.Value.UnitOfMeasure.Code} wide.");
}
}
}
Console.WriteLine();
Console.WriteLine("-----------------------");
Console.WriteLine("Equipment Offset Values");
Console.WriteLine("-----------------------");
Console.WriteLine();
//Various offset values describe where each device element is located vs. other elements via data on the device element configuration
//Vehicle GPS Receiver
DescribeOffset("GPS Receiver", vehicleConfiguration.GpsReceiverXOffset, vehicleConfiguration.GpsReceiverYOffset, "tractor reference point (center of rear axle)");
//Tractor hitch offset
DescribeOffset("vehicle hitch point", vehicleHitch.ReferencePoint.XOffset, vehicleHitch.ReferencePoint.YOffset, "tractor reference point (center of rear axle)");
//Implement hitch offset
DescribeOffset("implement hitch point", implementHitch.ReferencePoint.XOffset, implementHitch.ReferencePoint.YOffset, "implement reference point (center of implement)");
//Implmement control point offset (inverse of the prior)
DescribeOffset("implement control point offset", implementConfiguration.ControlPoint.XOffset, implementConfiguration.ControlPoint.YOffset, "tractor hitch point");
//Section offsets (measured to center of each section)
foreach (DeviceElement childElement in implementChildElements)
{
DeviceElementConfiguration deviceElementConfiguration = catalog.DeviceElementConfigurations.SingleOrDefault(c => c.DeviceElementId == childElement.Id.ReferenceId);
if (deviceElementConfiguration != null)
{
SectionConfiguration sectionConfiguration = deviceElementConfiguration as SectionConfiguration;
if (sectionConfiguration != null)
{
DescribeOffset($"{childElement.Description} offset", sectionConfiguration.InlineOffset, sectionConfiguration.LateralOffset, "tractor hitch point");
}
}
}
}
public PDBConfig(IProcDevice proc, MachineConfiguration config)
{
this.proc = proc;
this.GetGlobals(config);
// Initialize some lists for data collection
List <int> coil_bank_list = new List <int>();
List <int> lamp_source_bank_list = new List <int>();
List <PDBLampEntry> lamp_list = new List <PDBLampEntry>();
List <PDBLampListIndexEntry> lamp_list_for_index = new List <PDBLampListIndexEntry>();
this.aliases = new List <DriverAlias>();
this.indexes = new List <object>();
if (config.PRDriverAliases != null)
{
foreach (DriverAliasEntry alias in config.PRDriverAliases)
{
aliases.Add(new DriverAlias(alias.expr, alias.repl));
}
}
// Make a list of unique coil banks
foreach (CoilConfigFileEntry coil in config.PRCoils)
{
Coil coilObj = new Coil(this, coil.Number);
if (!coil_bank_list.Contains(coilObj.bank()))
{
coil_bank_list.Add(coilObj.bank());
}
}
// Make a list of lamp source banks. The P-ROC only supports 2
foreach (LampConfigFileEntry lamp in config.PRLamps)
{
Lamp lampObj = new Lamp(this, lamp.Number);
// Catalog PDB banks
// Dedicated lamps don't use PDB banks, they're direct driver pins.
if (lampObj.lamp_type == "dedicated")
{
continue;
}
else if (lampObj.lamp_type == "pdb")
{
if (!lamp_source_bank_list.Contains(lampObj.SourceBank()))
{
lamp_source_bank_list.Add(lampObj.SourceBank());
}
// Create dicts of unique sink banks. The source index is needed when
// setting up the driver groups
PDBLampEntry lamp_dict = new PDBLampEntry()
{
source_index = lamp_source_bank_list.IndexOf(lampObj.SourceBank()),
sink_bank = lampObj.SinkBank(),
source_output = lampObj.SourceOutput()
};
PDBLampListIndexEntry lamp_dict_for_index = new PDBLampListIndexEntry()
{
source_board = lampObj.SourceBoard(),
sink_bank = lampObj.SinkBank(),
source_output = lampObj.SourceOutput()
};
if (!lamp_list.Contains(lamp_dict))
{
lamp_list.Add(lamp_dict);
lamp_list_for_index.Add(lamp_dict_for_index);
}
}
}
// Create a list of indexes. The PDB banks will be mapped into this list.
// The index of the bank is used to calculate the P-ROC driver number for
// each driver.
int num_proc_banks = PinProc.kPRDriverCount / 8;
for (int i = 0; i < num_proc_banks; i++)
{
indexes.Add(99);
}
this.InitializeDrivers(proc);
// Set up dedicated driver groups (groups 0-3)
int group_ctr = 0;
for (group_ctr = 0; group_ctr < 4; group_ctr++)
{
bool enable = coil_bank_list.Contains(group_ctr);
proc.driver_update_group_config(
(byte)group_ctr,
0,
(byte)group_ctr,
0,
0,
false,
true,
enable,
true
);
}
group_ctr++;
// Process lamps first. The P-ROC can only control so many drivers directly.
// Since software won't have the speed to control lamp matrixes, map the lamps
// first. If there aren't enough P-ROC driver groups for coils, the overflow
// coils can be controlled by software via VirtualDrivers (which should get set up
// automagically here)
for (int i = 0; i < lamp_list.Count; i++)
{
PDBLampEntry lamp_dict = lamp_list[i];
if (group_ctr >= num_proc_banks || lamp_dict.sink_bank >= 16)
{
Console.WriteLine("Lamp matrix banks can't be mapped to index {0} because thats outside of the banks that P-ROC can control.", lamp_dict.sink_bank);
}
else
{
Console.WriteLine("Driver group {0}: slow_time={1} enable_index={2} row_activate_index={3} row_enable_index={4} matrix={5}", group_ctr, lamp_matrix_strobe_time, lamp_dict.sink_bank, lamp_dict.source_output, lamp_dict.source_index);
this.indexes[group_ctr] = lamp_list_for_index[i];
proc.driver_update_group_config((byte)group_ctr,
(byte)lamp_matrix_strobe_time,
(byte)lamp_dict.sink_bank,
(byte)lamp_dict.source_output,
(byte)lamp_dict.source_index,
true,
true,
true,
true);
group_ctr++;
}
}
for (int i = 0; i < coil_bank_list.Count; i++)
{
// If the bank is 16 or higher, the P-ROC can't control it directly. Software
// will have to do the driver logic and write any changes to the PDB bus.
// Therefore, map these banks to indexes above the P-ROC's driver count,
// which will force the drivers to be created as VirtualDrivers.
// Appending the bank avoids conflicts when the group counter (group_ctr) gets too high.
if (group_ctr >= num_proc_banks || coil_bank_list[i] >= 16)
{
Console.WriteLine("Driver group {0} mapped to driver index outside of P-ROC control. These drivers will become VirtualDrivers. Note, the index will not match the board/bank number; so software will need to request those values before updating the drivers.", coil_bank_list[i]);
indexes.Add(coil_bank_list[i]);
}
else
{
Console.WriteLine("Driver group {0}: slow_time={1} Enable Index={2}", group_ctr, 0, coil_bank_list[i]);
indexes[group_ctr] = coil_bank_list[i];
proc.driver_update_group_config((byte)group_ctr,
0,
(byte)coil_bank_list[i],
0,
0,
false,
true,
true,
true);
group_ctr++;
}
}
for (int i = group_ctr; i < 26; i++)
{
Console.WriteLine("Driver group {0} disabled", i);
proc.driver_update_group_config((byte)i,
lamp_matrix_strobe_time,
0,
0,
0,
false,
true,
false,
true);
}
// Make sure there are two indexes. If not, fill them in
while (lamp_source_bank_list.Count < 2)
{
lamp_source_bank_list.Add(0);
}
// Now set up globals. First disable them to allow the P-ROC to set up the
// polarities on the drivers, then enable them.
ConfigureGlobals(proc, lamp_source_bank_list, false);
ConfigureGlobals(proc, lamp_source_bank_list, true);
}
