/// <summary>
/// Reads the current voltage on the given pin.
/// </summary>
/// <param name="pin">The pin to read.</param>
/// <returns>The voltage between 0 (0V) and 1 (3.3V).</returns>
public double ReadAnalog(AnalogPin pin)
{
if (!Enum.IsDefined(typeof(AnalogPin), pin))
{
throw new ArgumentException(nameof(pin));
}
return(this.analog.Read((byte)pin));
}
/// <summary>
/// Configures a pin as an analog input with a delegate the receives a new input value at a specified interval
/// </summary>
/// <param name="pin">the analog pin (as per Teensy documentation)</param>
/// <param name="interval">the interval (in ms) to sample the input value and notify the delegate</param>
/// <param name="callback">the delegate called periodically with a new input value</param>
/// <returns>the port ID of the configured analog input</returns>
/// <remarks>
/// The notification delegate is called on a background thread.
/// </remarks>
public int ConfigureAnalogInputPin(AnalogPin pin, int interval, AnalogInputCallback callback)
{
if (interval == 0)
{
throw new WirekiteException("Analog input with periodc sampling requires interval > 0");
}
Port port = ConfigureAnalogInput(pin, interval);
_analogInputCallbacks.TryAdd(port.Id, callback);
return(port.Id);
}
private Port ConfigureAnalogInput(AnalogPin pin, int interval)
{
ConfigRequest request = new ConfigRequest
{
Action = Message.ConfigActionConfigPort,
PortType = Message.PortTypeAnalogIn,
PinConfig = (UInt16)pin,
Value1 = (UInt32)interval
};
ConfigResponse response = SendConfigRequest(request);
Port port = new Port(response.PortId, interval == 0 ? PortType.AnalogInputOnDemand : PortType.AnalogInputSampling, 10);
_ports.AddPort(port);
return(port);
}
public override void OnInspectorGUI()
{
this.serializedObject.Update();
AnalogPin analogPin = (AnalogPin)target;
EditorGUILayout.PropertyField(id, new GUIContent("ID"));
EditorGUILayout.PropertyField(maxValue, new GUIContent("Max Value"));
EditorGUILayout.LabelField("RawValue", analogPin.RawValue.ToString());
EditorGUILayout.LabelField("Value", analogPin.Value.ToString("F2"));
if (Application.isPlaying == true)
{
EditorUtility.SetDirty(target);
}
this.serializedObject.ApplyModifiedProperties();
}
bool AreAnalogPinsIdentical(AnalogPin pin1, AnalogPin pin2)
{
if (
pin1.ParentDevice == pin2.ParentDevice &&
pin1.PinID == pin2.PinID &&
pin1.BinaryMinimum == pin2.BinaryMinimum &&
pin1.BinaryMaximum == pin2.BinaryMaximum
)
{
return(true);
}
else
{
return(false);
}
}
public AdcChannel AnalogRead(AnalogPin pin)
{
int aPin = (int)pin;
if (aPin < 0 || aPin >= 4)
{
throw new ArgumentOutOfRangeException();
}
if (!IsAdcInitalised)
{
InitaliseAdcAsync().Wait();
}
if (channels[aPin] == null)
{
channels[aPin] = Adc.OpenChannel(aPin);
}
return(channels[aPin]);
}
public int analogRead(AnalogPin pin, string bundle = null)
{
return(analogRead("", (int)pin, bundle));
}
/// <summary>
/// Init a pin
/// </summary>
/// <param name="string">Target Name</param>
/// <param name="pin">Pin to init</param>
/// <param name="mode">PinMode to init pin</param>
public void InitPin(string target, AnalogPin pin, PinMode mode)
{
InitPin((int)pin, mode);
}
/// <summary>
/// Init a pin
/// </summary>
/// <param name="pin">Analog pin to initialize</param>
/// <param name="mode">PinMode to init pin</param>
public void InitPin(AnalogPin pin, PinMode mode)
{
InitPin(null, (int)pin, mode);
}
/// <summary>
/// Configure a pin as an analog input
/// </summary>
/// <remarks>
/// The analog input value can be read on demand with <see cref="ReadAnalogPin(int)"/>
/// </remarks>
/// <param name="pin">the analog pin (as per Teensy documentation)</param>
/// <returns>the port ID of the configured analog input</returns>
public int ConfigureAnalogInputPin(AnalogPin pin)
{
Port port = ConfigureAnalogInput(pin, 0);
return(port.Id);
}
/// <summary>
/// Reads the current voltage on the given pin.
/// </summary>
/// <param name="pin">The pin to read.</param>
/// <returns>The voltage between 0 (0V) and 1 (3.3V).</returns>
public double ReadAnalog(AnalogPin pin) {
if (!Enum.IsDefined(typeof(AnalogPin), pin)) throw new ArgumentException(nameof(pin));
return this.analog.Read((byte)pin);
}
public void _01_SHOULD_derive_from_AnalogPin_base_class()
{
AnalogPin baseObject = _pin as AnalogPin;
Assert.That(baseObject, Is.Not.Null);
}
public AdcChannel AnalogRead(AnalogPin pin) {
int aPin = (int)pin;
if (aPin < 0 || aPin >=4) { throw new ArgumentOutOfRangeException(); }
if (!IsAdcInitalised) { InitaliseAdcAsync().Wait(); }
if (channels[aPin] == null) { channels[aPin] = Adc.OpenChannel(aPin); }
return channels[aPin];
}
internal async Task <bool> ParseMessageAsync(BlynkConnection blynkConnection)
{
bool result = true;
try {
BlynkLogManager.LogMethodBegin(nameof(ParseMessageAsync));
BlynkLogManager.LogInformation(string.Format("Message Received command type : {0}", this.BlynkCommandType));
switch (this.BlynkCommandType)
{
case BlynkCommandType.BLYNK_CMD_RESPONSE:
blynkConnection.ResponseReceivedNotification?.Invoke(this.ResponseCode);
return(result);
case BlynkCommandType.BLYNK_CMD_PING:
return(await blynkConnection.SendResponseAsync(this.MessageId));
case BlynkCommandType.BLYNK_CMD_BRIDGE:
return(await blynkConnection.SendResponseAsync(this.MessageId));
case BlynkCommandType.BLYNK_CMD_HARDWARE: {
var hardwareCommandType = this.GetHardwareCommandType();
BlynkLogManager.LogInformation(string.Format("Hardware command type : {0}", hardwareCommandType));
switch (hardwareCommandType)
{
case HardwareCommandType.VirtualRead: {
string pinString;
this.messageBuffer.Extract(out pinString);
var pinNumber = int.Parse(pinString);
var pin = blynkConnection.VirtualPinNotification.PinReadRequest?.Invoke(pinNumber); // blynkConnection.ReadVirtualPinRequest?.Invoke( pinNumber );
if (pin == null)
{
return(await blynkConnection.SendResponseAsync(this.MessageId, BlynkResponse.NO_DATA));
}
else
{
return(await pin.SendVirtualPinWriteAsync(blynkConnection, this.MessageId, blynkConnection.CancellationToken));
}
}
case HardwareCommandType.VirtualWrite: {
string pinNumberAsString;
this.messageBuffer.Extract(out pinNumberAsString);
var pin = new VirtualPin()
{
PinNumber = int.Parse(pinNumberAsString)
};
this.messageBuffer.Extract(pin.Values);
blynkConnection.VirtualPinNotification.PinWriteNotification?.Invoke(pin);
return(await blynkConnection.SendResponseAsync(this.MessageId));
}
case HardwareCommandType.DigitalRead: {
string pinString;
this.messageBuffer.Extract(out pinString);
var pinNumber = int.Parse(pinString);
var pin = blynkConnection.DigitalPinNotification.PinReadRequest?.Invoke(pinNumber); // blynkConnection.ReadDigitalPinRequest?.Invoke( pinNumber );
if (pin == null)
{
return(await blynkConnection.SendResponseAsync(this.MessageId, BlynkResponse.NO_DATA));
}
else
{
return(await pin.SendDigitalPinWriteAsync(blynkConnection, this.MessageId, blynkConnection.CancellationToken));
}
}
case HardwareCommandType.DigitalWrite: {
string pinNumberAsString;
string valueAsString;
this.messageBuffer.Extract(out pinNumberAsString)
.Extract(out valueAsString);
var pin = new DigitalPin()
{
PinNumber = int.Parse(pinNumberAsString),
Value = int.Parse(valueAsString) == 1
};
//blynkConnection.WriteDigitalPinNotification?.Invoke( pin );
blynkConnection.DigitalPinNotification.PinWriteNotification?.Invoke(pin);
return(await blynkConnection.SendResponseAsync(this.MessageId));
}
case HardwareCommandType.AnalogRead: {
string pinString;
this.messageBuffer.Extract(out pinString);
var pinNumber = int.Parse(pinString);
var pin = blynkConnection.AnalogPinNotification.PinReadRequest?.Invoke(pinNumber); // blynkConnection.ReadAnalogPinRequest( pinNumber );
if (pin == null)
{
return(await blynkConnection.SendResponseAsync(this.MessageId, BlynkResponse.NO_DATA));
}
else
{
return(await pin.SendAnalogPinWriteAsync(blynkConnection, this.MessageId, blynkConnection.CancellationToken));
}
}
case HardwareCommandType.AnalogWrite: {
string pinNumberAsString;
string valueAsString;
this.messageBuffer.Extract(out pinNumberAsString)
.Extract(out valueAsString);
var pin = new AnalogPin()
{
PinNumber = int.Parse(pinNumberAsString),
Value = short.Parse(valueAsString)
};
//blynkConnection.WriteAnalogPinNotification?.Invoke( pin );
blynkConnection.AnalogPinNotification.PinWriteNotification?.Invoke(pin);
return(await blynkConnection.SendResponseAsync(this.MessageId));
}
case HardwareCommandType.PinMode: {
string pin;
string mode;
while (this.messageBuffer.Position < this.MessageLength)
{
this.messageBuffer.Extract(out pin)
.Extract(out mode);
PinMode pinMode = PinMode.Invalid;
switch (mode)
{
case "in":
pinMode = PinMode.Input;
break;
case "out":
pinMode = PinMode.Output;
break;
case "pu":
pinMode = PinMode.PullUp;
break;
case "pd":
pinMode = PinMode.PullDown;
break;
case "pwm":
pinMode = PinMode.Pwm;
break;
}
if (pinMode != PinMode.Invalid)
{
blynkConnection.PinModeNotification?.Invoke(pin, pinMode);
}
}
return(await blynkConnection.SendResponseAsync(this.MessageId));
}
}
break;
}
}
}
catch (Exception ex) {
BlynkLogManager.LogException("Error parsing message", ex);
}
finally {
BlynkLogManager.LogMethodEnd(nameof(ParseMessageAsync));
}
return(result);
}
public double AnalogRead(AnalogPin analogIn)
{
return(AnalogRead((uint)analogIn));
}
public void Setup()
{
_pin = new AnalogPin(1, 5, 10);
}
