internal static bool PinIsTX(BBBPin Pin)
{
switch (Pin)
{
case BBBPin.P9_24:
case BBBPin.P9_21:
case BBBPin.P9_42:
case BBBPin.P9_13: return(true);
}
return(false);
}
/// <summary> Converts a Scarlet BBBPin to a BBBCSIO GpioEnum. </summary>
public static GpioEnum PinToGPIO(BBBPin Pin)
{
if (PinInfo.ContainsKey(Pin))
{
return(PinInfo[Pin].GPIO);
}
else
{
return(GpioEnum.GPIO_NONE);
}
}
/// <summary> Returns the memory address offset for each pin. Returns 0x000 if not found or invalid input. </summary>
internal static int GetOffset(BBBPin Pin)
{
if (PinInfo.ContainsKey(Pin))
{
return(PinInfo[Pin].Offset);
}
else
{
return(0x000);
}
}
public DigitalInBBB(BBBPin Pin)
{
this.Pin = Pin;
if (BeagleBone.FastGPIO)
{
this.InputPort = new InputPortMM(IO.BeagleBone.Pin.PinToGPIO(this.Pin));
}
else
{
this.InputPort = new InputPortFS(IO.BeagleBone.Pin.PinToGPIO(this.Pin));
}
}
/// <summary> Converts a pin number to the corresponding CAN bus ID. 255 if invalid. </summary>
static internal byte PinToCANBus(BBBPin Pin)
{
switch (Pin)
{
case BBBPin.P9_19:
case BBBPin.P9_20: return(0);
case BBBPin.P9_24:
case BBBPin.P9_26: return(1);
}
return(255);
}
public DigitalOutBBB(BBBPin Pin)
{
if (!IO.BeagleBone.Pin.CheckPin(Pin, BeagleBone.Peripherals))
{
throw new ArgumentOutOfRangeException("Cannot use pin " + Enum.GetName(typeof(BBBPin), Pin) + " in current peripheral mode.");
}
this.Pin = Pin;
if (BeagleBone.FastGPIO)
{
this.OutputPort = new OutputPortMM(IO.BeagleBone.Pin.PinToGPIO(this.Pin));
}
else
{
this.OutputPort = new OutputPortFS(IO.BeagleBone.Pin.PinToGPIO(this.Pin));
}
}
/// <summary> Converts a pin number to the corresponding UART bus ID.</summary>
/// <param name="Pin"> The pin to translate. </param>
/// <returns> The corresponding UART bus ID, or 255 if the input is invalid.</returns>
internal static byte PinToUARTBus(BBBPin Pin)
{
switch (Pin)
{
case BBBPin.P9_24:
case BBBPin.P9_26: return(1);
case BBBPin.P9_21:
case BBBPin.P9_22: return(2);
case BBBPin.P9_42: return(3);
case BBBPin.P9_13:
case BBBPin.P9_11: return(4);
}
return(255);
}
public static BBBPin StringToPin(string pinName)
{
try
{
BBBPin Value = (BBBPin)Enum.Parse(typeof(BBBPin), pinName);
if (Enum.IsDefined(typeof(BBBPin), Value))
{
return(Value);
}
else
{
throw new IndexOutOfRangeException("Not a pin");
}
}
catch
{
TestMain.ErrorExit("Given BBBPin is invalid.");
return(BBBPin.NONE);
}
}
/// <summary> Determines if the given pin can be used in the system mode, or if it used by another device. </summary>
public static bool CheckPin(BBBPin Pin, SystemMode Mode)
{
if (!PinInfo.ContainsKey(Pin))
{
return(false);
}
if (Mode == SystemMode.DEFAULT)
{
return(PinInfo[Pin].Devices == 0);
} // No devices must be present.
else if (Mode == SystemMode.NO_STORAGE)
{
return((PinInfo[Pin].Devices & 0b1111_1110) == 0);
} // No devices except for eMMC must be present.
else if (Mode == SystemMode.NO_HDMI)
{
return((PinInfo[Pin].Devices & 0b1111_1101) == 0);
} // No devices except for HDMI must be present.
return(false); // Invalid system mode.
}
/// <summary> Converts a Scarlet BBBPin to a BBBCSIO A2DPinEnum. </summary>
public static A2DPortEnum PinToA2D(BBBPin Pin)
{
switch (Pin)
{
case BBBPin.P9_39: return(A2DPortEnum.AIN_0);
case BBBPin.P9_40: return(A2DPortEnum.AIN_1);
case BBBPin.P9_37: return(A2DPortEnum.AIN_2);
case BBBPin.P9_38: return(A2DPortEnum.AIN_3);
case BBBPin.P9_33: return(A2DPortEnum.AIN_4);
case BBBPin.P9_36: return(A2DPortEnum.AIN_5);
case BBBPin.P9_35: return(A2DPortEnum.AIN_6);
default: return(A2DPortEnum.AIN_NONE);
}
}
/// <summary> Prepares the analogue input for use. This can block for up to 5 seconds while the hardware and kernel are intiializing. </summary>
/// <param name="Pin"> The pin on the BeagleBone to use for analogue input. Must be one of the 7 AIN pins. </param>
/// <exception cref="TimeoutException"> If the hardware/kernel take longer than 5 seconds to initialize. </exception>
public AnalogueInBBB(BBBPin Pin)
{
this.Pin = Pin;
// The ADC input file is not always available immediately, it can take a bit for it to be available after device tree overaly application.
// Therefore, we will wait for it for up to 5 seconds, then throw an error if it is not ready at that time.
string Filename = "/sys/bus/iio/devices/iio:device0/in_voltage";
switch (this.Pin)
{
case BBBPin.P9_39: Filename += 0; break;
case BBBPin.P9_40: Filename += 1; break;
case BBBPin.P9_37: Filename += 2; break;
case BBBPin.P9_38: Filename += 3; break;
case BBBPin.P9_33: Filename += 4; break;
case BBBPin.P9_36: Filename += 5; break;
case BBBPin.P9_35: Filename += 6; break;
default: throw new Exception("Given pin is not a valid ADC pin!");
}
Filename += "_raw";
DateTime Timeout = DateTime.Now.Add(TimeSpan.FromSeconds(5));
while (!File.Exists(Filename))
{
if (DateTime.Now > Timeout)
{
Log.Output(Log.Severity.ERROR, Log.Source.HARDWAREIO, "ADC Failed to initialize.");
throw new TimeoutException("ADC failed to initialize within the timeout period.");
}
Thread.Sleep(50);
}
this.Port = new A2DPortFS(IO.BeagleBone.Pin.PinToA2D(this.Pin));
}
/// <summary> Gets the PWM output corresponding to a given pin on the BeagleBone Black. </summary>
/// <param name="Pin"> The pin to find a PWM output associated with. </param>
/// <returns> A <see cref="PWMOutputBBB"/>, or <c>null</c> if the given pin is not valid. </returns>
public static PWMOutputBBB GetFromPin(BBBPin Pin)
{
switch (Pin)
{
case BBBPin.P9_22:
case BBBPin.P9_31: return(PWMDevice0.OutputA);
case BBBPin.P9_21:
case BBBPin.P9_29: return(PWMDevice0.OutputB);
case BBBPin.P9_14:
case BBBPin.P8_36: return(PWMDevice1.OutputA);
case BBBPin.P9_16:
case BBBPin.P8_34: return(PWMDevice1.OutputB);
case BBBPin.P8_19:
case BBBPin.P8_45: return(PWMDevice2.OutputA);
case BBBPin.P8_13:
case BBBPin.P8_46: return(PWMDevice2.OutputB);
}
return(null);
}
/// <summary> Converts a pin number to the corresponding PWM device and output number. Needed as every output is connected to 2 physical pins. </summary>
/// <param name="Pin"> The pin to find the PWM ID of. </param>
/// <returns> The PWM ID corresponding to the pin, or <see cref="PWMPortEnum.PWM_NONE"/> if the given pin is invalid. </returns>
internal static PWMPortEnum PinToPWMID(BBBPin Pin)
{
switch (Pin)
{
case BBBPin.P9_22:
case BBBPin.P9_31: return(PWMPortEnum.PWM0_A);
case BBBPin.P9_21:
case BBBPin.P9_29: return(PWMPortEnum.PWM0_B);
case BBBPin.P9_14:
case BBBPin.P8_36: return(PWMPortEnum.PWM1_A);
case BBBPin.P9_16:
case BBBPin.P8_34: return(PWMPortEnum.PWM1_B);
case BBBPin.P8_19:
case BBBPin.P8_45: return(PWMPortEnum.PWM2_A);
case BBBPin.P8_13:
case BBBPin.P8_46: return(PWMPortEnum.PWM2_B);
}
return(PWMPortEnum.PWM_NONE);
}
public static void Start(string[] args)
{
if (args.Length < 3)
{
TestMain.ErrorExit("io bbb command requires functionality to test.");
}
BeagleBone.Initialize(SystemMode.DEFAULT, true);
switch (args[2].ToLower())
{
case "digin":
{
if (args.Length < 4)
{
TestMain.ErrorExit("io bbb digin command requires pin to test.");
}
BBBPin InputPin = StringToPin(args[3]);
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Testing digital input on BBB pin " + InputPin.ToString());
BBBPinManager.AddMappingGPIO(InputPin, false, ResistorState.PULL_DOWN);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_REGARDLESS);
IDigitalIn Input = new DigitalInBBB(InputPin);
while (true)
{
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Current pin state: " + (Input.GetInput() ? "HIGH" : "LOW"));
Thread.Sleep(250);
}
}
case "digout":
{
if (args.Length < 4)
{
TestMain.ErrorExit("io bbb digout command requires pin to test.");
}
BBBPin OutputPin = StringToPin(args[3]);
if (args.Length < 5)
{
TestMain.ErrorExit("io bbb digout command requires output mode (high/low/blink).");
}
if (args[4] != "high" && args[4] != "low" && args[4] != "blink")
{
TestMain.ErrorExit("Invalid digout test mode supplied.");
}
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Testing digital output on BBB pin " + OutputPin.ToString());
BBBPinManager.AddMappingGPIO(OutputPin, true, ResistorState.PULL_DOWN);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_REGARDLESS);
IDigitalOut Output = new DigitalOutBBB(OutputPin);
if (args[4] == "high")
{
Output.SetOutput(true);
}
else if (args[4] == "low")
{
Output.SetOutput(false);
}
else
{
bool Out = false;
while (true)
{
Output.SetOutput(Out);
Out = !Out;
Thread.Sleep(250);
}
}
break;
}
case "pwm":
{
if (args.Length < 4)
{
TestMain.ErrorExit("io bbb pwm command requires pin to test.");
}
BBBPin OutputPin = StringToPin(args[3]);
if (args.Length < 5)
{
TestMain.ErrorExit("io bbb pwm command requires frequency.");
}
int Frequency = int.Parse(args[4]);
if (args.Length < 6)
{
TestMain.ErrorExit("io bbb pwm command requires output mode.");
}
if (args[5] != "per" && args[5] != "sine")
{
TestMain.ErrorExit("io bbb pwm command invalid (per/sine).");
}
if (args[5] == "per" && args.Length < 7)
{
TestMain.ErrorExit("io bbb pwm per must be provided duty cycle.");
}
BBBPinManager.AddMappingPWM(OutputPin);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_REGARDLESS);
IPWMOutput Output = PWMBBB.GetFromPin(OutputPin);
Output.SetFrequency(Frequency);
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Testing PWM output on BBB pin " + OutputPin.ToString() + " at " + Frequency + "Hz.");
if (args[5] == "per")
{
Output.SetOutput(int.Parse(args[6]) / 100F);
Output.SetEnabled(true);
Thread.Sleep(15000); // Not sure if it stops outputting when the program exits.
}
else
{
int Cycle = 0;
while (true)
{
float Val = (float)((Math.Sin(Cycle * Math.PI / 180.000D) + 1) / 2);
Output.SetOutput(Val);
Thread.Sleep(50);
Cycle += 20;
}
}
break;
}
case "adc":
{
if (args.Length < 4)
{
TestMain.ErrorExit("io bbb adc command requires pin to test.");
}
BBBPin InputPin = StringToPin(args[3]);
BBBPinManager.AddMappingADC(InputPin);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_REGARDLESS);
IAnalogueIn Input = new AnalogueInBBB(InputPin);
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Testing analogue input on BBB pin " + InputPin.ToString());
while (true)
{
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "ADC Input: " + Input.GetInput() + " (Raw: " + Input.GetRawInput() + ")");
Thread.Sleep(250);
}
}
case "int":
{
if (args.Length < 4)
{
TestMain.ErrorExit("io bbb int command requires pin to test.");
}
BBBPin InputPin = StringToPin(args[3]);
if (args.Length < 5)
{
TestMain.ErrorExit("io bbb int command requires interrupt mode (rise/fall/both).");
}
if (args[4] != "rise" && args[4] != "fall" && args[4] != "both")
{
TestMain.ErrorExit("Invalid interrupt mode supplied.");
}
BBBPinManager.AddMappingGPIO(InputPin, true, ResistorState.PULL_DOWN);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_REGARDLESS);
IDigitalIn Input = new DigitalInBBB(InputPin);
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Testing interrupts on BBB pin " + InputPin.ToString());
switch (args[4])
{
case "rise": ((IInterruptSource)Input).RegisterInterruptHandler(GetInterrupt, InterruptType.RISING_EDGE); break;
case "fall": ((IInterruptSource)Input).RegisterInterruptHandler(GetInterrupt, InterruptType.FALLING_EDGE); break;
case "both": ((IInterruptSource)Input).RegisterInterruptHandler(GetInterrupt, InterruptType.ANY_EDGE); break;
}
while (true)
{
Thread.Sleep(50);
} // Program needs to be running to receive.
}
case "mtk3339":
{
BBBPinManager.AddMappingUART(BBBPin.P9_24);
BBBPinManager.AddMappingUART(BBBPin.P9_26);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_REGARDLESS);
IUARTBus UART = UARTBBB.UARTBus1;
Log.Output(Log.Severity.INFO, Log.Source.HARDWAREIO, "Press any key to stop.");
while (Console.KeyAvailable)
{
Console.ReadKey();
}
byte[] Buffer = new byte[32];
while (true)
{
Thread.Sleep(10);
if (UART.BytesAvailable() > 0)
{
int Count = UART.Read(32, Buffer);
Console.Write(System.Text.Encoding.ASCII.GetString(UtilMain.SubArray(Buffer, 0, Count)));
}
if (Console.KeyAvailable)
{
break;
}
}
break;
}
}
}
/// <summary> Gets the mux mode that needs to be used for the given pin usage. Returns 255 if invalid usage provided. </summary>
internal static byte GetModeID(BBBPin Pin, BBBPinMode Mode)
{
// Definitely not the prettiest code in the world.
// Source: http://www.ofitselfso.com/BeagleNotes/BeagleboneBlackPinMuxModes.php
switch (Pin)
{
// P8 Header
case BBBPin.P8_03:
case BBBPin.P8_04:
case BBBPin.P8_05:
case BBBPin.P8_06:
case BBBPin.P8_07:
case BBBPin.P8_08:
case BBBPin.P8_09:
case BBBPin.P8_10:
case BBBPin.P8_11:
case BBBPin.P8_12: //
case BBBPin.P8_14:
case BBBPin.P8_15:
case BBBPin.P8_16:
case BBBPin.P8_17:
case BBBPin.P8_18: //
case BBBPin.P8_20:
case BBBPin.P8_21:
case BBBPin.P8_22:
case BBBPin.P8_23:
case BBBPin.P8_24:
case BBBPin.P8_25:
case BBBPin.P8_26:
case BBBPin.P8_27:
case BBBPin.P8_28:
case BBBPin.P8_29:
case BBBPin.P8_30:
case BBBPin.P8_31:
case BBBPin.P8_32:
case BBBPin.P8_33: //
case BBBPin.P8_35: //
case BBBPin.P8_39:
case BBBPin.P8_40:
case BBBPin.P8_41:
case BBBPin.P8_42:
case BBBPin.P8_43:
case BBBPin.P8_44:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P8_13:
case BBBPin.P8_19:
if (Mode == BBBPinMode.PWM)
{
return(4);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P8_34:
case BBBPin.P8_36:
if (Mode == BBBPinMode.PWM)
{
return(2);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P8_37:
case BBBPin.P8_38:
if (Mode == BBBPinMode.UART)
{
return(4);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P8_45:
case BBBPin.P8_46:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else if (Mode == BBBPinMode.PWM)
{
return(3);
}
else
{
return(255);
}
// P9 Header
case BBBPin.P9_11:
case BBBPin.P9_13:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else if (Mode == BBBPinMode.UART)
{
return(6);
}
else
{
return(255);
}
case BBBPin.P9_12:
case BBBPin.P9_15:
case BBBPin.P9_23:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_14:
case BBBPin.P9_16:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else if (Mode == BBBPinMode.PWM)
{
return(6);
}
else
{
return(255);
}
case BBBPin.P9_17:
case BBBPin.P9_18:
if (Mode == BBBPinMode.SPI)
{
return(0);
}
else if (Mode == BBBPinMode.I2C)
{
return(2);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_19:
case BBBPin.P9_20:
if (Mode == BBBPinMode.I2C)
{
return(3);
}
if (Mode == BBBPinMode.SPI)
{
return(4);
}
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_21:
case BBBPin.P9_22:
if (Mode == BBBPinMode.SPI)
{
return(0);
}
else if (Mode == BBBPinMode.UART)
{
return(1);
}
else if (Mode == BBBPinMode.I2C)
{
return(2);
}
else if (Mode == BBBPinMode.PWM)
{
return(3);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_24:
case BBBPin.P9_26:
if (Mode == BBBPinMode.UART)
{
return(0);
}
else if (Mode == BBBPinMode.I2C)
{
return(3);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_25:
case BBBPin.P9_27:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_29:
case BBBPin.P9_31:
if (Mode == BBBPinMode.SPI)
{
return(3);
}
else if (Mode == BBBPinMode.PWM)
{
return(1);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_28:
case BBBPin.P9_30:
if (Mode == BBBPinMode.SPI)
{
return(3);
}
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_33:
case BBBPin.P9_35:
case BBBPin.P9_36:
case BBBPin.P9_37:
case BBBPin.P9_38:
case BBBPin.P9_39:
case BBBPin.P9_40:
if (Mode == BBBPinMode.ADC)
{
return(0);
}
else
{
return(255);
}
case BBBPin.P9_41:
if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
case BBBPin.P9_42:
if (Mode == BBBPinMode.SPI)
{
return(4);
}
else if (Mode == BBBPinMode.UART)
{
return(1);
} // TODO: Not sure if this works.
else if (Mode == BBBPinMode.GPIO)
{
return(7);
}
else
{
return(255);
}
}
return(255);
}
public static void Start(string[] args)
{
if (args.Length < 2)
{
TestMain.ErrorExit("Device testing needs device to test.");
}
switch (args[1].ToLower())
{
case "hx711":
{
if (args.Length < 5)
{
TestMain.ErrorExit("Insufficient info to run HX711 test. See help.");
}
IDigitalIn DataPin = null;
IDigitalOut ClockPin = null;
if (args[2].Equals("pi", StringComparison.InvariantCultureIgnoreCase))
{
RaspberryPi.Initialize();
DataPin = new DigitalInPi(int.Parse(args[3]));
ClockPin = new DigitalOutPi(int.Parse(args[4]));
}
else if (args[2].Equals("bbb", StringComparison.InvariantCultureIgnoreCase))
{
BeagleBone.Initialize(SystemMode.DEFAULT, true);
BBBPin DataBBBPin = IOBBB.StringToPin(args[3]);
BBBPin ClockBBBPin = IOBBB.StringToPin(args[4]);
BBBPinManager.AddMappingGPIO(DataBBBPin, false, ResistorState.NONE);
BBBPinManager.AddMappingGPIO(ClockBBBPin, true, ResistorState.NONE);
BBBPinManager.ApplyPinSettings(BBBPinManager.ApplicationMode.APPLY_IF_NONE);
DataPin = new DigitalInBBB(DataBBBPin);
ClockPin = new DigitalOutBBB(ClockBBBPin);
}
else
{
TestMain.ErrorExit("HX711 test: Unknown platform. See help.");
}
HX711 DUT = new HX711(ClockPin, DataPin);
while (Console.KeyAvailable)
{
Console.ReadKey();
}
Log.Output(Log.Severity.INFO, Log.Source.GUI, "[w] to increase gain, [s] to decrease. [z] to zero.");
Log.Output(Log.Severity.INFO, Log.Source.GUI, "Press any other key to exit.");
HX711.Gain Gain = HX711.Gain.GAIN_128x;
bool Continue = true;
while (Continue)
{
if (Console.KeyAvailable)
{
char Key = Console.ReadKey().KeyChar;
switch (Key)
{
case 'w':
{
if (Gain == HX711.Gain.GAIN_32x)
{
Gain = HX711.Gain.GAIN_64x;
}
else if (Gain == HX711.Gain.GAIN_64x)
{
Gain = HX711.Gain.GAIN_128x;
}
else
{
Log.Output(Log.Severity.ERROR, Log.Source.SENSORS, "Gain at maximum already.");
}
DUT.SetGain(Gain);
Log.Output(Log.Severity.INFO, Log.Source.SENSORS, "Gain now at " + Gain);
break;
}
case 's':
{
if (Gain == HX711.Gain.GAIN_128x)
{
Gain = HX711.Gain.GAIN_64x;
}
else if (Gain == HX711.Gain.GAIN_64x)
{
Gain = HX711.Gain.GAIN_32x;
}
else
{
Log.Output(Log.Severity.ERROR, Log.Source.SENSORS, "Gain at minimum already.");
}
DUT.SetGain(Gain);
Log.Output(Log.Severity.INFO, Log.Source.SENSORS, "Gain now at " + Gain);
break;
}
case 'z':
{
DUT.Tare();
Log.Output(Log.Severity.INFO, Log.Source.SENSORS, "Tared.");
break;
}
default:
{
Continue = false;
break;
}
}
}
DUT.UpdateState();
Log.Output(Log.Severity.INFO, Log.Source.SENSORS, "HX711 readings: Raw: " + DUT.GetRawReading() + ", Adjusted: " + DUT.GetAdjustedReading());
Thread.Sleep(250);
}
break;
}
default:
{
TestMain.ErrorExit("Unknown device.");
break;
}
}
}
