public async Task <string> GetDeviceTypeCode() { var response = await DeviceStream.SendCommand(new GetDeviceTypeCommand(DeviceId)); DeviceId = response.DeviceID; return(Bytes.GetAsciiString(response.DATA)); }
/// <summary> /// Send color array in RGB format /// </summary> public void SendRGB(byte channel, byte[] colors) { if (channel != 1 && channel != 2) { throw new ArgumentException("Channel must be 1 or 2"); } if (colors.Length % 3 != 0) { throw new ArgumentException("Color array length must be multiple of 3"); } byte[] buffer = null; using (MemoryStream strm = new MemoryStream(4 + colors.Length * 3)) { strm.Write(new byte[] { 0x22, 0x10, channel, 0x00 }, 0, 4); for (int i = 0; i < colors.Length / 3; i += 1) { strm.Write(new byte[] { colors[i * 3 + 1], colors[i * 3], colors[i * 3 + 2] }, 0, 3); } buffer = strm.ToArray(); } DeviceStream.Write(buffer); DeviceStream.Write(new byte[] { 0x22, 0x11, channel }); //0x22,0xA0,0x02,0x00,0x01,0x00,0x00,0x10,0x00,0x00,0x80,0x00,0x32,0x00,0x00,0x01 DeviceStream.Write(new byte[] { 0x22, 0xA0, channel, 0x00, 0x01, 0x00, 0x00, 0x10, 0x00, 0x00, 0x80, 0x00, 0x32, 0x00, 0x00, 0x01 }); }
public async Task SetEmployeesData(List <UserInfo> users) { while (users.Count > 0) { await DeviceStream.SendCommand(new SetStaffDataCommand(DeviceId, users)); } }
/// <summary> /// Refreshes the logical device. /// </summary> public void Refresh() { bootSector = null; data = new UInt16[0]; // Jump to FAT partition DeviceStream.Seek(partition.RelativeSector * PhysicalDevice.SectorSize, SeekOrigin.Begin); if (!partition.IsFAT) { return; } // Boot sector bootSector = (BootSector)StreamActivator.CreateInstance(typeof(BootSector), DeviceStream); DeviceStream.Seek(448, SeekOrigin.Current); // Failsafe .. be sure FAT partition table is valid if ((DeviceStream.ReadByte() != 0x55) || (DeviceStream.ReadByte() != 0xAA)) { bootSector = null; return; } // Get FAT sector BinaryReader br = new BinaryReader(DeviceStream); data = new UInt16[bootSector.NumberOfFATs * ((bootSector.SectorsPerFAT * PhysicalDevice.SectorSize) / 2)]; for (int i = 0; i < data.Length; i++) { data[i] = br.ReadUInt16(); } }
public async Task <DateTime> GetDateTime() { var cmd = new GetDateTimeCommand(DeviceId); var response = await DeviceStream.SendCommand(cmd); return(DateConversions.ByteArrayToDateTime(response.DATA)); }
public async Task <ulong> GetDeviceID() { var response = await DeviceStream.SendCommand(new GetDeviceIDCommand(DeviceId)); DeviceId = Bytes.Read(response.DATA); return(DeviceId); }
protected override Stream GetStreamInternal(Uri uri, FileMode mode, FileAccess access) { string path = GetPath(uri); long offset; if (!String.IsNullOrEmpty(uri.Fragment) && Int64.TryParse(HttpUtility.UrlDecode(uri.Fragment.Substring(1)), out offset)) { DeviceStream stream; switch (mode) { case FileMode.Create: stream = new DeviceStream(path, FileMode.OpenOrCreate, access); stream.SetLength(offset); break; case FileMode.Truncate: stream = new DeviceStream(path, FileMode.Open, access); stream.SetLength(offset); break; default: stream = new DeviceStream(path, mode, access); break; } stream.Seek(offset, SeekOrigin.Begin); return(stream); } else { return(new DeviceStream(path, mode, access)); } }
/// <summary> /// Query the devices connected. Not ready until this finishes. /// </summary> private async Task QueryDevices() { await Task.Run(async() => { DeviceStream.Write(new byte[] { 0x20, 0x03 }); while (true) { byte[] readBuf = DeviceStream.Read(); if (readBuf[0] == 0x21 && readBuf[1] == 0x03) { // We received the device query reply byte[] device1 = new byte[6]; byte[] device2 = new byte[6]; Array.Copy(readBuf, 15, device1, 0, 6); Array.Copy(readBuf, 21, device2, 0, 6); string deviceStr1 = Util.ByteArrayToString(device1); string deviceStr2 = Util.ByteArrayToString(device2); Channel1 = NzxtLedDevice.FromDeviceIdentifier(deviceStr1); Channel2 = NzxtLedDevice.FromDeviceIdentifier(deviceStr2); break; } await Task.Delay(10).ConfigureAwait(false); } Ready = true; }); }
public async Task <byte[]> EnrollFingerprint(ulong employeeID) { await DeviceStream.SendCommand(new EnrollFingerprintCommand(DeviceId, employeeID, true)); await DeviceStream.SendCommand(new EnrollFingerprintCommand(DeviceId, employeeID, false)); return(await GetFingerprintTemplate(employeeID, 0)); }
static void verifyNabto1861(NabtoClient nabto, Session session) { DeviceStream stream = session.CreateStream("mystream.nabto.net"); byte[] buf = new byte[1]; int n = stream.Read(buf, 0, 1); Console.WriteLine("Read returned {0}", n); }
internal void Register(DeviceStream deviceStream) { lock (deviceStreams) { Log.Write("DeviceConnnection.Register<NabtoStream>()"); deviceStreams.Add(deviceStream); } }
public async Task SetDeviceID(ulong newDeviceId) { await DeviceStream.SendCommand(new SetDeviceIDCommand(DeviceId, newDeviceId)); if (DeviceId != 0) { DeviceId = newDeviceId; } }
internal void Unregister(DeviceStream deviceStream) { lock (deviceStreams) { Log.Write("DeviceConnnection.Unregister<NabtoStream>()"); deviceStreams.Remove(deviceStream); CheckForImplicitDispose(); } }
protected override void GivenThat() { base.GivenThat(); Stream = GenerateMock <IStream>(); // Make seek return a non-zero position Stream.Stub(stream => stream.Seek(0, 0, IntPtr.Zero)) .IgnoreArguments() .WhenCalled(invocation => Marshal.WriteInt64((IntPtr)invocation.Arguments[2], 1234)); DeviceStream = new DeviceStream(Stream); }
public async Task <List <ScheduledBell> > GetScheduledBells() { var response = await DeviceStream.SendCommand(new GetScheduledBellsCommand(DeviceId)); var bells = new List <ScheduledBell>(ScheduledBell.MAX_SCHEDULED_BELL_SLOT); var counter = 0; while (counter < response.DATA.Length) { bells.Add(new ScheduledBell(response.DATA, counter)); counter += ScheduledBell.RECORD_LENGTH; } return(bells); }
public async Task <byte[]> EnrollFingerprint(ulong employeeID, int verifyCount = 2) { if (verifyCount < 1) { throw new ArgumentException("verifyCount should be at least 1"); } var first = true; while (verifyCount-- > 0) { await DeviceStream.SendCommand(new EnrollFingerprintCommand(DeviceId, employeeID, first)); first = false; } return(await GetFingerprintTemplate(employeeID, 0)); }
public TimeSpan Read() { if (stream is null) { try { stream = hid.Open(); } catch (IOException ex) { throw new HardwareException(DeviceType.Hrm, ErrorCode.CommunicationError, "HRM is unplugged", "Plug the HRM back in"); } } byte[] buffer = new byte[1024]; try { int x = stream.Read(buffer, 0, 1024); } catch (IOException ex) { stream.Close(); stream = null; throw new HardwareException(DeviceType.Hrm, ErrorCode.CommunicationError, "HRM is unplugged", "Plug the HRM back in"); } catch (TimeoutException) { stream.Close(); stream = null; throw new HardwareException(DeviceType.Hrm, ErrorCode.Timeout, "Unable to detect heart rate", "Attach the sensor correctly"); } catch { stream.Close(); stream = null; throw new HardwareException(DeviceType.Hrm, ErrorCode.OtherError, "General error", "Plug the device back in"); } var b0 = buffer[3]; var b1 = buffer[4]; var b2 = buffer[5]; long ticks = b0 << 16 | b1 << 8 | b2; ticks *= 40; return(new TimeSpan(ticks)); }
/// <summary> /// Reads the specified file entry. /// </summary> public byte[] ReadFile(FileEntry file) { ushort nextCluster = file.FirstCluster; uint sizeLeft = file.FileSize; uint clusterSize = (uint)(PhysicalDevice.SectorSize * device.BootSector.SectorsPerCluster); uint sector; int offset = 0; byte[] data = new Byte[file.FileSize]; while (true) { // Calculate next sector sector = (uint)(device.RootDirectorySector + ((((nextCluster == 0) ? (0) : (nextCluster + 2))) * device.BootSector.SectorsPerCluster)); // Jump to data sector DeviceStream.Seek((device.Partition.RelativeSector + sector) * device.BootSector.BytesPerSector, SeekOrigin.Begin); // Read correct size if (sizeLeft < clusterSize) { DeviceStream.Read(data, offset, (int)sizeLeft); break; } else { DeviceStream.Read(data, offset, (int)clusterSize); offset += (int)clusterSize; sizeLeft -= clusterSize; } // Get next cluster nextCluster = device.Data[nextCluster]; if ((nextCluster == 0x0000) || (nextCluster == 0xFFF7)) { break; // Bad cluster pointer } if ((nextCluster >= 0xFFF8) && (nextCluster <= 0xFFFF)) { break; // End of cluster of file } } return(data); }
public async Task <ActionResult> ConnectSSH([FromBody] SshRequest request) { // return Bad request if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { // Create SSH streaming. This will run in separate thread, so that it won't block the main process DeviceStream deviceStream = new DeviceStream(); await Task.Factory.StartNew(() => deviceStream.StartAsync(request)); return(Ok("Connected")); } catch (Exception ex) { throw new ApiException(ex.Message); } }
public async Task <List <Record> > DownloadRecords(bool onlyNew = false) { var statistics = await GetDownloadInformation(); var recordAmount = onlyNew ? statistics.NewRecordAmount : statistics.AllRecordAmount; var records = new List <Record>((int)recordAmount); var isFirst = true; while (recordAmount > 0) { var response = await DeviceStream.SendCommand(new GetRecordsCommand(DeviceId, isFirst, onlyNew, recordAmount)); var counter = response.DATA[0]; recordAmount -= counter; for (var i = 0; i < counter; i++) { records.Add(new Record(response.DATA, 1 + i * Record.RECORD_LENGTH)); } isFirst = false; } return(records); }
public async Task <List <UserInfo> > GetEmployeesData() { var statistics = await GetDownloadInformation(); var userAmount = statistics.UserAmount; var users = new List <UserInfo>((int)userAmount); var isFirst = true; while (userAmount > 0) { var response = await DeviceStream.SendCommand(new GetStaffDataCommand(DeviceId, isFirst, userAmount)); var counter = response.DATA[0]; userAmount -= counter; for (var i = 0; i < counter; i++) { users.Add(new UserInfo(response.DATA, 1 + i * UserInfo.RECORD_LENGTH)); } isFirst = false; } return(users); }
public static void WriteBootLoaderToDisk(string DiskId, IDeviceProfile deviceProfile) { var chunkSize = 131072; DeviceStream ds = new DeviceStream(DiskId, FileAccess.ReadWrite); ds.Seek(0, SeekOrigin.Begin); byte[] bootloader = File.ReadAllBytes(deviceProfile.Bootloader()); var sectors = bootloader.Count() / chunkSize; DateTime startTime = DateTime.Now; using (BinaryReader br = new BinaryReader(new MemoryStream(bootloader))) for (int i = 0; i < sectors; i++) { var buff = br.ReadBytes(chunkSize); ds.Write(buff, 0, chunkSize); Logging.ShowProgress((UInt64)bootloader.Count(), startTime, (UInt64)((i + 1) * chunkSize), (UInt64)((i + 1) * chunkSize), false); } Logging.Log(""); ds.Dispose(); }
private void TransmitCommand() { ET232Command command = null; lock (_thread_interlock) { if (CommandQueue.Count > 0) { command = CommandQueue.First(); CommandQueue.RemoveAt(0); } } if (command != null) { if (command.IsWrite()) { if (command.Address == AddressByte.Pot_A) { lock (_thread_interlock) command.Data = Governor.RegulateA(command.Data); } if (command.Address == AddressByte.Pot_B) { lock (_thread_interlock) command.Data = Governor.RegulateB(command.Data); } } byte[] data = command.Format(); last_command = command; last_command_time = UnixTime.Current(); lock (_thread_interlock) { DeviceStream.Write(data, 0, data.Length); _state = State.command; } } }
private static void Refresh() { foreach (DiskInfo info in CreateDiskInfos(GetDisks())) { if (info.Model == "Linux UMS disk 0 USB Device" && info.Partitions > 1) // probably a bad way of filtering? { try { IEnumerable <PartitionInfo> partitions = CreatePartitionInfos(GetPartitions()) .Where((p) => info.Index == p.DiskIndex) .OrderBy((p) => p.Index); if (!partitions.Any()) { continue; // obv the NAND should have *some* partitions } PartitionInfo lastPartition = partitions.Last(); long length = (long)(lastPartition.Size + lastPartition.StartingOffset); // thx windows for ignoring the GPT backup AND reporting the size of the disk incorrectly... long missingLength = (0x747BFFE00 - 0x727800000) + 0x200; // (start of GPT backup - end of USER) + length of GPT backup length += missingLength; DeviceStream stream = new DeviceStream(info.PhysicalName, length); IStorage diskStorage = new CachedStorage(stream.AsStorage().AsReadOnly(), info.SectorSize * 100, 4, true); if (InsertNAND(diskStorage, true)) { CurrentDisk = info; break; } } catch (UnauthorizedAccessException) { MessageBox.Show("Cannot get direct access drive due to lack of permissions.\nReopen HACGUI as administrator to use the plugged in NAND."); } } } }
public async Task DeleteAllRecords() { await DeviceStream.SendCommand(new ClearRecordsCommand(DeviceId, ClearRecordsCommand.DELETE_ALL, 0)); }
public async Task ClearNewRecords(ulong amount) { await DeviceStream.SendCommand(new ClearRecordsCommand(DeviceId, ClearRecordsCommand.CLEAR_AMOUNT, amount)); }
public async Task ClearNewRecords() { await DeviceStream.SendCommand(new ClearRecordsCommand(DeviceId, ClearRecordsCommand.CLEAR_ALL, 0)); }
public async Task SetFaceTemplate(ulong employeeID, byte[] template) { await DeviceStream.SendCommand(new SetFaceTemplateCommand(DeviceId, employeeID, template)); }
public async Task SetAdvancedSettings(AdvancedSettings value) { await DeviceStream.SendCommand(new SetAdvancedSettingsCommand(DeviceId, value)); }
public async Task SetTimeZoneInfo(byte number, AnvizTimeZone value) { await DeviceStream.SendCommand(new SetTimeZoneInfoCommand(DeviceId, number, value)); }