public static int Sizeof(SharerType type)
{
switch (type)
{
case SharerType.@bool:
case SharerType.@byte:
case SharerType.@short:
return(1);
case SharerType.@int:
case SharerType.@uint:
return(2);
case SharerType.@long:
case SharerType.@ulong:
case SharerType.@float:
return(4);
case SharerType.int64:
case SharerType.uint64:
case SharerType.@double:
return(8);
default:
return(0);
}
}
public static void Encode(SharerType type, BinaryWriter writer, object value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
switch (type)
{
case SharerType.@bool:
var boolValue = Boolean.Parse(value.ToString());
writer.Write((byte)(boolValue? 1:0));
break;
case SharerType.@byte:
writer.Write(Byte.Parse(value.ToString()));
break;
case SharerType.@short:
writer.Write(SByte.Parse(value.ToString()));
break;
case SharerType.@int:
writer.Write(Int16.Parse(value.ToString()));
break;
case SharerType.@uint:
writer.Write(UInt16.Parse(value.ToString()));
break;
case SharerType.@long:
writer.Write(Int32.Parse(value.ToString()));
break;
case SharerType.@ulong:
writer.Write(UInt32.Parse(value.ToString()));
break;
case SharerType.@float:
writer.Write(float.Parse(value.ToString().Replace(",", "."), System.Globalization.NumberStyles.AllowDecimalPoint, System.Globalization.CultureInfo.InvariantCulture));
break;
case SharerType.int64:
writer.Write(Int64.Parse(value.ToString()));
break;
case SharerType.uint64:
writer.Write(UInt64.Parse(value.ToString()));
break;
case SharerType.@double:
writer.Write(double.Parse(value.ToString().Replace(",", "."), System.Globalization.NumberStyles.AllowDecimalPoint, System.Globalization.CultureInfo.InvariantCulture));
break;
default:
throw new Exception("Type " + type.ToString() + " not supported");
}
}
/// <summary>
/// Read simultaneously several variables in Arduino
/// </summary>
/// <param name="names">Names of variable to read</param>
/// <returns>Variable values and read status</returns>
public List <SharerReadVariableReturn> ReadVariables(IEnumerable <string> names)
{
AssertConnected();
if (names == null)
{
throw new ArgumentNullException("names");
}
if (names.Count() == 0)
{
return(new List <SharerReadVariableReturn>());
}
var ids = new short[names.Count()];
var types = new SharerType[names.Count()];
for (int i = 0; i < names.Count(); i++)
{
ids[i] = (short)Variables.FindIndex((x) => string.Equals(x.Name, names.ElementAt(i)));
if (ids[i] < 0)
{
throw new Exception(names.ElementAt(i) + " not found in variables");
}
types[i] = Variables[ids[i]].Type;
}
byte[] buffer;
using (MemoryStream memory = new MemoryStream())
{
using (BinaryWriter writer = new BinaryWriter(memory))
{
writer.Write((short)ids.Length);
foreach (var id in ids)
{
writer.Write(id);
}
buffer = memory.ToArray();
}
}
var cmd = new SharerReadVariablesCommand(buffer, types);
sendCommand(cmd);
bool success = cmd.WaitAnswer(DEFAULT_TIMEOUT);
if (!success)
{
throw new Exception("Error while reading variables", cmd.Exception);
}
return(cmd.Values);
}
public void Share(string message, SharerType sharerType)
{
if (sharerType == SharerType.Reddit)
{
redditPoster.Post(message);
}
else
{
Sharing sharer = SharerFactory.Instance.GetSharer(sharerType);
sharer.Share(message);
}
}
public Sharing GetSharer(SharerType sharerType)
{
Sharing sharing = null;
switch (sharerType)
{
case SharerType.Facebook: sharing = new FacebookSharer(); break;
case SharerType.Twitter: sharing = new TwitterSharer(); break;
default: break;
}
return(sharing);
}
internal override bool DecodeArgument(byte b)
{
switch (_receivedStep)
{
case Steps.Status: // receive status
_lastValue = new SharerReadVariableReturn();
Values.Add(_lastValue);
_lastValue.Status = (SharerReadVariableStatus)b;
// if the we have a value, go to next step to decode, else stay to have next variable
if (_lastValue.Status == SharerReadVariableStatus.OK)
{
_lastValueType = _types[Values.Count - 1];
_lastValueSize = SharerTypeHelper.Sizeof(_lastValueType);
_lastValueBytes.Clear();
_receivedStep = Steps.Value;
}
else if (Values.Count >= _types.Length)
{
_receivedStep = Steps.End;
}
break;
case Steps.Value:
_lastValueBytes.Add(b); // add received byte
// if enought returned byte, decode it
if (_lastValueBytes.Count >= _lastValueSize)
{
_lastValue.Value = SharerTypeHelper.Decode(_lastValueType, _lastValueBytes.ToArray());
if (Values.Count >= _types.Length)
{
_receivedStep = Steps.End;
}
else
{
_receivedStep = Steps.Status;
}
}
break;
}
return(_receivedStep == Steps.End);
}
public static object Decode(SharerType type, byte[] buffer)
{
using (MemoryStream memory = new MemoryStream(buffer))
{
using (BinaryReader reader = new BinaryReader(memory))
{
switch (type)
{
case SharerType.@bool:
return(reader.ReadByte() != 0);
case SharerType.@byte:
return(reader.ReadByte());
case SharerType.@short:
return(reader.ReadSByte());
case SharerType.@int:
return(reader.ReadInt16());
case SharerType.@uint:
return(reader.ReadUInt16());
case SharerType.@long:
return(reader.ReadInt32());
case SharerType.@ulong:
return(reader.ReadUInt32());
case SharerType.@float:
return(reader.ReadSingle());
case SharerType.int64:
return(reader.ReadInt64());
case SharerType.uint64:
return(reader.ReadUInt64());
case SharerType.@double:
return(reader.ReadDouble());
default:
return(null);
}
}
}
}
public SharerCallFunctionCommand(byte[] buffer, SharerType returnType)
{
_buffer = buffer;
_returnType = returnType;
Return.Type = returnType;
}
