public void TestCreateInvalidUpper()
{
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
Relay r = new Relay(RelayChannels);
});
}
private void OnRaycastHit(RaycastHit hit, ref List <Vector3> points, ref List <Relay> relays)
{
points.Add(hit.point);
Tower tower = hit.transform.GetComponent <Tower>();
if (tower != null)
{
tower.Win();
return;
}
PlayerController player = hit.transform.GetComponent <PlayerController>();
if (player != null)
{
player.Kill();
return;
}
Relay relayHit = hit.transform.GetComponent <Relay>();
if (relayHit != null)
{
if (!relays.Contains(relayHit) && !relayHit.SpawnSignal)
{
relays.Add(relayHit);
DoRaycastsRecursive(relayHit.SignalSpawnPoint, ref points, ref relays);
}
}
}
public void TestCreateInvalidLower()
{
Assert.Throws <ArgumentOutOfRangeException>(() =>
{
Relay r = new Relay(-1);
});
}
public IColumnSyntax SubQuery(ICloseSyntax <IConditionValueSyntax> subquery)
{
var begin = new BeginSubquerySyntax(this);
Relay.AddRange((subquery as SyntaxBase).Relay);
return(new EndSubquerySyntax(begin));
}
private void UpdateStateObjects(Relay relay, bool state)
{
if (relay == Relay.All)
{
int i = 0;
foreach (var item in Enum.GetValues(typeof(Relay)))
{
if (++i > PackageHost.GetSettingValue <int>("RelayCount") || item == (object)Relay.All)
{
break;
}
else
{
var relayAttribute = typeof(Relay).GetMember(item.ToString())[0].GetCustomAttribute <RelayAttribute>();
PackageHost.PushStateObject(item.ToString(), state,
metadatas: new System.Collections.Generic.Dictionary <string, object>()
{
["Id"] = relayAttribute.Number,
["Flag"] = relayAttribute.Code.ToString()
});
}
}
}
else
{
var relayAttribute = typeof(Relay).GetMember(relay.ToString())[0].GetCustomAttribute <RelayAttribute>();
PackageHost.PushStateObject(relay.ToString(), state,
metadatas: new System.Collections.Generic.Dictionary <string, object>()
{
["Id"] = relayAttribute.Number,
["Flag"] = relayAttribute.Code.ToString()
});
}
}
/// <summary>
/// Constructor for RelayItem
/// </summary>
/// <param name="channel">The channel number on the roboRIO</param>
/// <param name="commonName">Common Name the RelayItem will have</param>
/// <param name="_default">Default position for when the robot is initialized</param>
public RelayItem(int channel, string commonName, Relay.Value _default = Relay.Value.Off)
{
relay = new Relay(channel);
Name = commonName;
Default = _default;
relay.Set(_default);
}
// FormatItem: convert the individual Relay to a string
// representing the 'items' property of the Collection+JSON response
public string FormatItem(Relay rly, string rlyUrl)
{
JArray items = new JArray();
JObject item = new JObject();
item["href"] = rlyUrl;
JObject ID = new JObject();
ID["name"] = "ID";
ID["value"] = rly.ID;
JObject State = new JObject();
State["name"] = "State";
State["value"] = (rly.State) ? "Closed" : "Open";
JArray data = new JArray();
data.Add(ID);
data.Add(State);
item["data"] = data;
items.Add(item);
return(JsonConvert.SerializeObject(items));
}
public override void Execute(Relay server, Client client, Session session, Message message)
{
var body = JSON.Parse(message.body);
ushort remoteBeat = Convert.ToUInt16(body["beat"].AsInt);
client.lastHeartBeat = ((int)new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds()) % int.MaxValue;
client.clockBeat = remoteBeat;
client.AddSumAtBeat(body["sum"]);
// Below are Synchron operations - only valid when in a session
if (session == null)
{
return;
}
// Pausing client if too advanced
if (remoteBeat > session.lowestClock + Config.MAXIMUM_BEAT_DIFFERENCE && !client.IsPaused())
{
logger.Debug("Paused client from session " + session + " because too advanced (" + remoteBeat + " > " + session.lowestClock + ")");
client.Pause();
}
// Checking if we can resume clients now that the others have caught back
foreach (var cl in session.GetClients())
{
if (cl.IsPaused() && cl.clockBeat < session.lowestClock + Config.MAXIMUM_BEAT_DIFFERENCE)
{
logger.Debug("Resumed client from session " + session + "(" + cl.clockBeat + " ~ " + session.lowestClock + ")");
cl.Unpause();
}
}
}
public void CanReadWriteOneChannel([Range(1, 8)] int channel)
{
var en = new RelaysEnumerator();
var relaysInfo = en.CollectInfo();
var relayInfo = relaysInfo.First();
var relay = new Relay(relayInfo);
if (relay.ChannelsCount < channel)
{
return;
}
if (relay.Open())
{
relay.WriteChannel(channel, false);
var state = relay.ReadChannel(channel);
Assert.That(state, Is.False);
relay.WriteChannel(channel, true);
state = relay.ReadChannel(channel);
Assert.That(state, Is.True);
relay.WriteChannel(channel, false);
state = relay.ReadChannel(channel);
Assert.That(state, Is.False);
relay.Close();
}
}
static void PopulateRelay(Relay <int, float, string> rly)
{
for (int i = 0; i < DELEGATES; ++i)
{
rly.AddListener(allDelegates[i], true);
}
}
public void CanWriteAllChannels()
{
var en = new RelaysEnumerator();
var relaysInfo = en.CollectInfo();
var relayInfo = relaysInfo.First();
var relay = new Relay(relayInfo);
var mask = 0;
for (var i = relay.ChannelsCount - 1; i >= 0; i--)
{
mask |= 1 << i;
}
if (relay.Open())
{
relay.WriteChannels(false);
var status = relay.ReadChannels();
Assert.That(status & mask, Is.EqualTo(0));
relay.WriteChannels(true);
status = relay.ReadChannels();
Assert.That(status & mask, Is.EqualTo(mask));
relay.WriteChannels(false);
status = relay.ReadChannels();
Assert.That(status & mask, Is.EqualTo(0));
relay.Close();
}
}
public static void Main()
{
var config = new SPI.Configuration(SPI_mod: SPI_Devices.SPI1,
ChipSelect_Port: Pins.GPIO_PIN_D8,
ChipSelect_ActiveState: false,
ChipSelect_SetupTime: 0,
ChipSelect_HoldTime: 0,
Clock_IdleState: true,
Clock_Edge: true,
Clock_RateKHz: 10);
var shiftRegister = new x74595(8, config);
DigitalOutputPort relayPort = shiftRegister.CreateOutputPort(0, false);
var relay = new Relay(relayPort);
while (true)
{
// toggle the relay
relay.Toggle();
Debug.Print("Relay on: " + relay.IsOn.ToString());
// wait for 5 seconds
Thread.Sleep(1000);
}
}
public override void Execute(Relay server, Client client, Session session, Message message)
{
if (session != null)
{
throw new Relay.UnexpectedSessionException();
}
uint id = server.CreateSession(client);
var newJSON = new JSONObject();
newJSON.Add("session", client.session.id);
newJSON.Add("beat", client.session.GetLowestClock());
using (var stream = client.tcp.NewStream())
{
var msg = new Message()
{
controller = (byte)KingdomsSharedCode.Networking.Controller.SESSION_INFO,
body = newJSON.ToString()
};
logger.Trace(">> " + msg);
stream.Write(msg);
}
logger.Trace("Client " + client + " is now in session " + client.session);
}
public void TestCreateInvalidUpper()
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
Relay r = new Relay(RelayChannels);
});
}
public void TestCreateInvalidLower()
{
Assert.Throws<ArgumentOutOfRangeException>(() =>
{
Relay r = new Relay(-1);
});
}
public void InvertRelayWithContactInput()
{
PowerSupplier power1 = new PowerSupplier();
PowerSupplier power2 = new PowerSupplier();
IndicatorLight light = new IndicatorLight();
Relay relay = new Relay(invert: true);
relay.Input.ConnectTo(power1.Output);
relay.InputOfContact.ConnectTo(power2.Output);
relay.Output.ConnectTo(light.Input);
Assert.IsFalse(light.Lighting);
power1.On();
power2.Off();
Assert.IsFalse(light.Lighting);
power1.On();
power2.On();
Assert.IsFalse(light.Lighting);
power1.Off();
power2.On();
Assert.IsTrue(light.Lighting);
power1.Off();
power2.Off();
Assert.IsFalse(light.Lighting);
}
public async Task ClearRelay(ITextChannel Channel)
{
Relay FindRelay = RelayDB.Relays.Find(Channel.Id);
if (FindRelay == null)
{
await BuildEmbed(EmojiEnum.Annoyed)
.WithTitle($"Relay already exists!")
.WithDescription($"The relay to the channel {Channel} does not exist and thus can not be removed!")
.SendEmbed(Context.Channel);
return;
}
await SendForAdminApproval(RemoveRelayCallback,
new Dictionary <string, string>() {
{ "ChannelID", Channel.Id.ToString() }
},
Context.User.Id,
$"{Context.User.GetUserInformation()} has suggested that `{FindRelay.Message}` should be removed from the channel {Channel} which has an interval of {FindRelay.MessageInterval} messages.");
await BuildEmbed(EmojiEnum.Love)
.WithTitle($"The relay to `#{Channel}` with the message `{(FindRelay.Message.Length > 100 ? $"{FindRelay.Message.Substring(0, 100)}..." : FindRelay.Message)}` for every {FindRelay.MessageInterval} messages has been suggested for removal!")
.WithDescription($"Once it has passed admin approval, it will be removed from the database.")
.SendEmbed(Context.Channel);
}
private object pulse(Relay relay)
{
relay.Close();
Thread.Sleep(100);
relay.Open();
return(relay);
}
// GET: Relays/Create
public ActionResult Create(Guid id)
{
Relay relay = new Relay();
relay.DeviceID = id;
return(View(relay));
}
public IColumnSyntax SubQuery(IOrderBySyntax subquery)
{
var begin = new BeginSubquerySyntax(this);
Relay.AddRange((subquery as SyntaxBase).Relay);
return(new EndSubquerySyntax(begin));
}
private static void TestRelay()
{
Relay relay = new Relay(_goPiGo3, GrovePort.Grove1);
Console.WriteLine($"Test {relay.SensorName} on port {relay.Port}, will change the state of the relay from on to off, reverse the polarity, turn on and off, reverse the polarity and turn on an off again.");
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
// 2 is different than 0, so it should swith it to "on"
Thread.Sleep(2000);
relay.Value = 2;
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
Thread.Sleep(2000);
relay.Value = 0;
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
Thread.Sleep(2000);
relay.IsInverted = true;
relay.Value = 0;
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
Thread.Sleep(2000);
relay.Value = 2;
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
Thread.Sleep(2000);
relay.IsInverted = false;
relay.On();
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
Thread.Sleep(2000);
relay.Off();
Console.WriteLine($"{relay.SensorName}, Value: {relay.Value}, state: {relay} IsInverted: {relay.IsInverted}");
Thread.Sleep(2000);
}
internal List <SyntaxBase> PassRelay()
{
var relay = Relay.ToList();
relay.Add(this);
return(relay);
}
public static void Rem()
{
sw.Stop();
sw.Reset();
System.Action <int, float, string> multicast;
List <System.Action <int, float, string> > list = new List <System.Action <int, float, string> >();
Relay <int, float, string> rly = new Relay <int, float, string>();
#region RELAY REMOVE
for (int i = 0; i < LOOPS; ++i)
{
PopulateRelay(rly);
for (int j = 0; j < DELEGATES; ++j)
{
var d = allDelegates[j];
sw.Start();
rly.RemoveListener(d);
sw.Stop();
}
}
LogStopwatch("Remove Relay", "ns", 1e6);
sw.Reset();
#endregion
#region MULTICAST REMOVE
for (int i = 0; i < LOOPS; ++i)
{
multicast = delegate {};
PopulateMulticast(ref multicast);
for (int j = 0; j < DELEGATES; ++j)
{
var d = allDelegates[j];
sw.Start();
multicast -= d;
sw.Stop();
}
}
LogStopwatch("Remove Multicast", "ns", 1e6);
sw.Reset();
#endregion
#region LIST REMOVE
for (int i = 0; i < LOOPS; ++i)
{
PopulateList(list);
for (int j = 0; j < DELEGATES; ++j)
{
var d = allDelegates[j];
sw.Start();
list.Remove(d);
sw.Stop();
}
}
LogStopwatch("Remove List", "ns", 1e6);
sw.Reset();
#endregion
PrintLogs();
}
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='relay'>
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Relay> PostRelayAsync(this IRelays operations, Relay relay, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.PostRelayWithHttpMessagesAsync(relay, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
public ILiveMovie(CrestronControlSystem system)
{
this.controlSystem = system;
this.comLight = new ILiveComPort(this.controlSystem.ComPorts[1]);
this.comLight.Register();
this.comProjector = new ILiveComPort(this.controlSystem.ComPorts[2]);
this.comProjector.Register();
this.relayPower = this.controlSystem.RelayPorts[1];
this.relayGolf = this.controlSystem.RelayPorts[2];
this.irTV = this.controlSystem.IROutputPorts[1];
this.irAV = this.controlSystem.IROutputPorts[2];
this.irBlueray = this.controlSystem.IROutputPorts[3];
this.irTV.LoadIRDriver("");
isin6 = new ILiveIsinRelay(comLight);
this.tpc5 = new ILiveTPC5(comLight);
// port = new UDPClient("192.168.188.22", 6004, 8004);
// port.NetDataReceived += new NetDataReceivedEventHandler(port_NetDataReceived);
// port.Connect();
// bigvivitek = new ILiveVivitek(port);
}
public override void Handle()
{
// check CTS amount
if (relay.finishedCTSs.Count == 0)
{
sim.eventQueue.Add(new RegionProgressEvent()
{
time = sim.clock,
relay = relay,
sim = sim,
previous = this
});
}
else
{
// if any have failed send COL or go to next region
if (relay.finishedCTSs.Any(t => t.failed))
{
if (relay.COL_count < sim.protocolParameters.n_max_coll)
{
relay.COL_count++;
sim.eventQueue.Add(new StartCOLEvent()
{
time = sim.clock,
relay = relay,
sim = sim,
previous = this
});
}
else
{
sim.eventQueue.Add(new RegionProgressEvent()
{
time = sim.clock,
relay = relay,
sim = sim,
previous = this
});
}
}
// else choose relay and send packet
else
{
Relay chosen = relay.finishedCTSs.First().source;
sim.eventQueue.Add(new StartPKTEvent()
{
time = sim.clock,
relay = relay,
actualDestination = chosen,
sim = sim,
previous = this
});
}
}
// clear finished
relay.finishedCTSs.Clear();
}
protected SyntaxBase(SyntaxBase syntaxBase)
{
Relay = syntaxBase.Relay.ToList();
Relay.Add(syntaxBase);
Parameters = syntaxBase.Parameters;
LocalParameters = new List <string>();
ParameterCount = syntaxBase.ParameterCount;
}
public MeadowApp()
{
Console.WriteLine("Initializing...");
relay = new Relay(Device.CreateDigitalOutputPort(Device.Pins.D02));
TestRelay();
}
public ActionResult DeleteConfirmed(Guid id)
{
Relay relay = db.Relays.Find(id);
db.Relays.Remove(relay);
db.SaveChanges();
return(RedirectToAction("Details", "Devices", new { id = relay.DeviceID }));
}
public Neuron(int idInput, Relay relayInput)
{
id = idInput;
connectedSynapses = new List <Synapse>();
relay = relayInput;
name = assignName(id, relay);
value = 0;
}
public ActionResult DeleteConfirmed(string id)
{
Relay relay = db.Relays.Find(id);
db.Relays.Remove(relay);
db.SaveChanges();
return(RedirectToAction("Index"));
}
//====== EVOLVE NET HELPER FUNCTIONS ====== //
public void addNeuron(Relay relayInput)
{
// addNeuron ----- adds a neuron to the appropriate neuron sublist.
int newNeuronID = neurons[0].Count + neurons[1].Count + neurons[2].Count;
Neuron neuron = new Neuron(newNeuronID, relayInput);
assignNeuronToList(neuron, relayInput);
}
public void TestOn()
{
Relay relay = new Relay(0, Relay.Direction.Both);
relay.Set(Relay.Value.On);
Assert.AreEqual(true, SimData.Relay[0].Forward);
Assert.AreEqual(true, SimData.Relay[0].Reverse);
relay.Dispose();
}
private void Initialize()
{
lock (this)
{
if (!initialized)
{
relay = GiveRelay();
inputOne = GiveInputOne();
inputTwo = GiveInputTwo();
initialized = true;
}
}
}
public void TestCreateAll()
{
List<Relay> relays = new List<Relay>();
for (int i = 0; i < RelayChannels; i++)
{
Relay r = new Relay(i);
relays.Add(r);
}
foreach (var relay in relays)
{
relay.Dispose();
}
}
public PhysicalHellevator()
{
CallButton = new Button(FEZ_Pin.Digital.Di43);
PanelButton = new Button(FEZ_Pin.Digital.Di41);
ModeButton = new Button(FEZ_Pin.Digital.Di21);
PatriotLight = new RelayPatriotLight(FEZ_Pin.Digital.Di52, FEZ_Pin.Digital.Di50, FEZ_Pin.Digital.Di48);
Fan = new Relay(FEZ_Pin.Digital.Di46);
RopeLight = new Relay(FEZ_Pin.Digital.Di28);
DriveWheel = new Relay(FEZ_Pin.Digital.Di26);
SmokeMachine = new Relay(FEZ_Pin.Digital.Di24);
ElevatorEffects = new SerialLedRope("COM2", 29);
CeilingEffects = new SerialLedRope("COM4", 60);
FloorIndicator = new SpiFloorIndicator(SPI.SPI_module.SPI2, FEZ_Pin.Digital.Di34);
InteriorZone = new SerialAudioZone(audioCoordinator, 1, FEZ_Pin.Digital.Di5);
ExteriorZone = new SerialAudioZone(audioCoordinator, 2, FEZ_Pin.Digital.Di10);
CarriageDoor = new Door();
lcd.Initialize();
}
public void TestForward()
{
Relay relay = new Relay(0, Relay.Direction.Reverse);
Assert.Throws<InvalidValueException>(() =>
{
relay.Set(Relay.Value.Forward);
});
relay.Dispose();
}
public static bool Load()
{
XmlSerializer deserializer = new XmlSerializer(typeof(HeatingData));
TextReader reader = new StreamReader(@"C:\Temp\HeatingData.xml");
Logger.Log(Logger.LOGLEVEL_INFO, "About to load init data");
object obj = deserializer.Deserialize(reader);
theData = (HeatingData)obj;
reader.Close();
Logger.Log(Logger.LOGLEVEL_INFO, "Init data loaded");
// Deserializer looses references - creates new objects so clear down and rebuild
for (int i = 0; i < Rooms.Count; i++)
{
Rooms[i].Heaters.Clear();
Rooms[i].Sensors.Clear();
}
for (int i = 0; i < FloorHeats.Count; i++)
{
FloorHeats[i].Sensors.Clear();
}
for (int i = 0; i < TowelRads.Count; i++)
{
TowelRads[i].Sensors.Clear();
}
// Add heaters to rooms
for (int i = 0; i < FloorHeats.Count; i++)
{
for (int j = 0; j < Rooms.Count; j++)
{
if (Rooms[j].Id == FloorHeats[i].RoomId)
{
Rooms[j].Heaters.Add(FloorHeats[i]);
break;
}
}
}
for (int i = 0; i < TowelRads.Count; i++)
{
for (int j = 0; j < Rooms.Count; j++)
{
if (Rooms[j].Id == TowelRads[i].RoomId)
{
Rooms[j].Heaters.Add(TowelRads[i]);
break;
}
}
}
// Add sensors to rooms and heaters
for (int i = 0; i < RoomSensors.Count; i++)
{
for (int j = 0; j < Rooms.Count; j++)
{
if (Rooms[j].Id == RoomSensors[i].RoomId)
{
Rooms[j].Sensors.Add(RoomSensors[i]);
for (int k = 0; k < Rooms[j].Heaters.Count; k++)
{
Rooms[j].Heaters[k].Sensors.Add(RoomSensors[i]);
}
break;
}
}
}
for (int i = 0; i < FloorSensors.Count; i++)
{
for (int j = 0; j < Rooms.Count; j++)
{
if (Rooms[j].Id == FloorSensors[i].RoomId)
{
Rooms[j].Sensors.Add(FloorSensors[i]);
for (int k = 0; k < Rooms[j].Heaters.Count; k++)
{
Rooms[j].Heaters[k].Sensors.Add(FloorSensors[i]);
}
break;
}
}
}
// Clear and then populate relay set
Relay oRelay;
theData.theRelays.Clear();
for (int i = 0; i < FloorHeats.Count; i++)
{
oRelay = new Relay(FloorHeats[i].Name, FloorHeats[i].RelayAddress);
theData.theRelays.Add(oRelay);
}
for (int i = 0; i < TowelRads.Count; i++)
{
oRelay = new Relay(TowelRads[i].Name, TowelRads[i].RelayAddress);
theData.theRelays.Add(oRelay);
}
theData.theRelays.Sort();
Logger.Log(Logger.LOGLEVEL_INFO, "Init data processed");
return true;
}
public RelayPatriotLight(FEZ_Pin.Digital redPin, FEZ_Pin.Digital whitePin, FEZ_Pin.Digital bluePin)
{
red = new Relay(redPin);
white = new Relay(whitePin);
blue = new Relay(bluePin);
}
public void TestOff()
{
Relay relay = new Relay(0, Relay.Direction.Reverse);
relay.Set(Relay.Value.Off);
Assert.AreEqual(false, SimData.Relay[0].Forward);
Assert.AreEqual(false, SimData.Relay[0].Reverse);
relay.Dispose();
}
