public void DigitalWrite(int pin, PinValue value)
{
DigitalValue digitalValue = value == 0 ? DigitalValue.Low : DigitalValue.High;
_log.DebugFormat("DigitalWrite pin " + pin + "=" + value.ToString());
_driver.Send(new ArduinoDriver.SerialProtocol.DigitalWriteRequest((byte)pin, digitalValue));
}
/// <summary>
/// Executes the calculation.
/// </summary>
public override void Calculate()
{
// Tous les input doivent avoir le cycle courrant pour pouvoir faire le calcule.
var outputValue = new DigitalValue(false);
if (this.ParametersManager.IsAllInputParamUptodate())
{
return;
}
var realValue1 = AnalogValue.AdjustValue(this.GetParameter(INPUT1), this.Gain, this.Offset);
var realValue2 = AnalogValue.AdjustValue(this.GetParameter(INPUT2), this.Gain, this.Offset);
/*
* Règle de calcul
* Si seuil d'enclenchement (DeltaOn) ≥ seuil de déclenchement (DeltaOff), on a :
* OutputState = 1, si (valeur réelle InputValue1 - valeur réelle InputValue2) > DeltaOn
* OutputState = 0, si (valeur réelle InputValue1 - valeur réelle InputValue2) ≤ DeltaOff.
* Si seuil d'enclenchement (DeltaOn) < seuil de déclenchement (DeltaOff), on a :
* OutputState = 1, si On ≤ (valeur réelle InputValue1 - valeur réelle InputValue2) < DeltaOff.
*/
var deltaValue = realValue1 - realValue2;
var deltaOn = (AnalogValue)this.InternalParametersManager.GetParameter(PARAM_D_ON).Value;
var deltaOff = (AnalogValue)this.InternalParametersManager.GetParameter(PARAM_D_OFF).Value;
// Si seuil d'enclenchement (DeltaOn) ≥ seuil de déclenchement (DeltaOff),
if (deltaOn >= deltaOff)
{
// OutputState = 1, si (valeur réelle InputValue1 - valeur réelle InputValue2) > DeltaOn
if (deltaValue > deltaOn)
{
outputValue.Value = true;
}
// OutputState = 0, si (valeur réelle InputValue1 - valeur réelle InputValue2) ≤ DeltaOff
else if (deltaValue <= deltaOff)
{
outputValue.Value = false;
}
}
// Si seuil d'enclenchement (DeltaOn) < seuil de déclenchement (DeltaOff),
else
{
// OutputState = 1, si On ≤ (valeur réelle InputValue1 - valeur réelle InputValue2) < DeltaOff.
outputValue.Value = (deltaValue >= deltaOn && deltaValue < deltaOff);
}
this.InternalParametersManager.SetParameter(OUTPUT1, outputValue);
}
public DigitalWriteReponse(byte pinRead, DigitalValue value)
{
PinWritten = pinRead;
PinValue = value;
}
public DigitalReadResponse(byte pinRead, DigitalValue value)
{
PinRead = pinRead;
PinValue = value;
}
private static extern ResultCode GpioTriggerUnmanaged(UserGpio userGpio, uint pulseLength, DigitalValue value);
internal static extern ResultCode GpioWriteUnmanaged(SystemGpio gpio, DigitalValue value);
public DigitalWriteRequest(byte pinToWrite, DigitalValue pinValue)
: base(CommandConstants.DigitalWrite)
{
Bytes.Add(pinToWrite);
Bytes.Add((byte)pinValue);
}
public DigitalReadResponse(int pinRead, int value)
{
PinRead = (byte)pinRead;
PinValue = (byte)value == 1 ? DigitalValue.High : DigitalValue.Low;
}
public int DigitalWrite(DigitalPins pin, DigitalValue pinValue)
{
var returnValue = ExecuteFunctionReturnValue("digitalwrite", pin.ToString(), pinValue.ToString().ToUpper());
return returnValue;
}
public static void DigitalWrite(int pin, DigitalValue value)
{
DigitalWrite(pin, (int)value);
}
public static bool DigitalWrite(int pin, DigitalValue digValue)
{
return(RunDirectQuery("write/digital/" + pin + "/" + (digValue.Equals(DigitalValue.High) ? "1" : "0")));
}
public double[][] ReadPressureSensorVoltages(int numberOfAveragedSamples)
{
double[][] allSensorVoltages = new double[8][];
using (driver)
{
for (int i = 0; i < 8; i++)
{
switch (i)
{
case 0: // Sensor Column A
DigitalValue[] controlValuesA = new DigitalValue[] { DigitalValue.Low, DigitalValue.Low, DigitalValue.Low };
SelectPressureSensorColumn(driver, controlValuesA);
break;
case 1: // Sensor Column B
DigitalValue[] controlValuesB = new DigitalValue[] { DigitalValue.High, DigitalValue.Low, DigitalValue.Low };
SelectPressureSensorColumn(driver, controlValuesB);
break;
case 2: // Sensor Column C
DigitalValue[] controlValuesC = new DigitalValue[] { DigitalValue.Low, DigitalValue.High, DigitalValue.Low };
SelectPressureSensorColumn(driver, controlValuesC);
break;
case 3: // Sensor Column D
DigitalValue[] controlValuesD = new DigitalValue[] { DigitalValue.High, DigitalValue.High, DigitalValue.Low };
SelectPressureSensorColumn(driver, controlValuesD);
break;
case 4: // Sensor Column E
DigitalValue[] controlValuesE = new DigitalValue[] { DigitalValue.Low, DigitalValue.Low, DigitalValue.High };
SelectPressureSensorColumn(driver, controlValuesE);
break;
case 5: // Sensor Column F
DigitalValue[] controlValuesF = new DigitalValue[] { DigitalValue.High, DigitalValue.Low, DigitalValue.High };
SelectPressureSensorColumn(driver, controlValuesF);
break;
case 6: // Sensor Column G
DigitalValue[] controlValuesG = new DigitalValue[] { DigitalValue.Low, DigitalValue.High, DigitalValue.High };
SelectPressureSensorColumn(driver, controlValuesG);
break;
case 7: // Sensor Column H
DigitalValue[] controlValuesH = new DigitalValue[] { DigitalValue.High, DigitalValue.High, DigitalValue.High };
SelectPressureSensorColumn(driver, controlValuesH);
break;
}
Thread.Sleep(100);
double[] avgSensorVoltagesInColumn = new double[analogSensorPins.Length];
for (int j = 0; j < numberOfAveragedSamples; j++)
{
for (int row = 0; row < analogSensorPins.Length; row++)
{
int sensorVoltage = driver.Send(new AnalogReadRequest(analogSensorPins[row])).PinValue;
avgSensorVoltagesInColumn[row] = avgSensorVoltagesInColumn[row] + sensorVoltage;
if (j == (numberOfAveragedSamples - 1))
{
avgSensorVoltagesInColumn[row] = (avgSensorVoltagesInColumn[row] / numberOfAveragedSamples) * 0.0049;
}
}
Thread.Sleep(10);
}
allSensorVoltages[i] = avgSensorVoltagesInColumn;
}
}
return(allSensorVoltages);
}
private static extern ResultCode GpioSerialReadInvertUnmanaged(UserGpio userGpio, DigitalValue invert);
public bool Equals(DigitalValue other)
{
if (ReferenceEquals(null, other)) return false;
if (ReferenceEquals(this, other)) return true;
return other.Value == Value;
}
public int DigitalWrite(DigitalPins pin, DigitalValue pinValue)
{
var returnValue = ExecuteFunctionReturnValue("digitalwrite", pin.ToString(), pinValue.ToString().ToUpper());
return(returnValue);
}
private static bool? CheckEqualBase(DigitalValue value1, DigitalValue value2)
{
// If both are null, or both are same instance, return true.
if (ReferenceEquals(value1, value2))
{
return true;
}
// If one is null, but not both, return false.
if (((object)value1 == null) || ((object)value2 == null))
{
return false;
}
return null;
}
public DigitalWriteReponse(int pinRead, int value)
{
PinWritten = (byte)pinRead;
PinValue = (byte)value == 1 ? DigitalValue.High : DigitalValue.Low;
}
