private void Compress(CompressionBuffer buffer, IotDevice lastDevice, IotDevice device)
{
buffer.CompressAndFold(4 + ((lastDevice == null || lastDevice.StatusMessage == null || lastDevice.StatusMessage != device.StatusMessage) ? 10 : 0));
buffer.CompressAndFold(device.Pressure.Value, 5);
buffer.CompressAndFold(device.Temperature.Value, 100);
buffer.CompressAndFold(device.Distance.Value, 1000);
}
private IotDevice DeserializeType(byte[] data)
{
var bitReader = new BitReader(data);
var name = DeserializeString(bitReader);
var id = DeserializeString(bitReader);
var statusMessage = DeserializeString(bitReader);
var selfCheckPassed = DeserializeBoolean(bitReader);
var serviceModeEnabled = DeserializeBoolean(bitReader);
var uptimeInSeconds = DeserializeUInt64(bitReader);
var pressure = DeserializeDouble(bitReader);
var temperature = DeserializeDouble(bitReader);
var distance = DeserializeDouble(bitReader);
if (_extremeOptimization)
{
id = Guid.Parse(id).ToString("D");
}
var instance = new IotDevice(
name,
id,
statusMessage,
selfCheckPassed,
serviceModeEnabled,
uptimeInSeconds,
new PhysicalValue(pressure, "bar"),
new PhysicalValue(temperature, "°C"),
new PhysicalValue(distance, "m")
);
return(instance);
}
private byte[] SerializeType(IotDevice obj)
{
var bitWriter = new BitWriter();
var id = obj.Id;
if (_extremeOptimization)
{
// if it smells like a guid and it looks like a guid
// it must be a guid, in that case we can dismiss the hyphens
// this saves us 4 bytes
id = Guid.Parse(id).ToString("N");
}
SerializeType(bitWriter, obj.Name);
SerializeType(bitWriter, id);
SerializeType(bitWriter, obj.StatusMessage);
SerializeType(bitWriter, obj.SelfCheckPassed);
SerializeType(bitWriter, obj.ServiceModeEnabled);
SerializeType(bitWriter, obj.UptimeInSeconds);
SerializeType(bitWriter, obj.Pressure.Value);
SerializeType(bitWriter, obj.Temperature.Value);
SerializeType(bitWriter, obj.Distance.Value);
var bytes = bitWriter.ToArray();
return(bytes);
}
private IotDevice Decompress(CompressionBuffer buffer, IotDevice lastDevice)
{
try
{
var uptime = (lastDevice?.UptimeInSeconds ?? 0) + (ulong)(buffer.Decompress().Value * 100.0);
string message = lastDevice?.StatusMessage;
if (lastDevice == null || buffer.Decompress().Value < 0.1)
{
message = buffer.DecompressString();
}
return(new IotDevice(
lastDevice.Name,
lastDevice.Id,
message,
buffer.DecompressBoolean(),
buffer.DecompressBoolean(),
uptime,
new PhysicalValue(buffer.Decompress().Value * 5.0, "bar"),
new PhysicalValue(buffer.Decompress().Value * 100.0, "°C"),
new PhysicalValue(buffer.Decompress().Value * 1000.0, "m")));
}
catch (InvalidOperationException ioe)
{
if (_debug)
{
Console.WriteLine("Decompression Error" + ioe.ToString());
}
return(null);
}
}
private byte[] SerializeType(IotDevice obj)
{
var bitWriter = new BitWriter();
var id = Guid.Parse(obj.Id);
var statusMessage = obj.StatusMessage.Replace(" ", string.Empty);
bitWriter.WriteBit(string.Equals(statusMessage, _statusMessage, StringComparison.Ordinal));
bitWriter.WriteBit(IsEqual(_pressure, obj.Pressure.Value));
bitWriter.WriteBit(IsEqual(_temperature, obj.Temperature.Value));
bitWriter.WriteBit(IsEqual(_distance, obj.Distance.Value));
if (!string.Equals(obj.Name, _name, StringComparison.Ordinal))
{
SerializeType(bitWriter, obj.Name);
_name = obj.Name;
}
if (id != _id)
{
SerializeType(bitWriter, id);
_id = id;
}
if (!string.Equals(statusMessage, _statusMessage, StringComparison.Ordinal))
{
SerializeType(bitWriter, statusMessage);
_statusMessage = statusMessage;
}
SerializeType(bitWriter, obj.SelfCheckPassed);
SerializeType(bitWriter, obj.ServiceModeEnabled);
SerializeType(bitWriter, obj.UptimeInSeconds - _uptimeInSeconds, bitLength: 7);
_uptimeInSeconds = obj.UptimeInSeconds;
if (!IsEqual(_pressure, obj.Pressure.Value))
{
SerializeType(bitWriter, obj.Pressure.Value);
_pressure = obj.Pressure.Value;
}
if (!IsEqual(_temperature, obj.Temperature.Value))
{
SerializeType(bitWriter, obj.Temperature.Value);
_temperature = obj.Temperature.Value;
}
if (!IsEqual(_distance, obj.Distance.Value))
{
SerializeType(bitWriter, obj.Distance.Value);
_distance = obj.Distance.Value;
}
var bytes = bitWriter.ToArray();
return(bytes);
}
public byte[] Encode(IotDevice device)
{
var text = JsonConvert.SerializeObject(device);
var encoding = new System.Text.UTF8Encoding();
return(encoding.GetBytes(text));
}
private DevicesDao ConvertToDao(IotDevice obj)
{
return(new DevicesDao
{
DeviceId = obj.Id,
LocationX = obj.LocationX,
LocationY = obj.LocationY
});
}
public long Run(IDataSource source, IEncoder encoder, IDecoder decoder, long msgCount, bool debug)
{
long totalBytesTransmitted = 0;
for (long i = 0; i < msgCount; i++)
{
var sourceData = source.GetNextDataPoint();
var encodedData = encoder.Encode(sourceData);
// This is where the data is normally transmitted via network
totalBytesTransmitted += encodedData.LongLength;
var decodedData = decoder.Decode(encodedData);
var areEqual = IotDevice.AreEquals(sourceData, decodedData, false);
if (!areEqual || debug)
{
Console.WriteLine();
Console.WriteLine("##########################################################");
Console.WriteLine($"Message number: {i+1}");
Console.WriteLine();
Console.WriteLine("source data:");
Console.WriteLine(sourceData);
Console.WriteLine();
Console.WriteLine("encoded data:");
Console.WriteLine(BitConverter.ToString(encodedData).Replace("-", ""));
Console.WriteLine();
Console.WriteLine("decoded data:");
Console.WriteLine(decodedData);
Console.WriteLine();
if (!areEqual)
{
// run this again to get debug outputs
IotDevice.AreEquals(sourceData, decodedData, true);
}
Console.WriteLine($"Encoding/Decoding successful: {areEqual}");
}
if (debug)
{
Console.WriteLine("Press any key to send the next message.");
Console.ReadKey();
}
}
return(totalBytesTransmitted);
}
public byte[] Encode(IotDevice device, IotDevice lastState = null)
{
using var memoryStream = new MemoryStream();
using var writer = new BinaryWriter(memoryStream);
var messageFlags =
(device.SelfCheckPassed ? MessageFlags.SelfCheckPassed : MessageFlags.None) |
(device.ServiceModeEnabled ? MessageFlags.ServiceModeEnabled : MessageFlags.None) |
(device.Pressure.Unit == "bar" ? MessageFlags.UseDefaultPressureUnit : MessageFlags.None) |
(device.Temperature.Unit == "°C" ? MessageFlags.UseDefaultTemperatureUnit : MessageFlags.None) |
(device.Distance.Unit == "m" ? MessageFlags.UseDefaultDistanceUnit : MessageFlags.None) |
(lastState?.StatusMessage != device.StatusMessage ? MessageFlags.IncludeMessage : MessageFlags.None);
writer.Write((byte)messageFlags);
if (lastState == null)
{
writer.Write(device.Name);
}
if (lastState == null)
{
writer.Write(Guid.Parse(device.Id).ToByteArray());
}
// Ja, man braucht nur ein 5 Bit Alphabet. Und die Leerzeichen kann man auch weglassen wenn man Annahmen trifft.
if (true || CheckFlag(MessageFlags.IncludeMessage, messageFlags))
{
writer.Write(device.StatusMessage); // Matthid.ImprovedLowerCaseStringEncoder.EncodeString(device.StatusMessage.Replace(" ", "")));
}
writer.Write(device.UptimeInSeconds);
// Leider kann man nicht einfach den double in einen float oder sogar einen 2-Byte Wert konvertieren ohne große Annahmen zu treffen
// Der Fehler in IoTDevice.AreEquals ist relativ definiert, je kleiner der Wert ist, desto kleiner darf der Fehler höchstens sein.
// Die Konvertierung geht nur, wenn man weiß dass zufällige Werte niemals kleiner sind als eine bestimmte Grenze, wäre eine Messung
// stattdessen z.B: double.Epsilon wäre jede Konvertierung unzulässig
writer.Write((double)device.Pressure.Value);
if (!CheckFlag(MessageFlags.UseDefaultPressureUnit, messageFlags))
{
writer.Write(device.Pressure.Unit);
}
writer.Write((double)device.Temperature.Value);
if (!CheckFlag(MessageFlags.UseDefaultTemperatureUnit, messageFlags))
{
writer.Write(device.Temperature.Unit);
}
writer.Write((double)device.Distance.Value);
if (!CheckFlag(MessageFlags.UseDefaultDistanceUnit, messageFlags))
{
writer.Write(device.Distance.Unit);
}
return(memoryStream.ToArray());
}
public void Update(IotDevice obj)
{
DevicesDao newDevice = ConvertToDao(obj);
DevicesDao foundDevice = _ctx.Devices.First(d => d.DeviceId == obj.Id);
if (foundDevice != null)
{
foundDevice.LocationX = newDevice.LocationX;
foundDevice.LocationY = newDevice.LocationY;
}
_ctx.SaveChanges();
}
public byte[] Encode(IotDevice device)
{
var protoMsg = new ProgrammingChallenge2.Codecs.Matthid.Protobuf.OptimizedIoTDevice();
var statusMessage = options.RemoveSpaces ? device.StatusMessage?.Replace(" ", "") : device.StatusMessage;
if (options.RememberLastData)
{
if (lastName == null || lastName != device.Name)
{
lastName = device.Name;
protoMsg.Name = EncodeString(device.Name);
}
if (lastId == null || lastId != device.Id)
{
lastId = device.Id;
var idGuid = System.Guid.ParseExact(device.Id, "D");
protoMsg.Id = ByteString.CopyFrom(idGuid.ToByteArray());
}
if (lastMsg == null || lastMsg != statusMessage)
{
lastMsg = statusMessage;
protoMsg.StatusMessage = EncodeString(statusMessage);
}
}
else
{
protoMsg.Name = EncodeString(device.Name);
var idGuid = System.Guid.ParseExact(device.Id, "D");
protoMsg.Id = ByteString.CopyFrom(idGuid.ToByteArray());
protoMsg.StatusMessage = EncodeString(statusMessage);
}
protoMsg.SelfCheckPassed = device.SelfCheckPassed;
protoMsg.ServiceModeEnabled = device.ServiceModeEnabled;
protoMsg.AdditionalUptimeInSeconds = (uint)(device.UptimeInSeconds - lastUptime);
lastUptime = device.UptimeInSeconds;
protoMsg.Pressure = (float)device.Pressure.Value;
protoMsg.Temperature = (float)device.Temperature.Value;
protoMsg.Distance = (float)device.Distance.Value;
return(protoMsg.ToByteArray());
}
public IotDevice Decode(byte[] data)
{
try
{
var device = _decoder.Decode(data, _lastDecodedDevice);
Compress(_decodingBuffer, _lastDecodedDevice, device);
_lastDecodedDevice = device;
return(device);
}
catch
{
var device = Decompress(_decodingBuffer, _lastDecodedDevice);
_lastDecodedDevice = device;
return(device);
}
}
public byte[] Encode(IotDevice device)
{
var protoMsg = new ProgrammingChallenge2.Codecs.Matthid.Protobuf.StupidIoTDevice();
protoMsg.Name = device.Name;
protoMsg.Id = device.Id;
protoMsg.StatusMessage = device.StatusMessage;
protoMsg.SelfCheckPassed = device.SelfCheckPassed;
protoMsg.ServiceModeEnabled = device.ServiceModeEnabled;
protoMsg.UptimeInSeconds = device.UptimeInSeconds;
protoMsg.Pressure = EncodePhysical(device.Pressure);
protoMsg.Temperature = EncodePhysical(device.Temperature);
protoMsg.Distance = EncodePhysical(device.Distance);
return(protoMsg.ToByteArray());
}
public IotDevice Create(IotDevice obj)
{
IEnumerable <IotDevice> devices = ReadAllDevices();
foreach (IotDevice iot in devices)
{
if (iot.LocationX == obj.LocationX && iot.LocationY == obj.LocationY)
{
throw new DuplicateNameException("Device(ID=" + iot.Id + ") en Device(ID=" + obj.Id + ") delen dezelfde locatie nl. " + obj.LocationX +
"," + obj.LocationY + ".");
}
}
obj.Id = FindNextAvailableDeviceId();
_ctx.Devices.Add(ConvertToDao(obj));
_ctx.SaveChanges();
return(obj);
}
public IotDevice Decode(byte[] data, IotDevice lastState = null)
{
using var memoryStream = new MemoryStream(data);
using var reader = new BinaryReader(memoryStream);
var messageFlags = (MessageFlags)reader.ReadByte();
var iotDevice = new IotDevice(
lastState == null ? reader.ReadString() : lastState.Name,
lastState == null ? new Guid(reader.ReadBytes(16)).ToString() : lastState.Id,
/*CheckFlag(MessageFlags.IncludeMessage, messageFlags) ?*/ reader.ReadString(), /* : lastState.StatusMessage,*/ // Beautify(Matthid.ImprovedLowerCaseStringEncoder.DecodeBytes(reader.ReadBytes(7))): lastState.StatusMessage,
CheckFlag(MessageFlags.SelfCheckPassed, messageFlags),
CheckFlag(MessageFlags.ServiceModeEnabled, messageFlags),
reader.ReadUInt64(),
new PhysicalValue(reader.ReadDouble(), !CheckFlag(MessageFlags.UseDefaultPressureUnit, messageFlags) ? reader.ReadString() : "bar"),
new PhysicalValue(reader.ReadDouble(), !CheckFlag(MessageFlags.UseDefaultTemperatureUnit, messageFlags) ? reader.ReadString() : "°C"),
new PhysicalValue(reader.ReadDouble(), !CheckFlag(MessageFlags.UseDefaultDistanceUnit, messageFlags) ? reader.ReadString() : "m")
);
return(iotDevice);
}
public byte[] Encode(IotDevice device)
{
var clone = _encodingBuffer.Clone();
Compress(_encodingBuffer, _lastEncodedDevice, device);
var x = Decompress(clone, _lastEncodedDevice);
_lastEncodedDevice = device;
// Wenn beim Komprimieren Rundungsfehler auftreten, dann nehmen wir einfach den Stateless Codec
if (x != null && IotDevice.AreEquals(device, x, _debug))
{
_encodingBuffer = clone;
return(new byte[0]);
}
else
{
var bytes = _encoder.Encode(device, sent ? _lastEncodedDevice : null);
sent = true;
return(bytes);
}
}
private IotDevice DeserializeType(byte[] data)
{
var bitReader = new BitReader(data);
var statusMessageChanged = bitReader.ReadBit();
var pressureChanged = bitReader.ReadBit();
var temperatureChanged = bitReader.ReadBit();
var distanceChanged = bitReader.ReadBit();
_name = _name is object?_name : DeserializeString(bitReader, length : 12);
_id = _id is object?_id : DeserializeGuid(bitReader);
_statusMessage = statusMessageChanged ? _statusMessage : DeserializeString(bitReader, length: 10);
_selfCheckPassed = DeserializeBoolean(bitReader);
_serviceModeEnabled = DeserializeBoolean(bitReader);
_uptimeInSeconds = _uptimeInSeconds + DeserializeUInt64(bitReader, bitLength: 7);
_pressure = pressureChanged ? _pressure : DeserializeDouble(bitReader);
_temperature = temperatureChanged ? _temperature : DeserializeDouble(bitReader);
_distance = distanceChanged ? _distance : DeserializeDouble(bitReader);
if (!_statusMessage.Contains(' '))
{
_statusMessage = _statusMessage.Substring(0, 3) + " " + _statusMessage.Substring(3, 4) + " " + _statusMessage.Substring(7, 3);
}
var instance = new IotDevice(
_name,
_id?.ToString("D") ?? string.Empty,
_statusMessage,
_selfCheckPassed,
_serviceModeEnabled,
_uptimeInSeconds,
new PhysicalValue(_pressure, "bar"),
new PhysicalValue(_temperature, "°C"),
new PhysicalValue(_distance, "m")
);
return(instance);
}
private IotDevice DeserializeType(byte[] data)
{
var bitReader = new BitReader(data);
var statusByte = bitReader.ReadBytes(1)[0];
_name = BitOperations.GetBit(statusByte, 0) ? _name : DeserializeString(bitReader, length: 12, onlyCharacters: true);
_id = BitOperations.GetBit(statusByte, 0) ? _id : DeserializeString(bitReader, length: 32);
_statusMessage = BitOperations.GetBit(statusByte, 1) ? _statusMessage : DeserializeString(bitReader, length: 10, onlyCharacters: true);
_selfCheckPassed = BitOperations.GetBit(statusByte, 2) ? _selfCheckPassed : DeserializeBoolean(bitReader);
_serviceModeEnabled = BitOperations.GetBit(statusByte, 3) ? _serviceModeEnabled : DeserializeBoolean(bitReader);
_uptimeInSeconds = BitOperations.GetBit(statusByte, 4) ? _uptimeInSeconds : DeserializeUInt64(bitReader);
_pressure = BitOperations.GetBit(statusByte, 5) ? _pressure : DeserializeDouble(bitReader);
_temperature = BitOperations.GetBit(statusByte, 6) ? _temperature : DeserializeDouble(bitReader);
_distance = BitOperations.GetBit(statusByte, 7) ? _distance : DeserializeDouble(bitReader);
_id = Guid.Parse(_id).ToString("D");
if (!_statusMessage.Contains(' '))
{
_statusMessage = _statusMessage.Substring(0, 3) + " " + _statusMessage.Substring(3, 4) + " " + _statusMessage.Substring(7, 3);
}
var instance = new IotDevice(
_name,
_id,
_statusMessage,
_selfCheckPassed,
_serviceModeEnabled,
_uptimeInSeconds,
new PhysicalValue(_pressure, "bar"),
new PhysicalValue(_temperature, "°C"),
new PhysicalValue(_distance, "m")
);
return(instance);
}
/// <summary>
/// Should add all claims to the token
/// When expires
/// User owner
/// Organization
/// </summary>
/// <param name="user"></param>
/// <param name="device"></param>
/// <returns></returns>
public string CreateToken(User user, IotDevice device, DateTime?expiration)
{
// TODO Add token creation logic
return("");
}
public byte[] Encode(IotDevice device)
{
return(Encode(device, null));
}
public byte[] Serialize(IotDevice obj)
{
var bytes = SerializeType(obj);
return(bytes);
}
public byte[] Encode(IotDevice device)
{
return(new byte[_random.Next(23)]);
}
public byte[] Encode(IotDevice device) => _serializer.Serialize(device);
public byte[] Encode(IotDevice device)
{
var mem = new MemoryStream();
var writer = new BinaryWriter(mem);
bool writeNameAndId = true, writeMsg = true;
var statusMessage = options.RemoveSpaces ? device.StatusMessage?.Replace(" ", "") : device.StatusMessage;
if (options.RememberLastData)
{
writeNameAndId = false;
if (lastName == null || lastName != device.Name)
{
lastName = device.Name;
writeNameAndId = true;
}
if (lastId == null || lastId != device.Id)
{
lastId = device.Id;
writeNameAndId = true;
}
if (lastMsg == null || lastMsg != statusMessage)
{
lastMsg = statusMessage;
}
else
{
writeMsg = false;
}
writer.Write(writeNameAndId);
writer.Write(writeMsg);
}
if (writeNameAndId)
{
Debug.Assert(device.Name.Length == 12);
WriteString(writer, device.Name);
var idGuid = System.Guid.ParseExact(device.Id, "D");
writer.Write(idGuid.ToByteArray());
}
if (writeMsg)
{
Debug.Assert(statusMessage.Length == (options.RemoveSpaces ? 10 : 12), $"Length was {device.StatusMessage.Length}");
WriteString(writer, statusMessage);
}
writer.Write(device.SelfCheckPassed);
writer.Write(device.ServiceModeEnabled);
if (options.OptimizeUptime)
{
var diff = device.UptimeInSeconds - lastUptime;
Debug.Assert(diff >= 0 && diff < byte.MaxValue, $"expected diff to be smaller than a byte, but was '{diff}'");
writer.Write((byte)(diff));
lastUptime = device.UptimeInSeconds;
}
else
{
writer.Write(device.UptimeInSeconds);
}
writer.Write((float)device.Pressure.Value);
writer.Write((float)device.Temperature.Value);
writer.Write((float)device.Distance.Value);
writer.Flush();
return(mem.ToArray());
}
private void LoadIotDevices()
{
//ugly implementation
IotDevice d;
d = new IotDevice(IotDeviceTypeEnum.ServoMotor, "传送模块电机");
DeviceCurve c = new DeviceCurve("电流时间曲线", "Videos/curvenormal");
d.Curves.Add(c);
c = new DeviceCurve("转速时间曲线", "Videos/curveabnormal");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.ServoMotor, "上压辊电机");
c = new DeviceCurve("电流时间曲线", "Videos/curvenormal");
d.Curves.Add(c);
c = new DeviceCurve("转速时间曲线", "Videos/curvenormal");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.ServoMotor, "下压辊电机");
c = new DeviceCurve("电流时间曲线", "Videos/curveabnormal");
d.Curves.Add(c);
c = new DeviceCurve("转速时间曲线", "Videos/curvenormal");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Solenoid, "传送模块电磁阀");
c = new DeviceCurve("I/O时间曲线", "Videos/1recircle");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Solenoid, "上压辊电磁阀");
c = new DeviceCurve("I/O时间曲线", "Videos/10notrecircle");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Solenoid, "下压辊电磁阀");
c = new DeviceCurve("I/O时间曲线", "Videos/1recircle");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Sensor, "传送模块入口传感器");
c = new DeviceCurve("I/O时间曲线", "Videos/10notrecircle");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Sensor, "传送模块出口传感器");
c = new DeviceCurve("I/O时间曲线", "Videos/1recircle");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Sensor, "热压模块入口传感器");
c = new DeviceCurve("I/O时间曲线", "Videos/1recircle");
d.Curves.Add(c);
iotDevices.Add(d);
d = new IotDevice(IotDeviceTypeEnum.Sensor, "热压模块出口传感器");
c = new DeviceCurve("I/O时间曲线", "Videos/10notrecircle");
d.Curves.Add(c);
iotDevices.Add(d);
}
