// HidUtility asks if a packet should be requested from the device
// Request a packet if a packet has been successfully sent to the device before
public void ReceivePacketHandler(object sender, UsbBuffer InBuffer)
{
DebugString = "Start ReceivePacketHandler";
WaitingForDevice = true;
InBuffer.RequestTransfer = WaitingForDevice;
DebugString = "End ReceivePacketHandler";
}
public int BulkTransfer(UsbTransferDirection direction, byte endpoint, UsbBuffer buffer, int timeout)
{
int transferred;
LibUSBNative.ThrowIfError(LibUSBNative.libusb_bulk_transfer(handle, (byte)(endpoint | (byte)direction), buffer.AsPtr(), buffer.ByteLength, &transferred, (uint)timeout));
return(transferred);
}
// HidUtility asks if a packet should be sent to the device
// Prepare the buffer and request a transfer
public void SendPacketHandler(object sender, UsbBuffer OutBuffer)
{
// Fill entire buffer with 0xFF
OutBuffer.clear();
if (ToggleLedPending == true)
{
// The first byte is the "Report ID" and does not get sent over the USB bus. Always set = 0.
OutBuffer.buffer[0] = 0;
// 0x80 is the "Toggle LED" command in the firmware
OutBuffer.buffer[1] = 0x80;
ToggleLedPending = false;
LastCommand = 0x80;
}
else if (LastCommand == 0x81)
{
// The first byte is the "Report ID" and does not get sent over the USB bus. Always set = 0.
OutBuffer.buffer[0] = 0x00;
// READ_POT command (see the firmware source code), gets 10-bit ADC Value
OutBuffer.buffer[1] = 0x37;
LastCommand = 0x37;
}
else
{
// The first byte is the "Report ID" and does not get sent over the USB bus. Always set = 0.
OutBuffer.buffer[0] = 0x00;
// 0x81 is the "Get Pushbutton State" command in the firmware
OutBuffer.buffer[1] = 0x81;
LastCommand = 0x81;
}
// Request that this buffer be sent
OutBuffer.RequestTransfer = true;
}
// HidUtility informs us if the requested transfer was successful and provides us with the received packet
public void PacketReceivedHandler(object sender, UsbBuffer InBuffer)
{
//WriteLog(string.Format("PacketReceivedHandler: {0:X2}", InBuffer.buffer[1]), false);
WaitingForDevice = false;
if (InBuffer.buffer[1] == 0x37)
{
//Need to reformat the data from two unsigned chars into one unsigned int.
AdcValue = (uint)(InBuffer.buffer[3] << 8) + InBuffer.buffer[2];
}
if (InBuffer.buffer[1] == 0x81)
{
if (InBuffer.buffer[2] == 0x01)
{
PushbuttonPressed = false;
}
if (InBuffer.buffer[2] == 0x00)
{
PushbuttonPressed = true;
}
}
if (InBuffer.TransferSuccessful)
{
++RxCount;
}
else
{
++RxFailedCount;
}
}
//Function to parse packet received over USB
private void ParseCalibration2(ref UsbBuffer InBuffer)
{
OnboardTemperatureCalibration = new Calibration(InBuffer.buffer, 2);
ExternalTemperature1Calibration = new Calibration(InBuffer.buffer, 14);
ExternalTemperature2Calibration = new Calibration(InBuffer.buffer, 26);
//New calibration is now available
_NewCalibration2Available = true;
}
//Function to parse packet received over USB
private void ParseCalibration1(ref UsbBuffer InBuffer)
{
InputVoltageCalibration = new Calibration(InBuffer.buffer, 2);
OutputVoltageCalibration = new Calibration(InBuffer.buffer, 14);
InputCurrentCalibration = new Calibration(InBuffer.buffer, 26);
OutputCurrentCalibration = new Calibration(InBuffer.buffer, 38);
//New calibration is now available
_NewCalibration1Available = true;
}
// HidUtility informs us if the requested transfer was successful
// Schedule to request a packet if the transfer was successful
public void PacketSentHandler(object sender, UsbBuffer OutBuffer)
{
if (LastCommand == 0x80)
{
WaitingForDevice = false;
}
else
{
WaitingForDevice = OutBuffer.TransferSuccessful;
}
++TxCount;
}
// HidUtility asks if a packet should be sent to the device
// Prepare the buffer and request a transfer
public void SendPacketHandler(object sender, UsbBuffer OutBuffer)
{
DebugString = "Start SendPacketHandler";
// Fill entire buffer with 0xFF
OutBuffer.clear();
// The first byte is the "Report ID" and does not get sent over the USB bus. Always set = 0.
OutBuffer.buffer[0] = 0x00;
//Prepare data to send
byte NextPacket;
if (PacketsToRequest.Count >= 1)
{
NextPacket = PacketsToRequest[0];
PacketsToRequest.RemoveAt(0);
}
else
{
NextPacket = 0x10;
}
OutBuffer.buffer[1] = NextPacket;
PacketsToRequest.Add(NextPacket);
int position = 2;
while ((position <= 64) && (PendingCommands.Count > 0))
{
List <byte> CommandBytes = PendingCommands[0].GetByteList();
//Check if entire command fits into current buffer
if ((64 - position) >= CommandBytes.Count)
{
foreach (byte b in CommandBytes)
{
OutBuffer.buffer[position] = b;
++position;
}
PendingCommands.RemoveAt(0);
}
else
{
position += CommandBytes.Count;
break;
}
}
//Request the packet to be sent over the bus
OutBuffer.RequestTransfer = true;
DebugString = "End SendPacketHandler";
}
//Function to parse packet received over USB
private void ParseDisplay2(ref UsbBuffer InBuffer)
{
for (int line = 2; line < 4; ++line)
{
Display[line] = "";
for (int c = 0; c < 20; ++c)
{
char character = (char)InBuffer.buffer[2 + 20 * (line - 2) + c];
Display[line] += character.ToString();
}
}
//New display2 data is now available
_NewDisplay2Available = true;
}
//Function to parse status packet received over USB
private void ParseStatus(ref UsbBuffer InBuffer)
{
FirmwareMajor = InBuffer.buffer[4];
FirmwareMinor = InBuffer.buffer[5];
FirmwareFix = InBuffer.buffer[6];
DeviceStatus_SubTimeSlot = InBuffer.buffer[7];
DeviceStatus_TimeSlot = InBuffer.buffer[8];
DeviceStatus_Done = InBuffer.buffer[9];
DeviceStatus_LeftEncoderCount = (sbyte)InBuffer.buffer[10];
DeviceStatus_LeftEncoderButton = (sbyte)InBuffer.buffer[11];
DeviceStatus_RightEncoderCount = (sbyte)InBuffer.buffer[12];
DeviceStatus_RightEncoderButton = (sbyte)InBuffer.buffer[13];
DeviceStatus_CurrentPositionInSteps = BitConverter.ToUInt32(InBuffer.buffer, 14);
DeviceStatus_CurrentPositionInDegrees = BitConverter.ToUInt16(InBuffer.buffer, 18);
DeviceStatus_DisplayState = InBuffer.buffer[22];
DeviceStatus_BeepCount = InBuffer.buffer[23];
DeviceStatus_InternalTemperature = BitConverter.ToInt16(InBuffer.buffer, 24);
DeviceStatus_ExternalTemperature = BitConverter.ToInt16(InBuffer.buffer, 26);
DeviceStatus_FanOn = InBuffer.buffer[28];
DeviceStatus_BrakeOn = InBuffer.buffer[29];
DeviceStatus_Busy = InBuffer.buffer[30];
DeviceStatus_ManualSpeed = BitConverter.ToUInt16(InBuffer.buffer, 31);
DeviceStatus_AbsolutePosition = BitConverter.ToInt16(InBuffer.buffer, 33);
//42-45: uint32_t full_circle_in_steps
//46: uint8_t inverse_direction
//47-48: uint16_t overshoot_in_steps
//49-50: uint16_t overshoot_cost_in_steps
//51-52: uint16_t minimum_speed
//53-54: uint16_t maximum_speed
//55-56: uint16_t initial_speed_arc
//57-58: uint16_t maximum_speed_arc
//59-60: uint16_t initial_speed_manual
//61-62: uint16_t maximum_speed_manual
//63: uint8_t beep_duration
DeviceConfig_PositionDisplay180 = (byte)InBuffer.buffer[35];
DeviceConfig_FullCircleInSteps = BitConverter.ToUInt32(InBuffer.buffer, 43);
DeviceConfig_InverseDirection = InBuffer.buffer[45];
DeviceConfig_OvershootInSteps = BitConverter.ToUInt16(InBuffer.buffer, 48);
DeviceConfig_OvershootCostInSteps = BitConverter.ToUInt16(InBuffer.buffer, 50);
DeviceConfig_MinimumSpeed = BitConverter.ToUInt16(InBuffer.buffer, 52);
DeviceConfig_MaximumSpeed = BitConverter.ToUInt16(InBuffer.buffer, 54);
DeviceConfig_InitialSpeedArc = BitConverter.ToUInt16(InBuffer.buffer, 56);
DeviceConfig_MaximumSpeedArc = BitConverter.ToUInt16(InBuffer.buffer, 58);
DeviceConfig_InitialSpeedManual = BitConverter.ToUInt16(InBuffer.buffer, 60);
DeviceConfig_MaximumSpeedManual = BitConverter.ToUInt16(InBuffer.buffer, 62);
DeviceConfig_BeepDuration = InBuffer.buffer[49];
}
// HidUtility informs us if the requested transfer was successful
// Schedule to request a packet if the transfer was successful
public void PacketSentHandler(object sender, UsbBuffer OutBuffer)
{
DebugString = "Start PacketSentHandler";
WaitingForDevice = OutBuffer.TransferSuccessful;
if (OutBuffer.TransferSuccessful)
{
++TxCount;
}
else
{
++TxFailedCount;
}
DebugString = "End PacketSentHandler";
}
// HidUtility informs us if the requested transfer was successful and provides us with the received packet
public void PacketReceivedHandler(object sender, UsbBuffer InBuffer)
{
DebugString = String.Format("Start PacketReceivedHandler ({0:X})", InBuffer.buffer[1]);
WaitingForDevice = false;
//Parse received data
switch (InBuffer.buffer[1])
{
case 0x10:
ParseStatus(ref InBuffer);
break;
case 0x11:
case 0x12:
ParseDisplay(ref InBuffer);
break;
case 0x13:
//mode-specific details
//This is the last package. We now have a consistent snapshot
_NewDataAvailable = true;
break;
default:
//We have received a packet of unknown content
DebugString = String.Format("Unknown packet received: {0:X}", InBuffer.buffer[1]);
NewDebugString = true;
break;
}
//Some statistics
if (InBuffer.TransferSuccessful)
{
++RxCount;
}
else
{
++RxFailedCount;
}
DebugString = "End PacketReceivedHandler";
}
// HidUtility informs us if the requested transfer was successful and provides us with the received packet
public void PacketReceivedHandler(object sender, UsbBuffer InBuffer)
{
WaitingForDevice = false;
if (InBuffer.buffer[1] == 0x37)
{
AdcValue = (uint)(InBuffer.buffer[3] << 8) + InBuffer.buffer[2];
}
if (InBuffer.buffer[1] == 0x81)
{
if (InBuffer.buffer[2] == 0x01)
{
PushbuttonPressed = false;
}
if (InBuffer.buffer[2] == 0x00)
{
PushbuttonPressed = true;
}
}
++RxCount;
}
// HidUtility informs us if the requested transfer was successful and provides us with the received packet
public void PacketReceivedHandler(object sender, UsbBuffer InBuffer)
{
DebugString = "Start PacketReceivedHandler";
WaitingForDevice = false;
//Parse received data
switch (InBuffer.buffer[1])
{
case 0x10:
ParseStatusData(ref InBuffer);
break;
case 0x11:
ParseDisplay1(ref InBuffer);
break;
case 0x12:
ParseDisplay2(ref InBuffer);
break;
case 0x13:
ParseCalibration1(ref InBuffer);
break;
case 0x14:
ParseCalibration2(ref InBuffer);
break;
}
;
//Some statistics
if (InBuffer.TransferSuccessful)
{
++RxCount;
}
else
{
++RxFailedCount;
}
DebugString = "End PacketReceivedHandler";
}
private void ParseDisplay(ref UsbBuffer InBuffer)
{
string Replace(byte b)
{
switch (b)
{
case 0x00:
return("|");
case 0x01:
return("°");
case 0x02:
return("ä");
default:
return("" + ((char)b));
}
}
int first_line = 0;
if (InBuffer.buffer[1] == 0x12)
{
first_line = 2;
}
DisplayContent[first_line] = "";
DisplayContent[first_line + 1] = "";
for (int i = 0; i < 20; ++i)
{
DisplayContent[first_line] += Replace(InBuffer.buffer[4 + i]);
DisplayContent[first_line + 1] += Replace(InBuffer.buffer[24 + i]);
}
}
public int ControlTransferWrite(byte fieldRequest, ushort fieldValue, ushort fieldIndex, UsbBuffer buffer, uint timeout)
{
byte flags = LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE;
return(ControlTransfer(flags, fieldRequest, fieldValue, fieldIndex, buffer, timeout));
}
private int ControlTransfer(byte flags, byte fieldRequest, ushort fieldValue, ushort fieldIndex, UsbBuffer buffer, uint timeout)
{
//Apply
int code;
if (buffer != null)
{
code = LibUSBNative.libusb_control_transfer(handle, flags, fieldRequest, fieldValue, fieldIndex, buffer.AsPtr(), (ushort)buffer.ByteLength, timeout);
}
else
{
code = LibUSBNative.libusb_control_transfer(handle, flags, fieldRequest, fieldValue, fieldIndex, null, 0, timeout);
}
//Valiate
if (code < 0)
{
throw new Exception("Unknown USB transfer write error.");
}
return(code);
}
// HidUtility asks if a packet should be requested from the device
// Request a packet if a packet has been successfully sent to the device before
public void ReceivePacketHandler(object sender, UsbBuffer InBuffer)
{
InBuffer.RequestTransfer = WaitingForDevice;
//WriteLog(string.Format("ReceivePacketHandler: {0}", WaitingForDevice), false);
}
//Function to parse packet received over USB
private void ParseStatusData(ref UsbBuffer InBuffer)
{
//Input values are mainly encoded as Int16
Int16 tmp;
tmp = (Int16)((InBuffer.buffer[3] << 8) + InBuffer.buffer[2]);
InputVoltage = (double)tmp / 1000.0;
tmp = (Int16)((InBuffer.buffer[5] << 8) + InBuffer.buffer[4]);
OutputVoltage = (double)tmp / 1000.0;
tmp = (Int16)((InBuffer.buffer[7] << 8) + InBuffer.buffer[6]);
InputCurrent = (double)tmp / 1000.0;
tmp = (Int16)((InBuffer.buffer[9] << 8) + InBuffer.buffer[8]);
OutputCurrent = (double)tmp / 1000.0;
tmp = (Int16)((InBuffer.buffer[11] << 8) + InBuffer.buffer[10]);
TemperatureOnboard = (double)tmp / 100.0;
tmp = (Int16)((InBuffer.buffer[13] << 8) + InBuffer.buffer[12]);
TemperatureExternal1 = (double)tmp / 100.0;
tmp = (Int16)((InBuffer.buffer[15] << 8) + InBuffer.buffer[14]);
TemperatureExternal2 = (double)tmp / 100.0;
InputPower = InputVoltage * InputCurrent;
OutputPower = OutputVoltage * OutputCurrent;
Loss = InputPower - OutputPower;
Efficiency = OutputPower / InputPower;
PowerOutput1 = ((InBuffer.buffer[16] & 1) == 1);
PowerOutput2 = ((InBuffer.buffer[16] & 2) == 2);
PowerOutput3 = ((InBuffer.buffer[16] & 4) == 4);
PowerOutput4 = ((InBuffer.buffer[16] & 8) == 8);
PowerOutputUsb = ((InBuffer.buffer[16] & 16) == 16);
FanOutput = ((InBuffer.buffer[16] & 32) == 32);
FanOutputManual = ((InBuffer.buffer[16] & 64) == 64);
DisplayMode = InBuffer.buffer[17];
uint Year = 2000 + BcdToUint(InBuffer.buffer[18]);
uint Month = BcdToUint(InBuffer.buffer[19]);
uint Day = BcdToUint(InBuffer.buffer[20]);
uint Hour = BcdToUint(InBuffer.buffer[21]);
uint Minute = BcdToUint(InBuffer.buffer[22]);
uint Second = BcdToUint(InBuffer.buffer[23]);
SystemTime = new DateTime((int)Year, (int)Month, (int)Day, (int)Hour, (int)Minute, (int)Second);
BuckMode = InBuffer.buffer[24];
BuckDutyCycle = InBuffer.buffer[25];
BuckRemoteEnable = ((InBuffer.buffer[26] & 1) == 1);
BuckRemoteOn = ((InBuffer.buffer[26] & 2) == 2);
BuckRemoteSynchronous = ((InBuffer.buffer[26] & 4) == 4);
BuckRemoteDutycycle = InBuffer.buffer[27];
tmp = (Int16)((InBuffer.buffer[29] << 8) + InBuffer.buffer[28]);
TemperatureOnboardAdc = (uint)tmp;
tmp = (Int16)((InBuffer.buffer[31] << 8) + InBuffer.buffer[30]);
TemperatureExternal1Adc = (uint)tmp;
tmp = (Int16)((InBuffer.buffer[33] << 8) + InBuffer.buffer[32]);
TemperatureExternal2Adc = (uint)tmp;
tmp = (Int16)((InBuffer.buffer[35] << 8) + InBuffer.buffer[34]);
InputVoltageAdc[(TimeSlot >> 4) & 0x03] = (uint)tmp;
tmp = (Int16)((InBuffer.buffer[37] << 8) + InBuffer.buffer[36]);
OutputVoltageAdc[(TimeSlot >> 4) & 0x03] = (uint)tmp;
tmp = (Int16)((InBuffer.buffer[39] << 8) + InBuffer.buffer[38]);
InputCurrentAdc[(TimeSlot >> 4) & 0x03] = (uint)tmp;
tmp = (Int16)((InBuffer.buffer[41] << 8) + InBuffer.buffer[40]);
OutputCurrentAdc[(TimeSlot >> 4) & 0x03] = (uint)tmp;
DisplayStatus = InBuffer.buffer[42];
TimeSlot = InBuffer.buffer[43];
//New status data is now available
_NewStatusAvailable = true;
}
// HidUtility asks if a packet should be requested from the device
// Request a packet if a packet has been successfully sent to the device before
public void ReceivePacketHandler(object sender, UsbBuffer InBuffer)
{
InBuffer.RequestTransfer = WaitingForDevice;
}
