public DrawableCircuitSwitch(Vector2 position, bool offsetMiddle) : base(position, "", 0, 1)
{
Value = LogicValue.LOW;
Size = new Vector2(25, 30);
Text = "0";
CalculateOffsets(offsetMiddle);
}
public XnorArchitectures()
: base(_entityId)
{
AddArchitecture(EntityId.DerivePrefix("Logic"),
LogicValueCategory.IsLogicValueMember,
delegate(Port port) { return(new ProcessBase[] { LogicValue.CreateXnorProcess(0, port.InputSignalCount - 1, 0) }); });
}
public Sr501PirMotionDetector(int pinNumber, LogicValue logicValue = LogicValue.Positive) : base(pinNumber, GpioPinDriveMode.Input, logicValue)
{
lastPinValue = ActualLowPinValue;
Pin.DebounceTimeout = TimeSpan.FromMilliseconds(20);
Pin.ValueChanged += Pin_ValueChanged;
}
/***************************************************************************/
public static void elementWithCoverage(
ILogicalElement _element
, LogicValue.Enum _significantValue
, LogicValue.Enum _valueToSet
)
{
ILineCollection inputs = _element.Inputs;
ILineCollection outputs = _element.Outputs;
if (inputs.hasUnknownStates())
{
outputs[0].Value = LogicValue.Enum.Unknown;
return;
}
if (inputs.hasValue(_significantValue))
{
outputs[0].Value = _valueToSet;
return;
}
if (!inputs.hasValue(LogicValue.Enum.DontCare))
{
outputs[0].Value = LogicValue.invert(_valueToSet);
}
else
{
outputs[0].Value = LogicValue.Enum.DontCare;
}
}
public NotArchitectures()
: base(_entityId)
{
AddArchitecture(EntityId.DerivePrefix("Logic"),
LogicValueCategory.IsLogicValueMember,
delegate(Port port) { return(new Process[] { LogicValue.CreateNotProcess(0, 0, port.InputSignalCount, false, false) }); });
}
public RotaryEncoder(int dataPinNumber, int clockPinNumber, LogicValue logicValue = LogicValue.Positive)
{
dataPin = new GpioModule(Controller, dataPinNumber, GpioPinDriveMode.Input, logicValue);
clockPin = new GpioModule(Controller, clockPinNumber, GpioPinDriveMode.Input, logicValue);
dataPin.Pin.ValueChanged += Pin_ValueChanged;
clockPin.Pin.ValueChanged += Pin_ValueChanged;
}
public void Update(Simulator sim, Vector2 mousePosInWorld)
{
if (Raylib.IsMouseButtonPressed(MouseButton.MOUSE_RIGHT_BUTTON))
{
if (Raylib.CheckCollisionPointRec(mousePosInWorld, Box))
{
Value = Value == LogicValue.HIGH ? LogicValue.LOW : LogicValue.HIGH;
}
}
}
// Logic stuff
public static LogicValue[] GetLogicValues(List <CircuitInput> lst)
{
LogicValue[] arr = new LogicValue[lst.Count];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = lst[i].Value;
}
return(arr);
}
public LogicValue GetOutput(LogicValue[] inputs)
{
LogicValue a = inputs[0];
LogicValue b = inputs[1];
if (a == LogicValue.HIGH || b == LogicValue.HIGH)
{
return(LogicValue.LOW);
}
else
{
return(LogicValue.HIGH);
}
}
public static Logic operator !(Logic l)
{
LogicValue[] not_table =
{
//U 0 1 |
//------|--
//U 1 0 |
LogicValue.UNINITIALIZED, LogicValue.LOGIC_1, LogicValue.LOGIC_0
};
LogicValue rv = not_table[(byte)l.Value];
return(new Logic(rv));
}
private static bool?ToBool(LogicValue Value)
{
if (Value == LogicValue.Hi)
{
return(true);
}
else if (Value == LogicValue.Low)
{
return(false);
}
else
{
return(null);
}
}
public static SourceValue ToSource(LogicValue Value)
{
if (Value == LogicValue.Hi)
{
return(SourceValue.Hi);
}
else if (Value == LogicValue.Low)
{
return(SourceValue.Low);
}
else
{
return(SourceValue.Indeterminate);
}
}
public static Logic operator ^(Logic l, Logic r)
{
LogicValue[,] xor_table =
{
//U 0 1 |
//------|--
//U U U | U
//U 0 1 | 0
//U 1 0 | 1
{ LogicValue.UNINITIALIZED, LogicValue.UNINITIALIZED, LogicValue.UNINITIALIZED },
{ LogicValue.UNINITIALIZED, LogicValue.LOGIC_0, LogicValue.LOGIC_1 },
{ LogicValue.UNINITIALIZED, LogicValue.LOGIC_1, LogicValue.LOGIC_0 }
};
LogicValue rv = xor_table[(byte)l.Value, (byte)r.Value];
return(new Logic(rv));
}
public static Logic operator &(Logic l, Logic r)
{
LogicValue[,] and_table =
{
//U 0 1 |
//------|--
//U 0 U | U
//0 0 0 | 0
//U 0 1 | 1
{ LogicValue.UNINITIALIZED, LogicValue.LOGIC_0, LogicValue.UNINITIALIZED },
{ LogicValue.LOGIC_0, LogicValue.LOGIC_0, LogicValue.LOGIC_0 },
{ LogicValue.UNINITIALIZED, LogicValue.LOGIC_0, LogicValue.LOGIC_1 }
};
LogicValue rv = and_table[(byte)l.Value, (byte)r.Value];
return(new Logic(rv));
}
public LogicValue GetOutput(LogicValue[] inputs)
{
LogicValue a = inputs[0];
LogicValue b = inputs[1];
if (a == LogicValue.NAN || b == LogicValue.NAN)
{
return(LogicValue.NAN);
}
if ((a == LogicValue.HIGH && b == LogicValue.LOW) || (a == LogicValue.LOW && b == LogicValue.HIGH))
{
return(LogicValue.LOW);
}
else
{
return(LogicValue.HIGH);
}
}
static void Main(string[] args)
{
Boolean a = true;
Boolean b = false;
Boolean c = true;
Vertex logicA = new LogicValue(a);
Vertex logicB = new LogicValue(b);
Vertex logicC = new LogicValue(c);
Vertex disjuction = new Disjunction(logicA, logicB);
Vertex consecution = new Consecution(disjuction, logicC);
Vertex equivalence = new Equivalence(consecution, logicA);
Console.WriteLine(equivalence.GetResult());
Console.ReadKey();
}
/***************************************************************************/
public int executeOnSimpleLogicSet(LogicSet _set)
{
int dontCareIndex = findValue(_set, LogicValue.Enum.DontCare);
if (dontCareIndex != -1)
{
throw new Exception();
}
int currentBinaryPow = 1;
int resultNumber = 0;
for (int i = 0; i < _set.Count; ++i)
{
int logicValueAsNumber = LogicValue.asNumber(_set[i]);
resultNumber += currentBinaryPow * logicValueAsNumber;
currentBinaryPow *= 2;
}
return(resultNumber);
}
public GpioModule(GpioController controller, int pinNumber, GpioPinDriveMode driveMode = GpioPinDriveMode.Input, LogicValue logicValue = LogicValue.Positive)
: base(controller)
{
Pin = Controller.OpenPin(pinNumber);
// Shows an error if the pin wasn't initialized properly
if (Pin == null)
throw new ArgumentException($"There were problems initializing the GPIO {GetType().Name} pin.");
if (logicValue == LogicValue.Positive)
{
ActualHighPinValue = GpioPinValue.High;
ActualLowPinValue = GpioPinValue.Low;
}
else
{
ActualHighPinValue = GpioPinValue.Low;
ActualLowPinValue = GpioPinValue.High;
}
Pin.Write(ActualLowPinValue);
Pin.SetDriveMode(driveMode);
}
public CircuitIO()
{
this.Value = LogicValue.NAN;
}
public void SetValue(LogicValue logic)
{
Outputs[0].Value = logic;
}
public InfraredTransmitter(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(pinNumber, logicValue)
{
}
public SwitchGpioModule(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: this(GpioController.GetDefault(), pinNumber, logicValue)
{ }
public Logic(LogicValue value)
{
Value = value;
}
/***************************************************************************/
public static void nxor(ILogicalElement _element)
{
xor(_element);
_element.Outputs[0].Value = LogicValue.invert(_element.Outputs[0].Value);
}
public SwitchGpioModule(GpioController controller, int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(controller, pinNumber, GpioPinDriveMode.Output, logicValue)
{ }
public MulticolorLed(int redPinNumber, int greenPinNumber, int bluePinNumber, LogicValue logicValue = LogicValue.Positive)
{
redPin = new SwitchGpioModule(Controller, redPinNumber, logicValue);
greenPin = new SwitchGpioModule(Controller, greenPinNumber, logicValue);
bluePin = new SwitchGpioModule(Controller, bluePinNumber, logicValue);
}
public Relay(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(pinNumber, logicValue)
{
}
public KnockSensor(int pinNumber, LogicValue logicValue = LogicValue.Positive) : base(pinNumber, GpioPinDriveMode.Input, logicValue)
{
lastPinValue = ActualLowPinValue;
Pin.ValueChanged += Pin_ValueChanged;
}
public ActiveBuzzer(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(pinNumber, logicValue)
{
}
/***************************************************************************/
public static void not(ILogicalElement _element)
{
_element.Outputs[0].Value = LogicValue.invert(_element.Inputs[0].Value);
}
public SwitchGpioModule(GpioController controller, int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(controller, pinNumber, GpioPinDriveMode.Output, logicValue)
{
}
public InfraredTransmitter(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(pinNumber, logicValue)
{
}
public SwitchGpioModule(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: this(GpioController.GetDefault(), pinNumber, logicValue)
{
}
public bool IsPushingLogicValue(LogicValue value)
{
return(this.PushedValues.Contains(value));
}
public GpioModule(int pinNumber, GpioPinDriveMode driveMode = GpioPinDriveMode.Input, LogicValue logicValue = LogicValue.Positive)
: this(GpioController.GetDefault(), pinNumber, driveMode, logicValue)
{
}
public bool HasLogicValue(LogicValue value)
{
return(this.Values.Contains(value));
}
public PhotoInterrupter(int pinNumber, LogicValue logicValue = LogicValue.Positive) : base(pinNumber, GpioPinDriveMode.Input, logicValue)
{
lastPinValue = ActualLowPinValue;
timer = new Timer(CheckState, null, 0, 100);
}
public ActiveBuzzer(int pinNumber, LogicValue logicValue = LogicValue.Positive)
: base(pinNumber, logicValue)
{
}
