Exemplo n.º 1
0
 /// <summary>
 /// Measures the vehicle supply voltage
 /// </summary>
 /// <returns>Voltage (mV)</returns>
 public int MeasureBatteryVoltage()
 {
     using (HeapInt hVoltage = new HeapInt())
     {
         lock (sync)
         {
             API.CheckResult(API.PTIoctl(deviceId, (int)IOCTL.READ_VBATT, IntPtr.Zero, (IntPtr)hVoltage));
         }
         return(hVoltage.Value);
     }
 }
Exemplo n.º 2
0
 /// <summary>
 /// Measures the delivered programming voltage
 /// </summary>
 /// <returns>Voltage (mV)</returns>
 public int MeasureProgrammingVoltage()
 {
     using (HeapInt hVoltage = new HeapInt())
     {
         lock (sync)
         {
             API.CheckResult(API.PTIoctl(deviceId, (int)IOCTL.READ_PROG_VOLTAGE, IntPtr.Zero, (IntPtr)hVoltage));
         }
         return(hVoltage.Value);
     }
 }
Exemplo n.º 3
0
 /// <summary>
 /// Opens a channel on the device using the specified parameters
 /// </summary>
 /// <param name="ProtocolID">Connection protocol</param>
 /// <param name="Baud">Connection baud-rate</param>
 /// <param name="ConnectFlags">Connection flags</param>
 /// <returns>A connected J2534Channel object</returns>
 public Channel GetChannel(Protocol ProtocolID, Baud Baud, ConnectFlag ConnectFlags, bool ChannelLevelSync = false)
 {
     using (HeapInt hChannelID = new HeapInt())
     {
         lock (sync)
         {
             API.CheckResult(API.PTConnect(deviceId, (int)ProtocolID, (int)ConnectFlags, (int)Baud, (IntPtr)hChannelID));
         }
         var NewChannel = new Channel(this, ProtocolID, Baud, ConnectFlags, hChannelID.Value, ChannelLevelSync ? new object() : sync);
         OnDisposing += NewChannel.Dispose;
         return(NewChannel);
     }
 }
Exemplo n.º 4
0
 /// <summary>
 /// Opens a J2534 device using this API
 /// </summary>
 /// <param name="DeviceName">The name of the device or blank to open the first available</param>
 /// <returns>Device object</returns>
 public Device GetDevice(string DeviceName = "")
 {
     using (var hDeviceID = new HeapInt())
         using (var hDeviceName = new HeapString(DeviceName))
         {
             lock (sync)
             {
                 CheckResult(PTOpen(String.IsNullOrWhiteSpace(DeviceName) ? IntPtr.Zero : (IntPtr)hDeviceName, (IntPtr)hDeviceID));
             }
             var device = new Device(this, hDeviceName.ToString(), hDeviceID.Value, sync);
             OnDisposing += device.Dispose;
             return(device);
         }
 }
Exemplo n.º 5
0
 /// <summary>
 /// Starts automated periodic transmission of a message
 /// </summary>
 /// <param name="PeriodicMessage">Periodic message object</param>
 /// <returns>Message index</returns>
 public int StartPeriodicMessage(PeriodicMessage PeriodicMessage)
 {
     using (HeapInt hMessageID = new HeapInt())
         using (HeapMessage hPeriodicMessage = new HeapMessage(ProtocolID, PeriodicMessage))
         {
             lock (sync)
             {
                 API.CheckResult(API.PTStartPeriodicMsg(channelId,
                                                        (IntPtr)hPeriodicMessage,
                                                        (IntPtr)hMessageID,
                                                        PeriodicMessage.Interval));
                 PeriodicMessage.MessageID = hMessageID.Value;
                 periodicMsgList.Add(PeriodicMessage);
             }
             return(periodicMsgList.IndexOf(PeriodicMessage));
         }
 }
Exemplo n.º 6
0
 /// <summary>
 /// Starts a message filter
 /// </summary>
 /// <param name="Filter">Message filter object</param>
 /// <returns>Filter index</returns>
 public int StartMsgFilter(MessageFilter Filter)
 {
     using (HeapInt hFilterID = new HeapInt())
         using (HeapMessage hMask = new HeapMessage(ProtocolID, Filter.TxFlags, Filter.Mask))
             using (HeapMessage hPattern = new HeapMessage(ProtocolID, Filter.TxFlags, Filter.Pattern))
                 using (HeapMessage hFlowControl = new HeapMessage(ProtocolID, Filter.TxFlags, Filter.FlowControl))
                 {
                     lock (sync)
                     {
                         API.CheckResult(API.PTStartMsgFilter(channelId,
                                                              (int)Filter.FilterType,
                                                              (IntPtr)hMask,
                                                              (IntPtr)hPattern,
                                                              Filter.FilterType == J2534.Filter.FLOW_CONTROL_FILTER ? (IntPtr)hFlowControl : IntPtr.Zero,
                                                              (IntPtr)hFilterID));
                         Filter.FilterId = hFilterID.Value;
                         filterList.Add(Filter);
                     }
                     return(filterList.IndexOf(Filter));
                 }
 }