Repository: DarthAffe/OBD.NET Branch: master Commit: 19f84465ed27 Files: 159 Total size: 145.1 KB Directory structure: gitextract_4a21douj/ ├── .gitattributes ├── .gitignore ├── LICENSE ├── OBD.NET/ │ ├── ConsoleClient/ │ │ ├── ConsoleClient.csproj │ │ └── Program.cs │ ├── OBD.NET/ │ │ ├── Commands/ │ │ │ ├── ATCommand.cs │ │ │ └── STCommand.cs │ │ ├── Communication/ │ │ │ ├── EnhancedSerialPort.cs │ │ │ ├── EventArgs/ │ │ │ │ └── DataReceivedEventArgs.cs │ │ │ ├── ISerialConnection.cs │ │ │ └── SerialConnection.cs │ │ ├── DataTypes/ │ │ │ ├── Count.cs │ │ │ ├── Degree.cs │ │ │ ├── DegreeCelsius.cs │ │ │ ├── GenericData.cs │ │ │ ├── GramPerSec.cs │ │ │ ├── Kilometre.cs │ │ │ ├── KilometrePerHour.cs │ │ │ ├── Kilopascal.cs │ │ │ ├── LitresPerHour.cs │ │ │ ├── Milliampere.cs │ │ │ ├── Minute.cs │ │ │ ├── NewtonMetre.cs │ │ │ ├── Pascal.cs │ │ │ ├── Percent.cs │ │ │ ├── Ratio.cs │ │ │ ├── RevolutionsPerMinute.cs │ │ │ ├── Second.cs │ │ │ └── Volt.cs │ │ ├── Devices/ │ │ │ ├── Command.cs │ │ │ ├── CommandResult.cs │ │ │ ├── ELM327.cs │ │ │ ├── STN1170.cs │ │ │ └── SerialDevice.cs │ │ ├── Enums/ │ │ │ └── Mode.cs │ │ ├── Events/ │ │ │ ├── EventArgs/ │ │ │ │ ├── DataReceivedEventArgs.cs │ │ │ │ └── RawDataReceivedEventArgs.cs │ │ │ ├── GenericDataEventManager.cs │ │ │ └── IDataEventManager.cs │ │ ├── Exceptions/ │ │ │ ├── SerialException.cs │ │ │ └── UnexpectedResultException.cs │ │ ├── Extensions/ │ │ │ └── HexExtension.cs │ │ ├── Logging/ │ │ │ ├── IOBDLogger.cs │ │ │ ├── OBDConsoleLogger.cs │ │ │ ├── OBDDebugLogger.cs │ │ │ └── OBDLogLevel.cs │ │ ├── OBD.NET.csproj │ │ ├── OBD.NET.csproj.DotSettings │ │ ├── OBDData/ │ │ │ ├── 00-1F/ │ │ │ │ ├── AuxiliaryInputStatus.cs │ │ │ │ ├── CalculatedEngineLoad.cs │ │ │ │ ├── CommandedSecondaryAirStatus.cs │ │ │ │ ├── EngineCoolantTemperature.cs │ │ │ │ ├── EngineRPM.cs │ │ │ │ ├── FuelPressure.cs │ │ │ │ ├── FuelSystemStatus.cs │ │ │ │ ├── IntakeAirTemperature.cs │ │ │ │ ├── IntakeManifoldAbsolutePressure.cs │ │ │ │ ├── LongTermFuelTrimBank1.cs │ │ │ │ ├── LongTermFuelTrimBank2.cs │ │ │ │ ├── MAFAirFlowRate.cs │ │ │ │ ├── OBDStandards.cs │ │ │ │ ├── OxygenSensor1FuelTrim.cs │ │ │ │ ├── OxygenSensor2FuelTrim.cs │ │ │ │ ├── OxygenSensor3FuelTrim.cs │ │ │ │ ├── OxygenSensor4FuelTrim.cs │ │ │ │ ├── OxygenSensor5FuelTrim.cs │ │ │ │ ├── OxygenSensor6FuelTrim.cs │ │ │ │ ├── OxygenSensor7FuelTrim.cs │ │ │ │ ├── OxygenSensor8FuelTrim.cs │ │ │ │ ├── OxygenSensorPresent.cs │ │ │ │ ├── OxygenSensorsPresent2.cs │ │ │ │ ├── PidsSupported01_20.cs │ │ │ │ ├── RunTimeSinceEngineStart.cs │ │ │ │ ├── ShortTermFuelTrimBank1.cs │ │ │ │ ├── ShortTermFuelTrimBank2.cs │ │ │ │ ├── ThrottlePosition.cs │ │ │ │ ├── TimingAdvance.cs │ │ │ │ └── VehicleSpeed.cs │ │ │ ├── 20-3F/ │ │ │ │ ├── AbsoluteBarometricPressure.cs │ │ │ │ ├── CatalystTemperatureBank1Sensor1.cs │ │ │ │ ├── CatalystTemperatureBank1Sensor2.cs │ │ │ │ ├── CatalystTemperatureBank2Sensor1.cs │ │ │ │ ├── CatalystTemperatureBank2Sensor2.cs │ │ │ │ ├── CommandedEGR.cs │ │ │ │ ├── CommandedEvaporativePurge.cs │ │ │ │ ├── DistanceTraveledSinceCodesCleared.cs │ │ │ │ ├── DistanceTraveledWithMILOn.cs │ │ │ │ ├── EGRError.cs │ │ │ │ ├── EvapSystemVaporPressure.cs │ │ │ │ ├── FuelRailGaugePressure.cs │ │ │ │ ├── FuelRailPressure.cs │ │ │ │ ├── FuelTankLevelInput.cs │ │ │ │ ├── OxygenSensor1FuelAir.cs │ │ │ │ ├── OxygenSensor1FuelAir2.cs │ │ │ │ ├── OxygenSensor2FuelAir.cs │ │ │ │ ├── OxygenSensor2FuelAir2.cs │ │ │ │ ├── OxygenSensor3FuelAir.cs │ │ │ │ ├── OxygenSensor3FuelAir2.cs │ │ │ │ ├── OxygenSensor4FuelAir.cs │ │ │ │ ├── OxygenSensor4FuelAir2.cs │ │ │ │ ├── OxygenSensor5FuelAir.cs │ │ │ │ ├── OxygenSensor5FuelAir2.cs │ │ │ │ ├── OxygenSensor6FuelAir.cs │ │ │ │ ├── OxygenSensor6FuelAir2.cs │ │ │ │ ├── OxygenSensor7FuelAir.cs │ │ │ │ ├── OxygenSensor7FuelAir2.cs │ │ │ │ ├── OxygenSensor8FuelAir.cs │ │ │ │ ├── OxygenSensor8FuelAir2.cs │ │ │ │ ├── PidsSupported21_40.cs │ │ │ │ └── WarmUpsSinceCodesCleared.cs │ │ │ ├── 40-5F/ │ │ │ │ ├── AbsoluteEvapSystemVaporPressure.cs │ │ │ │ ├── AbsoluteLoadValue.cs │ │ │ │ ├── AbsoluteThrottlePositionB.cs │ │ │ │ ├── AbsoluteThrottlePositionC.cs │ │ │ │ ├── AcceleratorPedalPositionD.cs │ │ │ │ ├── AcceleratorPedalPositionE.cs │ │ │ │ ├── AcceleratorPedalPositionF.cs │ │ │ │ ├── AmbientAirTemperature.cs │ │ │ │ ├── CommandedThrottleActuator.cs │ │ │ │ ├── ControlModuleVoltage.cs │ │ │ │ ├── EngineFuelRate.cs │ │ │ │ ├── EngineOilTemperature.cs │ │ │ │ ├── EthanolFuel.cs │ │ │ │ ├── EvapSystemVaporPressure2.cs │ │ │ │ ├── FuelAirCommandedEquivalenceRatio.cs │ │ │ │ ├── FuelInjectionTiming.cs │ │ │ │ ├── FuelRailAbsolutePressure.cs │ │ │ │ ├── FuelType.cs │ │ │ │ ├── HybridBatteryPackRemainingLife.cs │ │ │ │ ├── LongTermSecondaryOxygenSensorTrimBank13.cs │ │ │ │ ├── LongTermSecondaryOxygenSensorTrimBank24.cs │ │ │ │ ├── MaximumValueForAirFlowRate.cs │ │ │ │ ├── MaximumValues.cs │ │ │ │ ├── MonitorStatusThisDriveCycle.cs │ │ │ │ ├── PidsSupported41_60.cs │ │ │ │ ├── RelativeAcceleratorPedalPosition.cs │ │ │ │ ├── RelativeThrottlePosition.cs │ │ │ │ ├── ShortTermSecondaryOxygenSensorTrimBank13.cs │ │ │ │ ├── ShortTermSecondaryOxygenSensorTrimBank24.cs │ │ │ │ ├── TimeRunWithMILOn.cs │ │ │ │ └── TimeSinceTroubleCodesCleared.cs │ │ │ ├── 60-7F/ │ │ │ │ ├── ActualEnginePercentTorque.cs │ │ │ │ ├── DriversDemandEnginePercentTorque.cs │ │ │ │ ├── EngineCoolantTemperatureSensor.cs │ │ │ │ ├── EnginePercentTorqueData.cs │ │ │ │ ├── EngineReferenceTorque.cs │ │ │ │ ├── IntakeAirTemperatureSensor.cs │ │ │ │ └── PidsSupported61_80.cs │ │ │ ├── 80-9F/ │ │ │ │ └── PidsSupported81_A0.cs │ │ │ ├── A0-BF/ │ │ │ │ └── PidsSupportedA1_C0.cs │ │ │ ├── AbstractOBDData.cs │ │ │ ├── AbstractPidsSupported.cs │ │ │ ├── C0-DF/ │ │ │ │ └── PidsSupportedC1_E0.cs │ │ │ └── IOBDData.cs │ │ ├── Properties/ │ │ │ └── launchSettings.json │ │ └── Util/ │ │ └── AsyncManulResetEvent.cs │ ├── OBD.NET.Unix.sln │ └── OBD.NET.sln └── README.md ================================================ FILE CONTENTS ================================================ ================================================ FILE: .gitattributes ================================================ ############################################################################### # Set default behavior to automatically normalize line endings. ############################################################################### * text=auto ############################################################################### # Set default behavior for command prompt diff. # # This is need for earlier builds of msysgit that does not have it on by # default for csharp files. # Note: This is only used by command line ############################################################################### #*.cs diff=csharp ############################################################################### # Set the merge driver for project and solution files # # Merging from the command prompt will add diff markers to the files if there # are conflicts (Merging from VS is not affected by the settings below, in VS # the diff markers are never inserted). Diff markers may cause the following # file extensions to fail to load in VS. An alternative would be to treat # these files as binary and thus will always conflict and require user # intervention with every merge. To do so, just uncomment the entries below ############################################################################### #*.sln merge=binary #*.csproj merge=binary #*.vbproj merge=binary #*.vcxproj merge=binary #*.vcproj merge=binary #*.dbproj merge=binary #*.fsproj merge=binary #*.lsproj merge=binary #*.wixproj merge=binary #*.modelproj merge=binary #*.sqlproj merge=binary #*.wwaproj merge=binary ############################################################################### # behavior for image files # # image files are treated as binary by default. ############################################################################### #*.jpg binary #*.png binary #*.gif binary ############################################################################### # diff behavior for common document formats # # Convert binary document formats to text before diffing them. This feature # is only available from the command line. Turn it on by uncommenting the # entries below. ############################################################################### #*.doc diff=astextplain #*.DOC diff=astextplain #*.docx diff=astextplain #*.DOCX diff=astextplain #*.dot diff=astextplain #*.DOT diff=astextplain #*.pdf diff=astextplain #*.PDF diff=astextplain #*.rtf diff=astextplain #*.RTF diff=astextplain ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ bld/ [Bb]in/ [Oo]bj/ # Visual Studio 2015 cache/options directory .vs/ # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # DNX project.lock.json artifacts/ *_i.c *_p.c *_i.h *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile # Visual Studio profiler *.psess *.vsp *.vspx *.sap # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # JustCode is a .NET coding add-in .JustCode # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # TODO: Comment the next line if you want to checkin your web deploy settings # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/packages/* # except build/, which is used as an MSBuild target. !**/packages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/packages/repositories.config # NuGet v3's project.json files produces more ignoreable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Microsoft Azure ApplicationInsights config file ApplicationInsights.config # Windows Store app package directory AppPackages/ BundleArtifacts/ # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ # Others ClientBin/ ~$* *~ *.dbmdl *.dbproj.schemaview *.pfx *.publishsettings node_modules/ orleans.codegen.cs # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm # SQL Server files *.mdf *.ldf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt # Visual Studio LightSwitch build output **/*.HTMLClient/GeneratedArtifacts **/*.DesktopClient/GeneratedArtifacts **/*.DesktopClient/ModelManifest.xml **/*.Server/GeneratedArtifacts **/*.Server/ModelManifest.xml _Pvt_Extensions # Paket dependency manager .paket/paket.exe # FAKE - F# Make .fake/ .DS_Store OBD.NET/.idea ================================================ FILE: LICENSE ================================================ GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Lesser General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. {description} Copyright (C) {year} {fullname} This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. {signature of Ty Coon}, 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. ================================================ FILE: OBD.NET/ConsoleClient/ConsoleClient.csproj ================================================  Exe net4.8 enable latest ================================================ FILE: OBD.NET/ConsoleClient/Program.cs ================================================ using System; using System.Threading; using System.Threading.Tasks; using OBD.NET.Communication; using OBD.NET.Devices; using OBD.NET.Extensions; using OBD.NET.Logging; using OBD.NET.OBDData; namespace ConsoleClient; public class Program { public static void Main(string[] args) { //if (args.Length < 1) //{ // Console.WriteLine("Parameter ComPort needed."); // IEnumerable availablePorts = SerialConnection.GetAvailablePorts(); // Console.WriteLine("\nAvailable ports:"); // foreach (string port in availablePorts) // Console.WriteLine(port); // return; //} string comPort = args[0]; using SerialConnection connection = new(comPort); using ELM327 dev = new(connection, new OBDConsoleLogger(OBDLogLevel.Debug)); dev.SubscribeDataReceived((_, data) => Console.WriteLine("EngineRPM: " + data.Data.Rpm)); dev.SubscribeDataReceived((_, data) => Console.WriteLine("VehicleSpeed: " + data.Data)); dev.SubscribeDataReceived((_, data) => Console.WriteLine($"PID {data.Data.PID.ToHexString()}: {data.Data}")); dev.Initialize(); dev.RequestData(); for (int i = 0; i < 5; i++) { dev.RequestData(); dev.RequestData(); Thread.Sleep(1000); } Console.ReadLine(); //Async example // MainAsync(comPort).Wait(); //Console.ReadLine(); } /// /// Async example using new RequestDataAsync /// /// The COM port. /// public static async Task MainAsync(string comPort) { using SerialConnection connection = new(comPort); using ELM327 dev = new(connection, new OBDConsoleLogger(OBDLogLevel.Debug)); await dev.InitializeAsync(); EngineRPM? engineRpm = await dev.RequestDataAsync(); Console.WriteLine("Data: " + (engineRpm?.Rpm.ToString() ?? "-")); engineRpm = await dev.RequestDataAsync(); Console.WriteLine("Data: " + (engineRpm?.Rpm.ToString() ?? "-")); VehicleSpeed? vehicleSpeed = await dev.RequestDataAsync(); Console.WriteLine("Data: " + (vehicleSpeed?.Speed.ToString() ?? "-")); engineRpm = await dev.RequestDataAsync(); Console.WriteLine("Data: " + (engineRpm?.Rpm.ToString() ?? "-")); } } ================================================ FILE: OBD.NET/OBD.NET/Commands/ATCommand.cs ================================================ namespace OBD.NET.Commands; public class ATCommand { #region Commands // ReSharper disable InconsistentNaming //TODO DarthAffe 26.06.2016: Implement all commands public static readonly ATCommand RepeatLastCommand = new("\r"); public static readonly ATCommand ResetDevice = new("ATZ"); public static readonly ATCommand ReadVoltage = new("ATRV"); public static readonly ATCommand EchoOn = new("ATE1", "^OK$"); public static readonly ATCommand EchoOff = new("ATE0", "^OK$"); public static readonly ATCommand HeadersOn = new("ATH1", "^OK$"); public static readonly ATCommand HeadersOff = new("ATH0", "^OK$"); public static readonly ATCommand PrintSpacesOn = new("ATS1", "^OK$"); public static readonly ATCommand PrintSpacesOff = new("ATS0", "^OK$"); public static readonly ATCommand LinefeedsOn = new("ATL1", "^OK$"); public static readonly ATCommand LinefeedsOff = new("ATL0", "^OK$"); public static readonly ATCommand SetProtocolAuto = new("ATSP0", "^OK$"); public static readonly ATCommand PrintVersion = new("ATI", "^ELM327.*"); public static readonly ATCommand CloseProtocol = new("ATPC"); // ReSharper restore InconsistentNaming #endregion #region Properties & Fields public string Command { get; } public string? ExpectedResult { get; } #endregion #region Constructors private ATCommand(string command, string? expectedResult = null) { this.Command = command; this.ExpectedResult = expectedResult; } #endregion #region Methods public override string ToString() => Command; #endregion #region Operators public static implicit operator string(ATCommand command) => command.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/Commands/STCommand.cs ================================================ namespace OBD.NET.Commands; public class STCommand { #region Values // ReSharper disable InconsistentNaming //TODO DarthAffe 19.03.2017: Implement all commands internal static readonly STCommand AddPassFilter = new("STFAP"); internal static readonly STCommand AddBlockFilter = new("STFAB"); internal static readonly STCommand AddFlowControlFilter = new("STFAFC"); internal static readonly STCommand ClearPassFilters = new("STFCP"); internal static readonly STCommand ClearBlockFilters = new("STFCB"); internal static readonly STCommand ClearFlowControlFilters = new("STFCFC"); internal static readonly STCommand Monitor = new("STM"); internal static readonly STCommand MonitorAll = new("STMA"); // ReSharper restore InconsistentNaming #endregion #region Properties & Fields public string Command { get; } #endregion #region Constructors protected STCommand(string command) { this.Command = command; } #endregion #region Methods public override string ToString() => Command; #endregion #region Operators public static implicit operator string(STCommand command) => command.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/Communication/EnhancedSerialPort.cs ================================================ #if !NET5_0_OR_GREATER // Copyright 2013 Antanas Veiverys www.veiverys.com // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. using System; using System.ComponentModel; using System.IO; using System.IO.Ports; using System.Reflection; using System.Runtime.InteropServices; using System.Threading; // Source: http://antanas.veiverys.com/mono-serialport-datareceived-event-workaround-using-a-derived-class/ namespace OBD.NET.Communication; [DesignerCategory("Code")] public class EnhancedSerialPort : SerialPort { #region Properties & Fields // private member access via reflection private int _fd; private FieldInfo? _disposedFieldInfo; private object? _dataReceived; private Thread? _thread; #endregion #region DLLImports [DllImport("MonoPosixHelper", SetLastError = true)] private static extern bool poll_serial(int fd, out int error, int timeout); [DllImport("libc")] private static extern IntPtr strerror(int errnum); #endregion #region Constructors public EnhancedSerialPort() : base() { } public EnhancedSerialPort(IContainer container) : base(container) { } public EnhancedSerialPort(string portName) : base(portName) { } public EnhancedSerialPort(string portName, int baudRate) : base(portName, baudRate) { } public EnhancedSerialPort(string portName, int baudRate, Parity parity) : base(portName, baudRate, parity) { } public EnhancedSerialPort(string portName, int baudRate, Parity parity, int dataBits) : base(portName, baudRate, parity, dataBits) { } public EnhancedSerialPort(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits) : base(portName, baudRate, parity, dataBits, stopBits) { } #endregion #region Methods public new void Open() { base.Open(); if (!IsWindows) { FieldInfo? fieldInfo = BaseStream.GetType().GetField("fd", BindingFlags.Instance | BindingFlags.NonPublic); if (fieldInfo == null) throw new NotSupportedException("Unable to initialize SerialPort - 'fd'-field is missing."); _fd = (int)fieldInfo.GetValue(BaseStream)!; _disposedFieldInfo = BaseStream.GetType().GetField("disposed", BindingFlags.Instance | BindingFlags.NonPublic) ?? throw new NotSupportedException("Unable to initialize SerialPort - 'disposed'-field is missing."); fieldInfo = typeof(SerialPort).GetField("data_received", BindingFlags.Instance | BindingFlags.NonPublic); if (fieldInfo == null) throw new NotSupportedException("Unable to initialize SerialPort - 'data_received'-field is missing."); _dataReceived = fieldInfo.GetValue(this); _thread = new Thread(EventThreadFunction); _thread.Start(); } } private static bool IsWindows { get { PlatformID id = Environment.OSVersion.Platform; return (id == PlatformID.Win32Windows) || (id == PlatformID.Win32NT); // WinCE not supported } } private void EventThreadFunction() { do { try { Stream? stream = BaseStream; if (stream == null) return; if (Poll(stream, ReadTimeout)) OnDataReceived(null!); } catch { return; } } while (IsOpen); } private void OnDataReceived(SerialDataReceivedEventArgs args) { SerialDataReceivedEventHandler? handler = Events[_dataReceived!] as SerialDataReceivedEventHandler; handler?.Invoke(this, args); } private bool Poll(Stream stream, int timeout) { CheckDisposed(stream); if (IsOpen == false) throw new Exception("port is closed"); bool pollResult = poll_serial(_fd, out int error, ReadTimeout); if (error == -1) ThrowIOException(); return pollResult; } private static void ThrowIOException() { int errnum = Marshal.GetLastWin32Error(); string errorMessage = Marshal.PtrToStringAnsi(strerror(errnum))!; throw new IOException(errorMessage); } private void CheckDisposed(Stream stream) { bool disposed = (bool)_disposedFieldInfo!.GetValue(stream)!; if (disposed) throw new ObjectDisposedException(stream.GetType().FullName); } #endregion } #endif ================================================ FILE: OBD.NET/OBD.NET/Communication/EventArgs/DataReceivedEventArgs.cs ================================================ namespace OBD.NET.Communication; /// /// Event args for receiving serial data /// public class DataReceivedEventArgs : System.EventArgs { #region Properties & Fields /// /// Count of valid data bytes in the buffer /// public int Count { get; } /// /// Data buffer holding the bytes /// public byte[] Data { get; } #endregion #region Constructors /// /// Initializes a new instance of the class. /// /// The count. /// The data. public DataReceivedEventArgs(int count, byte[] data) { this.Count = count; this.Data = data; } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Communication/ISerialConnection.cs ================================================ using System; using System.Threading.Tasks; namespace OBD.NET.Communication; /// /// Serial connection interface /// /// public interface ISerialConnection : IDisposable { /// /// Gets a value indicating whether this instance is open. /// /// /// true if this instance is open; otherwise, false. /// bool IsOpen { get; } /// /// Gets a value indicating whether this instance uses asynchronous IO /// /// /// Has to be set to true if asynchronous IO is supported. /// If true async methods have to be implemented /// bool IsAsync { get; } /// /// Occurs when a full line was received /// event EventHandler DataReceived; /// /// Connects the serial port. /// void Connect(); /// /// Connects the serial port asynchronous /// /// Task ConnectAsync(); /// /// Writes the specified data to the serial connection /// /// The data. void Write(byte[] data); /// /// Writes the specified data to the serial connection asynchronous /// /// The data. Task WriteAsync(byte[] data); } ================================================ FILE: OBD.NET/OBD.NET/Communication/SerialConnection.cs ================================================ #if NET5_0_OR_GREATER using System; using System.Collections.Generic; using System.IO.Ports; using System.Threading.Tasks; namespace OBD.NET.Communication; public class SerialConnection : ISerialConnection { #region Properties & Fields private readonly SerialPort _serialPort; public bool IsOpen => _serialPort.IsOpen; public bool IsAsync => false; private readonly byte[] _readBuffer = new byte[1024]; #endregion #region Events public event EventHandler? DataReceived = delegate { }; #endregion #region Constructors public SerialConnection(string port, int baudRate = 38400, Parity parity = Parity.None, StopBits stopBits = StopBits.One, Handshake handshake = Handshake.None, int timeout = 5000) { _serialPort = new SerialPort(port, baudRate, parity) { StopBits = stopBits, Handshake = handshake, ReadTimeout = timeout, WriteTimeout = timeout }; _serialPort.DataReceived += SerialPortOnDataReceived; } #endregion #region Methods public static IEnumerable GetAvailablePorts() => SerialPort.GetPortNames(); public void Connect() => _serialPort.Open(); private void SerialPortOnDataReceived(object sender, SerialDataReceivedEventArgs serialDataReceivedEventArgs) { int count = _serialPort.Read(_readBuffer, 0, _serialPort.BytesToRead); DataReceived?.Invoke(this, new DataReceivedEventArgs(count, _readBuffer)); } public void Dispose() => _serialPort.Dispose(); public async Task ConnectAsync() { await Task.Yield(); Connect(); } public async Task WriteAsync(byte[] data) { await Task.Yield(); Write(data); } public void Write(byte[] data) => _serialPort.Write(data, 0, data.Length); #endregion } #else using System; using System.Collections.Generic; using System.IO.Ports; using System.Threading.Tasks; namespace OBD.NET.Communication; public class SerialConnection : ISerialConnection { #region Properties & Fields private readonly EnhancedSerialPort _serialPort; public bool IsOpen => _serialPort?.IsOpen ?? false; public bool IsAsync => false; private readonly byte[] _readBuffer = new byte[1024]; #endregion #region Events public event EventHandler? DataReceived; #endregion #region Constructors public SerialConnection(string port, int baudRate = 38400, Parity parity = Parity.None, StopBits stopBits = StopBits.One, Handshake handshake = Handshake.None, int timeout = 5000) { _serialPort = new EnhancedSerialPort(port, baudRate, parity) { StopBits = stopBits, Handshake = handshake, ReadTimeout = timeout, WriteTimeout = timeout }; _serialPort.DataReceived += SerialPortOnDataReceived; } #endregion #region Methods public static IEnumerable GetAvailablePorts() => SerialPort.GetPortNames(); public void Connect() => _serialPort.Open(); private void SerialPortOnDataReceived(object sender, SerialDataReceivedEventArgs serialDataReceivedEventArgs) { int count = _serialPort.Read(_readBuffer, 0, _serialPort.BytesToRead); DataReceived?.Invoke(this, new DataReceivedEventArgs(count, _readBuffer)); } public void Dispose() => _serialPort.Dispose(); public async Task ConnectAsync() { await Task.Yield(); Connect(); } public async Task WriteAsync(byte[] data) { await Task.Yield(); Write(data); } public void Write(byte[] data) => _serialPort.Write(data, 0, data.Length); #endregion } #endif ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Count.cs ================================================ namespace OBD.NET.DataTypes; public class Count : GenericData { #region Properties & Fields protected override string? Unit => null; #endregion #region Constructors public Count(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Count(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Degree.cs ================================================ namespace OBD.NET.DataTypes; public class Degree : GenericData { #region Properties & Fields protected override string Unit => "°"; #endregion #region Constructors public Degree(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Degree(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion #region Methods public override string ToString() => (IsFloatingPointValue ? Value.ToString("0.00") : Value.ToString()) + Unit; #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/DegreeCelsius.cs ================================================ namespace OBD.NET.DataTypes; public class DegreeCelsius : GenericData { #region Properties & Fields protected override string Unit => "°C"; #endregion #region Constructors public DegreeCelsius(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public DegreeCelsius(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion #region Methods public override string ToString() => (IsFloatingPointValue ? Value.ToString("0.00") : Value.ToString()) + Unit; #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/GenericData.cs ================================================ using System; namespace OBD.NET.DataTypes; public abstract class GenericData { #region Properties & Fields public double Value { get; } public double MinValue { get; } public double MaxValue { get; } public bool IsFloatingPointValue { get; } protected abstract string? Unit { get; } #endregion #region Constructors protected GenericData(double value, double minValue, double maxValue) { this.Value = value; this.MinValue = minValue; this.MaxValue = maxValue; IsFloatingPointValue = true; } protected GenericData(int value, int minValue, int maxValue) { this.Value = value; this.MinValue = minValue; this.MaxValue = maxValue; IsFloatingPointValue = false; } #endregion #region Operators public static implicit operator double(GenericData p) => p.Value; public static implicit operator int(GenericData p) => (int)Math.Round(p.Value); #endregion #region Methods public override string ToString() => (IsFloatingPointValue ? Value.ToString("0.00") : Value.ToString()) + (Unit == null ? string.Empty : (" " + Unit)); #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/GramPerSec.cs ================================================ namespace OBD.NET.DataTypes; public class GramPerSec : GenericData { #region Properties & Fields protected override string Unit => "g/s"; #endregion #region Constructors public GramPerSec(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public GramPerSec(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Kilometre.cs ================================================ namespace OBD.NET.DataTypes; public class Kilometre : GenericData { #region Properties & Fields protected override string Unit => "km"; #endregion #region Constructors public Kilometre(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Kilometre(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/KilometrePerHour.cs ================================================ namespace OBD.NET.DataTypes; public class KilometrePerHour : GenericData { #region Properties & Fields protected override string Unit => "km/h"; #endregion #region Constructors public KilometrePerHour(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public KilometrePerHour(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Kilopascal.cs ================================================ namespace OBD.NET.DataTypes; public class Kilopascal : GenericData { #region Properties & Fields protected override string Unit => "kPa"; #endregion #region Constructors public Kilopascal(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Kilopascal(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion #region Operators public static explicit operator Pascal(Kilopascal pa) => new(pa.Value / 1000.0, pa.MinValue / 1000.0, pa.MaxValue / 1000.0); #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/LitresPerHour.cs ================================================ namespace OBD.NET.DataTypes; public class LitresPerHour : GenericData { #region Properties & Fields protected override string Unit => "l/h"; #endregion #region Constructors public LitresPerHour(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public LitresPerHour(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Milliampere.cs ================================================ namespace OBD.NET.DataTypes; public class Milliampere : GenericData { #region Properties & Fields protected override string Unit => "mA"; #endregion #region Constructors public Milliampere(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Milliampere(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Minute.cs ================================================ namespace OBD.NET.DataTypes; public class Minute : GenericData { #region Properties & Fields protected override string Unit => "min"; #endregion #region Constructors public Minute(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Minute(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion #region Operators public static explicit operator Second(Minute m) => m.IsFloatingPointValue ? new Second(m.Value * 60, m.MinValue * 60, m.MaxValue * 60) : new Second((int)(m.Value * 60), (int)(m.MinValue * 60), (int)(m.MaxValue * 60)); #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/NewtonMetre.cs ================================================ namespace OBD.NET.DataTypes; public class NewtonMetre : GenericData { #region Properties & Fields protected override string Unit => "N"; #endregion #region Constructors public NewtonMetre(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public NewtonMetre(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Pascal.cs ================================================ namespace OBD.NET.DataTypes; public class Pascal : GenericData { #region Properties & Fields protected override string Unit => "Pa"; #endregion #region Constructors public Pascal(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Pascal(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion #region Operators public static explicit operator Kilopascal(Pascal pa) => pa.IsFloatingPointValue ? new Kilopascal(pa.Value * 1000, pa.MinValue * 1000, pa.MaxValue * 1000) : new Kilopascal((int)(pa.Value * 1000), (int)(pa.MinValue * 1000), (int)(pa.MaxValue * 1000)); #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Percent.cs ================================================ namespace OBD.NET.DataTypes; public class Percent : GenericData { #region Properties & Fields protected override string Unit => "%"; #endregion #region Constructors public Percent(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Percent(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Ratio.cs ================================================ namespace OBD.NET.DataTypes; public class Ratio : GenericData { #region Properties & Fields protected override string? Unit => null; #endregion #region Constructors public Ratio(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Ratio(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/RevolutionsPerMinute.cs ================================================ namespace OBD.NET.DataTypes; public class RevolutionsPerMinute : GenericData { #region Properties & Fields protected override string Unit => "rpm"; #endregion #region Constructors public RevolutionsPerMinute(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public RevolutionsPerMinute(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Second.cs ================================================ namespace OBD.NET.DataTypes; public class Second : GenericData { #region Properties & Fields protected override string Unit => "s"; #endregion #region Constructors public Second(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Second(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion #region Operators public static explicit operator Minute(Second s) => new(s.Value / 60.0, s.MinValue / 60.0, s.MaxValue / 60.0); #endregion } ================================================ FILE: OBD.NET/OBD.NET/DataTypes/Volt.cs ================================================ namespace OBD.NET.DataTypes; public class Volt : GenericData { #region Properties & Fields protected override string Unit => "V"; #endregion #region Constructors public Volt(double value, double minValue, double maxValue) : base(value, minValue, maxValue) { } public Volt(int value, int minValue, int maxValue) : base(value, minValue, maxValue) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Devices/Command.cs ================================================ namespace OBD.NET.Devices; /// /// Class used for queued command /// public class QueuedCommand { #region Properties & Fields public string CommandText { get; } public CommandResult CommandResult { get; } #endregion #region Constructors public QueuedCommand(string commandText) { this.CommandText = commandText; CommandResult = new CommandResult(); } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Devices/CommandResult.cs ================================================ using OBD.NET.Util; namespace OBD.NET.Devices; public class CommandResult { #region Properties & Fields public object? Result { get; set; } public AsyncManualResetEvent WaitHandle { get; } #endregion #region Constructors public CommandResult() { WaitHandle = new AsyncManualResetEvent(); } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Devices/ELM327.cs ================================================ using System; using System.Collections.Generic; using System.Linq; using System.Reflection; using System.Threading.Tasks; using OBD.NET.Commands; using OBD.NET.Communication; using OBD.NET.Enums; using OBD.NET.Events; using OBD.NET.Extensions; using OBD.NET.Logging; using OBD.NET.OBDData; namespace OBD.NET.Devices; public class ELM327 : SerialDevice { #region Properties & Fields protected readonly Dictionary DataReceivedEventHandlers = new(); protected static Dictionary PidCache { get; } = new(); protected static Dictionary DataTypeCache { get; } = new(); protected Mode Mode { get; set; } = Mode.ShowCurrentData; //TODO DarthAffe 26.06.2016: Implement different modes protected string MessageChunk { get; set; } = string.Empty; #endregion #region Events public delegate void DataReceivedEventHandler(object sender, DataReceivedEventArgs args) where T : IOBDData; public delegate void RawDataReceivedEventHandler(object sender, RawDataReceivedEventArgs args); public event RawDataReceivedEventHandler? RawDataReceived; #endregion #region Constructors public ELM327(ISerialConnection connection, IOBDLogger? logger = null) : base(connection, logger: logger) { } #endregion #region Methods public override async Task InitializeAsync() { await base.InitializeAsync(); InternalInitialize(); } public override void Initialize() { base.Initialize(); InternalInitialize(); } private void InternalInitialize() { Logger?.WriteLine("Initializing ...", OBDLogLevel.Debug); try { Logger?.WriteLine("Resetting Device ...", OBDLogLevel.Debug); SendCommand(ATCommand.ResetDevice); Logger?.WriteLine("Turning Echo Off ...", OBDLogLevel.Debug); SendCommand(ATCommand.EchoOff); Logger?.WriteLine("Turning Linefeeds Off ...", OBDLogLevel.Debug); SendCommand(ATCommand.LinefeedsOff); Logger?.WriteLine("Turning Headers Off ...", OBDLogLevel.Debug); SendCommand(ATCommand.HeadersOff); Logger?.WriteLine("Turning Spaced Off ...", OBDLogLevel.Debug); SendCommand(ATCommand.PrintSpacesOff); Logger?.WriteLine("Setting the Protocol to 'Auto' ...", OBDLogLevel.Debug); SendCommand(ATCommand.SetProtocolAuto); WaitQueue(); } // DarthAffe 21.02.2017: This seems to happen sometimes, i don't know why - just retry. catch { Logger?.WriteLine("Failed to initialize the device!", OBDLogLevel.Error); throw; } } /// /// Sends the AT command. /// /// The command. public virtual void SendCommand(ATCommand command) => SendCommand(command.Command); /// /// Requests the data and calls the handler /// /// public virtual void RequestData() where T : class, IOBDData, new() { Logger?.WriteLine("Requesting Type " + typeof(T).Name + " ...", OBDLogLevel.Debug); byte pid = ResolvePid(); RequestData(pid); } /// /// Request data based on a pid /// /// The pid of the requested data public virtual void RequestData(byte pid) { Logger?.WriteLine("Requesting PID " + pid.ToString("X2") + " ...", OBDLogLevel.Debug); SendCommand(((byte)Mode).ToString("X2") + pid.ToString("X2")); } /// /// Requests the data asynchronous and return the data when available /// /// /// public virtual async Task RequestDataAsync() where T : class, IOBDData, new() { Logger?.WriteLine("Requesting Type " + typeof(T).Name + " ...", OBDLogLevel.Debug); byte pid = ResolvePid(); return await RequestDataAsync(pid) as T; } /// /// Requests the data asynchronous and return the data when available /// /// public virtual async Task RequestDataAsync(Type type) { Logger?.WriteLine("Requesting Type " + type.Name + " ...", OBDLogLevel.Debug); byte pid = ResolvePid(type); return await RequestDataAsync(pid) as IOBDData; } /// /// Request data based on a pid /// /// The pid of the requested data public virtual async Task RequestDataAsync(byte pid) { Logger?.WriteLine("Requesting PID " + pid.ToString("X2") + " ...", OBDLogLevel.Debug); CommandResult result = SendCommand(((byte)Mode).ToString("X2") + pid.ToString("X2")); await result.WaitHandle.WaitAsync(); return result.Result; } protected override object? ProcessMessage(string message) { DateTime timestamp = DateTime.Now; RawDataReceived?.Invoke(this, new RawDataReceivedEventArgs(message, timestamp)); if (message.Length > 4) { // DarthAffe 15.08.2020: Splitted messages are prefixed with 0: (first chunk) and 1: (second chunk) // DarthAffe 15.08.2020: They also seem to be always preceded by a '009'-message, but since that's to short to be processed it should be safe to ignore. // DarthAffe 15.08.2020: Since that behavior isn't really documented (at least I wasn't able to find it) that's all trial and error and might not work for all pids with long results. if (message[1] == ':') { if (message[0] == '0') MessageChunk = message.Substring(2, message.Length - 2); else if (message[0] == '1') { string fullMessage = MessageChunk + message.Substring(2, message.Length - 2); MessageChunk = string.Empty; return ProcessMessage(fullMessage); } } else if (message[0] == '4') { byte mode = (byte)message[1].GetHexVal(); if (mode == (byte)Mode) { byte pid = (byte)message.Substring(2, 2).GetHexVal(); if (DataTypeCache.TryGetValue(pid, out Type? dataType)) { IOBDData obdData = (IOBDData)Activator.CreateInstance(dataType)!; obdData.Load(message.Substring(4, message.Length - 4)); if (DataReceivedEventHandlers.TryGetValue(dataType, out IDataEventManager? dataEventManager)) dataEventManager.RaiseEvent(this, obdData, timestamp); if (DataReceivedEventHandlers.TryGetValue(typeof(IOBDData), out IDataEventManager? genericDataEventManager)) genericDataEventManager.RaiseEvent(this, obdData, timestamp); return obdData; } } } } return null; } protected virtual byte ResolvePid() where T : class, IOBDData, new() => ResolvePid(typeof(T)); protected virtual byte ResolvePid(Type type) { if (!PidCache.TryGetValue(type, out byte pid)) pid = AddToPidCache(type); return pid; } public virtual byte AddToPidCache() where T : class, IOBDData, new() => AddToPidCache(typeof(T)); protected virtual byte AddToPidCache(Type obdDataType) { if (Activator.CreateInstance(obdDataType) is not IOBDData data) throw new ArgumentException("Has to implement IOBDData", nameof(obdDataType)); byte pid = data.PID; PidCache.Add(obdDataType, pid); DataTypeCache.Add(pid, obdDataType); return pid; } /// /// YOU SHOULDN'T NEED THIS METHOD! /// /// You should only use this method if you're requesting data by pid instead of the -method. /// /// Initializes the PID-Cache with all IOBDData-Types contained in OBD.NET. /// You can add additional ones with . /// public virtual void InitializePidCache() { TypeInfo iobdDataInfo = typeof(IOBDData).GetTypeInfo(); foreach (TypeInfo obdDataType in iobdDataInfo.Assembly.DefinedTypes.Where(t => t.IsClass && !t.IsAbstract && iobdDataInfo.IsAssignableFrom(t))) AddToPidCache(obdDataType.AsType()); } public override void Dispose() => Dispose(true); public void Dispose(bool sendCloseProtocol) { try { if (sendCloseProtocol) SendCommand(ATCommand.CloseProtocol); } catch { /* Well at least we tried ... */ } DataReceivedEventHandlers.Clear(); base.Dispose(); } public void SubscribeDataReceived(DataReceivedEventHandler eventHandler) where T : IOBDData { if (!DataReceivedEventHandlers.TryGetValue(typeof(T), out IDataEventManager? eventManager)) DataReceivedEventHandlers.Add(typeof(T), (eventManager = new GenericDataEventManager())); ((GenericDataEventManager)eventManager).DataReceived += eventHandler; } public void UnsubscribeDataReceived(DataReceivedEventHandler eventHandler) where T : IOBDData { if (DataReceivedEventHandlers.TryGetValue(typeof(T), out IDataEventManager? eventManager)) ((GenericDataEventManager)eventManager).DataReceived -= eventHandler; } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Devices/STN1170.cs ================================================ using OBD.NET.Commands; using OBD.NET.Communication; using OBD.NET.Logging; namespace OBD.NET.Devices; public class STN1170 : ELM327 // Fully compatible device { #region Constructors public STN1170(ISerialConnection connection, IOBDLogger? logger = null) : base(connection, logger) { } #endregion #region Methods /// /// Sends the ST command. /// /// The command. public virtual void SendCommand(STCommand command) => SendCommand(command.Command); #endregion } ================================================ FILE: OBD.NET/OBD.NET/Devices/SerialDevice.cs ================================================ using System; using System.Collections.Concurrent; using System.Text; using System.Threading; using System.Threading.Tasks; using OBD.NET.Communication; using OBD.NET.Exceptions; using OBD.NET.Logging; namespace OBD.NET.Devices; /// /// Base class used for communicating with the device /// public abstract class SerialDevice : IDisposable { #region Properties & Fields private readonly BlockingCollection _commandQueue = new(); private readonly StringBuilder _lineBuffer = new(); private readonly AutoResetEvent _commandFinishedEvent = new(false); private Task? _commandWorkerTask; private CancellationTokenSource? _commandCancellationToken; private volatile int _queueSize = 0; private readonly ManualResetEvent _queueEmptyEvent = new(true); public int QueueSize => _queueSize; protected QueuedCommand? CurrentCommand; protected IOBDLogger? Logger { get; } protected ISerialConnection Connection { get; } protected char Terminator { get; set; } #endregion #region Constructors /// /// Initializes a new instance of the class. /// /// connection. /// terminator used for terminating the command message /// logger instance protected SerialDevice(ISerialConnection connection, char terminator = '\r', IOBDLogger? logger = null) { this.Connection = connection; this.Terminator = terminator; this.Logger = logger; connection.DataReceived += OnDataReceived; } #endregion #region Methods /// /// Initializes the device /// public virtual void Initialize() { Connection.Connect(); CheckConnectionAndStartWorker(); } /// /// Initializes the device /// public virtual async Task InitializeAsync() { await Connection.ConnectAsync(); CheckConnectionAndStartWorker(); } /// /// Checks the connection and starts background worker which is sending the commands /// /// Failed to open Serial-Connection. private void CheckConnectionAndStartWorker() { if (!Connection.IsOpen) { Logger?.WriteLine("Failed to open Serial-Connection.", OBDLogLevel.Error); throw new SerialException("Failed to open Serial-Connection."); } Logger?.WriteLine("Opened Serial-Connection!", OBDLogLevel.Debug); _commandCancellationToken = new CancellationTokenSource(); _commandWorkerTask = Task.Factory.StartNew(CommandWorker); } /// /// Sends the command. /// /// command string /// Not connected protected virtual CommandResult SendCommand(string command) { if (!Connection.IsOpen) throw new InvalidOperationException("Not connected"); command = PrepareCommand(command); Logger?.WriteLine("Queuing Command: '" + command.Replace('\r', '\'') + "'", OBDLogLevel.Verbose); QueuedCommand cmd = new(command); _queueEmptyEvent.Reset(); Interlocked.Increment(ref _queueSize); _commandQueue.Add(cmd); return cmd.CommandResult; } /// /// Prepares the command /// /// /// protected virtual string PrepareCommand(string command) { if (command == null) throw new ArgumentNullException(nameof(command)); if (!command.EndsWith(Terminator.ToString(), StringComparison.Ordinal)) command += Terminator; return command; } /// /// Called when data is received from the serial device /// /// The sender. /// The instance containing the event data. private void OnDataReceived(object? sender, DataReceivedEventArgs e) { for (int i = 0; i < e.Count; i++) { char c = (char)e.Data[i]; switch (c) { case '\r': FinishLine(); break; case '>': CurrentCommand?.CommandResult.WaitHandle.Set(); _commandFinishedEvent.Set(); break; case '\n': case (char)0x00: break; // ignore default: _lineBuffer.Append(c); break; } } } /// /// Signals a final message /// private void FinishLine() { string line = _lineBuffer.ToString().Trim(); _lineBuffer.Clear(); if (string.IsNullOrWhiteSpace(line)) return; Logger?.WriteLine("Response: '" + line + "'", OBDLogLevel.Verbose); InternalProcessMessage(line); } /// /// Process message and sets the result /// /// The message. private void InternalProcessMessage(string message) { object? data = ProcessMessage(message); if (CurrentCommand != null) CurrentCommand.CommandResult.Result = data; } /// /// Processes the message. /// /// message received /// result data protected abstract object? ProcessMessage(string message); /// /// Worker method for sending commands /// private async void CommandWorker() { if (_commandCancellationToken == null) return; CancellationToken cancellationToken = _commandCancellationToken.Token; while (!_commandCancellationToken.IsCancellationRequested) { CurrentCommand = null; if (_queueSize == 0) _queueEmptyEvent.Set(); try { if (_commandQueue.TryTake(out CurrentCommand, 10, cancellationToken)) { Interlocked.Decrement(ref _queueSize); Logger?.WriteLine("Writing Command: '" + CurrentCommand.CommandText.Replace('\r', '\'') + "'", OBDLogLevel.Verbose); if (Connection.IsAsync) await Connection.WriteAsync(Encoding.ASCII.GetBytes(CurrentCommand.CommandText)); else // ReSharper disable once MethodHasAsyncOverload Connection.Write(Encoding.ASCII.GetBytes(CurrentCommand.CommandText)); // wait for command to finish or command canceled while (!_commandFinishedEvent.WaitOne(50)) cancellationToken.ThrowIfCancellationRequested(); } } catch (OperationCanceledException) { CurrentCommand?.CommandResult.WaitHandle.Set(); } } foreach (QueuedCommand cmd in _commandQueue) cmd.CommandResult.WaitHandle.Set(); } public void WaitQueue() => _queueEmptyEvent.WaitOne(); public async Task WaitQueueAsync() => await Task.Run(WaitQueue); /// /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// public virtual void Dispose() { _commandQueue.CompleteAdding(); _commandCancellationToken?.Cancel(); _commandWorkerTask?.Wait(); Connection.Dispose(); } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Enums/Mode.cs ================================================ namespace OBD.NET.Enums; /// /// https://en.wikipedia.org/wiki/OBD-II_PIDs#Modes /// public enum Mode { ShowCurrentData = 0x01, ShowFreezeFrameData = 0x02, ShowStoredDiagnosticTroubleCodes = 0x03, ClearDiagnosticTroubleCodesAndStoredValues = 0x04, TestResults_OxygenSensorMonitoring = 0x05, TestResults_OtherComponentMonitoring = 0x06, ShowPendingDiagnosticTroubleCodes = 0x07, ControlOperationOfOnboardComponent = 0x08, RequestVehicleInformation = 0x09, PermanentDiagnosticTroubleCodes = 0x0A } ================================================ FILE: OBD.NET/OBD.NET/Events/EventArgs/DataReceivedEventArgs.cs ================================================ using System; using OBD.NET.OBDData; namespace OBD.NET.Events; public class DataReceivedEventArgs where T : IOBDData { #region Properties & Fields public T Data { get; } public DateTime Timestamp { get; } #endregion #region Constructors public DataReceivedEventArgs(T data, DateTime timestamp) { this.Data = data; this.Timestamp = timestamp; } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Events/EventArgs/RawDataReceivedEventArgs.cs ================================================ using System; namespace OBD.NET.Events; public class RawDataReceivedEventArgs { #region Properties & Fields public string Data { get; } public DateTime Timestamp { get; } #endregion #region Constructors public RawDataReceivedEventArgs(string data, DateTime timestamp) { this.Data = data; this.Timestamp = timestamp; } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Events/GenericDataEventManager.cs ================================================ using System; using OBD.NET.Devices; using OBD.NET.OBDData; namespace OBD.NET.Events; public class GenericDataEventManager : IDataEventManager where T : IOBDData { #region Events internal event ELM327.DataReceivedEventHandler? DataReceived; #endregion #region Methods public void RaiseEvent(object sender, IOBDData data, DateTime timestamp) => DataReceived?.Invoke(sender, new DataReceivedEventArgs((T)data, timestamp)); #endregion } ================================================ FILE: OBD.NET/OBD.NET/Events/IDataEventManager.cs ================================================ using System; using OBD.NET.OBDData; namespace OBD.NET.Events; public interface IDataEventManager { void RaiseEvent(object sender, IOBDData data, DateTime timestamp); } ================================================ FILE: OBD.NET/OBD.NET/Exceptions/SerialException.cs ================================================ using System; namespace OBD.NET.Exceptions; public class SerialException : Exception { #region Constructors public SerialException() { } public SerialException(string message) : base(message) { } public SerialException(string message, Exception innerException) : base(message, innerException) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Exceptions/UnexpectedResultException.cs ================================================ using System; namespace OBD.NET.Exceptions; public class UnexpectedResultException : Exception { #region Properties & Fields public string Result { get; } public string ExpectedResult { get; } #endregion #region Constructors public UnexpectedResultException(string result, string expectedResult) : this($"Unexpected result '{result}'. Expected was '{expectedResult}'", result, expectedResult) { this.Result = result; this.ExpectedResult = expectedResult; } public UnexpectedResultException(string message, string result, string expectedResult) : base(message) { this.Result = result; this.ExpectedResult = expectedResult; } public UnexpectedResultException(string message, Exception innerException, string result, string expectedResult) : base(message, innerException) { this.Result = result; this.ExpectedResult = expectedResult; } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Extensions/HexExtension.cs ================================================ using System; using System.Linq; namespace OBD.NET.Extensions; public static class HexExtension { #region Methods public static int GetHexVal(this char hex) => hex - (hex < 58 ? 48 : (hex < 97 ? 55 : 87)); public static int GetHexVal(this string hex) { if ((hex.Length % 2) == 1) throw new ArgumentException("The binary key cannot have an odd number of digits"); return hex.Aggregate(0, (current, c) => (current << 4) + (GetHexVal(c))); } public static string ToHexString(this byte b) => ToHexString(new[] { b }); public static string ToHexString(this byte[] bytes) => BitConverter.ToString(bytes).Replace("-", string.Empty); #endregion } ================================================ FILE: OBD.NET/OBD.NET/Logging/IOBDLogger.cs ================================================ namespace OBD.NET.Logging; public interface IOBDLogger { void WriteLine(string text, OBDLogLevel level); } ================================================ FILE: OBD.NET/OBD.NET/Logging/OBDConsoleLogger.cs ================================================ using System; namespace OBD.NET.Logging; /// /// Simple console logger /// /// public class OBDConsoleLogger : IOBDLogger { #region Properties & Fields public OBDLogLevel LogLevel { get; set; } #endregion #region Constructors public OBDConsoleLogger(OBDLogLevel level = OBDLogLevel.None) { this.LogLevel = level; } #endregion #region Methods public void WriteLine(string text, OBDLogLevel level) { if (LogLevel == OBDLogLevel.None) return; if ((int)level <= (int)LogLevel) Console.WriteLine($"{DateTime.Now:G} - {level} - {text}"); } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Logging/OBDDebugLogger.cs ================================================ using System; using System.Diagnostics; namespace OBD.NET.Logging; /// /// Simple debug logger /// /// public class OBDDebugLogger : IOBDLogger { #region Properties & Fields public OBDLogLevel LogLevel { get; set; } #endregion #region Constructors public OBDDebugLogger(OBDLogLevel level = OBDLogLevel.None) { this.LogLevel = level; } #endregion #region Methods public void WriteLine(string text, OBDLogLevel level) { if (LogLevel == OBDLogLevel.None) return; if ((int)level <= (int)LogLevel) Debug.WriteLine($"{DateTime.Now:G} - {level} - {text}"); } #endregion } ================================================ FILE: OBD.NET/OBD.NET/Logging/OBDLogLevel.cs ================================================ namespace OBD.NET.Logging; public enum OBDLogLevel { None, Error, Verbose, Debug } ================================================ FILE: OBD.NET/OBD.NET/OBD.NET.csproj ================================================  enable net6.0;net5.0;net4.8 10 Darth Affe / Roman Lumetsberger - OBD.NET C#-Library to read/write data from/to a car through an ELM327-/STN1170-Adapter 1.3.0 True Github https://github.com/DarthAffe/OBD.NET https://github.com/DarthAffe/OBD.NET GPL-2.0-only ..\bin\ true True True snupkg OBD.NET OBD.NET OBD.NET NET5_0;NETFULL NET6_0;NETFULL NET4_8;NETFULL $(DefineConstants);TRACE;DEBUG true full false $(DefineConstants);RELEASE portable true $(NoWarn);CS1591;CS1572;CS1573 ================================================ FILE: OBD.NET/OBD.NET/OBD.NET.csproj.DotSettings ================================================  True True True True True True True True True ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/AuxiliaryInputStatus.cs ================================================ namespace OBD.NET.OBDData; public class AuxiliaryInputStatus : AbstractOBDData { #region Properties & Fields public bool PowerTakeOffStatus => (A & (1 << 0)) != 0; #endregion #region Constructors public AuxiliaryInputStatus() : base(0x1E, 1) { } #endregion #region Methods public override string ToString() => PowerTakeOffStatus.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/CalculatedEngineLoad.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CalculatedEngineLoad : AbstractOBDData { #region Properties & Fields public new Percent Load => new(A / 2.55, 0, 100); #endregion #region Constructors public CalculatedEngineLoad() : base(0x04, 1) { } #endregion #region Methods public override string ToString() => Load.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/CommandedSecondaryAirStatus.cs ================================================ using System; namespace OBD.NET.OBDData; public class CommandedSecondaryAirStatus : AbstractOBDData { #region Properties & Fields public CommandedSecondaryAirStatusValue Status => (CommandedSecondaryAirStatusValue)A; #endregion #region Constructors public CommandedSecondaryAirStatus() : base(0x12, 1) { } #endregion #region Methods public override string ToString() => Status.ToString(); #endregion #region Enum /// /// https://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_1_PID_12 /// [Flags] public enum CommandedSecondaryAirStatusValue { Missing = 0, Upstream = 1 << 0, DownstreamOfCatalyticConverter = 1 << 1, FromTheOutsideAtmosphereOrOff = 1 << 2, PumpCommandedOnForDiagnostics = 1 << 3 } #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/EngineCoolantTemperature.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EngineCoolantTemperature : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new(A - 40, -40, 215); #endregion #region Constructors public EngineCoolantTemperature() : base(0x05, 1) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/EngineRPM.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EngineRPM : AbstractOBDData { #region Properties & Fields public RevolutionsPerMinute Rpm => new(((256 * A) + B) / 4.0, 0, 16383.75); #endregion #region Constructors public EngineRPM() : base(0x0C, 2) { } #endregion #region Methods public override string ToString() => Rpm.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/FuelPressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelPressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(3 * A, 0, 765); #endregion #region Constructors public FuelPressure() : base(0x0A, 1) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/FuelSystemStatus.cs ================================================ using System; namespace OBD.NET.OBDData; public class FuelSystemStatus : AbstractOBDData { #region Properties & Fields public FuelSystemStatusValue StatusSystem1 => (FuelSystemStatusValue)A; public FuelSystemStatusValue StatusSystem2 => (FuelSystemStatusValue)B; #endregion #region Constructors public FuelSystemStatus() : base(0x03, 2) { } #endregion #region Methods public override string ToString() => StatusSystem1.ToString(); #endregion #region Enums /// /// https://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_1_PID_03 /// [Flags] public enum FuelSystemStatusValue { Missing = 0, OpenLoopDueToInsufficientEngineTemperature = 1 << 0, ClosedLoopUsingOxygenSensorFeedbackToDetermineFuelMix = 1 << 1, OpenLoopDueToEngineLoadOrFuelCutDueToDeceleration = 1 << 2, OpenLoopDueToSystemFailure = 1 << 3, ClosedLoopUsingAtLeastOneOxygenSensorButThereIsAFaultInTheFeedbackSystem = 1 << 4 } #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/IntakeAirTemperature.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class IntakeAirTemperature : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new(A - 40, -40, 215); #endregion #region Constructors public IntakeAirTemperature() : base(0x0F, 1) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/IntakeManifoldAbsolutePressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class IntakeManifoldAbsolutePressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(A, 0, 255); #endregion #region Constructors public IntakeManifoldAbsolutePressure() : base(0x0B, 1) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/LongTermFuelTrimBank1.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class LongTermFuelTrimBank1 : AbstractOBDData { #region Properties & Fields public Percent Trim => new((A / 1.28) - 100, -100, 99.2); #endregion #region Constructors public LongTermFuelTrimBank1() : base(0x07, 1) { } #endregion #region Methods public override string ToString() => Trim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/LongTermFuelTrimBank2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class LongTermFuelTrimBank2 : AbstractOBDData { #region Properties & Fields public Percent Trim => new((A / 1.28) - 100, -100, 99.2); #endregion #region Constructors public LongTermFuelTrimBank2() : base(0x09, 1) { } #endregion #region Methods public override string ToString() => Trim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/MAFAirFlowRate.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class MAFAirFlowRate : AbstractOBDData { #region Properties & Fields public GramPerSec Rate => new(((256 * A) + B) / 100.0, 0, 655.35); #endregion #region Constructors public MAFAirFlowRate() : base(0x10, 2) { } #endregion #region Methods public override string ToString() => Rate.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OBDStandards.cs ================================================ namespace OBD.NET.OBDData; public class OBDStandards : AbstractOBDData { #region Properties & Fields public OBDStandard Standard => (OBDStandard)A; #endregion #region Constructors public OBDStandards() : base(0x1C, 1) { } #endregion #region Enum public enum OBDStandard { Missing = 0, OBDII = 1, OBD = 2, OBD_OBDII = 3, OBDI = 4, NotOBDCompliant = 5, EOBD = 6, EOBD_OBDII = 7, EOBD_OBD = 8, EOBD_OBD_OBDII = 9, JOBD = 10, JOBD_OBDII = 11, JOBD_EOBD = 12, JOBD_EOBD_OBDII = 13, EMD = 17, EMDPlus = 18, HDOBDC = 19, HDOBD = 20, WWHOBD = 21, HDEOBDI = 23, HDEOBDIN = 24, HDEOBDII = 25, HDEOBDIIN = 26, OBDBr1 = 28, OBDBr2 = 29, KOBD = 30, IOBDI = 31, IOBDII = 32, HDEOBDIV = 33 } #endregion #region Methods public override string ToString() => Standard.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor1FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor1FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor1FuelTrim() : base(0x14, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor2FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor2FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor2FuelTrim() : base(0x15, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor3FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor3FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor3FuelTrim() : base(0x16, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor4FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor4FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor4FuelTrim() : base(0x17, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor5FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor5FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor5FuelTrim() : base(0x18, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor6FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor6FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor6FuelTrim() : base(0x19, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor7FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor7FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor7FuelTrim() : base(0x1A, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensor8FuelTrim.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor8FuelTrim : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(A / 200.0, 0, 1.275); public Percent ShortTermFuelTrim => new((B / 1.28) - 100, -100, 99.2); public bool IsSensorUsed => B != 0xFF; #endregion #region Constructors public OxygenSensor8FuelTrim() : base(0x1B, 2) { } #endregion #region Methods public override string ToString() => ShortTermFuelTrim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensorPresent.cs ================================================ using System; namespace OBD.NET.OBDData; public class OxygenSensorPresent : AbstractOBDData { #region Properties & Fields public bool IsSensor1Present => (A & (1 << 0)) != 0; public bool IsSensor2Present => (A & (1 << 1)) != 0; public bool IsSensor3Present => (A & (1 << 2)) != 0; public bool IsSensor4Present => (A & (1 << 3)) != 0; public bool IsSensor5Present => (A & (1 << 4)) != 0; public bool IsSensor6Present => (A & (1 << 5)) != 0; public bool IsSensor7Present => (A & (1 << 6)) != 0; public bool IsSensor8Present => (A & (1 << 7)) != 0; #endregion #region Constructors public OxygenSensorPresent() : base(0x13, 1) { } #endregion #region Methods public override string ToString() => Convert.ToString(A, 2); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/OxygenSensorsPresent2.cs ================================================ using System; namespace OBD.NET.OBDData; public class OxygenSensorPresent2 : AbstractOBDData { #region Properties & Fields public bool IsSensor1Present => (A & (1 << 0)) != 0; public bool IsSensor2Present => (A & (1 << 1)) != 0; public bool IsSensor3Present => (A & (1 << 2)) != 0; public bool IsSensor4Present => (A & (1 << 3)) != 0; public bool IsSensor5Present => (A & (1 << 4)) != 0; public bool IsSensor6Present => (A & (1 << 5)) != 0; public bool IsSensor7Present => (A & (1 << 6)) != 0; public bool IsSensor8Present => (A & (1 << 7)) != 0; #endregion #region Constructors public OxygenSensorPresent2() : base(0x1D, 1) { } #endregion #region Methods public override string ToString() => Convert.ToString(A, 2); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/PidsSupported01_20.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupported01_20 : AbstractPidsSupported { #region Constructors public PidsSupported01_20() : base(0x00, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/RunTimeSinceEngineStart.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class RunTimeSinceEngineStart : AbstractOBDData { #region Properties & Fields public Second Runtime => new((256 * A) + B, 0, 65535); #endregion #region Constructors public RunTimeSinceEngineStart() : base(0x1F, 2) { } #endregion #region Methods public override string ToString() => Runtime.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/ShortTermFuelTrimBank1.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ShortTermFuelTrimBank1 : AbstractOBDData { #region Properties & Fields public Percent Trim => new((A / 1.28) - 100, -100, 99.2); #endregion #region Constructors public ShortTermFuelTrimBank1() : base(0x06, 1) { } #endregion #region Methods public override string ToString() => Trim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/ShortTermFuelTrimBank2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ShortTermFuelTrimBank2 : AbstractOBDData { #region Properties & Fields public Percent Trim => new((A / 1.28) - 100, -100, 99.2); #endregion #region Constructors public ShortTermFuelTrimBank2() : base(0x08, 1) { } #endregion #region Methods public override string ToString() => Trim.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/ThrottlePosition.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ThrottlePosition : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public ThrottlePosition() : base(0x11, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/TimingAdvance.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class TimingAdvance : AbstractOBDData { #region Properties & Fields public Degree Timing => new((A / 2.0) - 64, -64, 63.5); #endregion #region Constructors public TimingAdvance() : base(0x0E, 1) { } #endregion #region Methods public override string ToString() => Timing.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/00-1F/VehicleSpeed.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class VehicleSpeed : AbstractOBDData { #region Properties & Fields public KilometrePerHour Speed => new(A, 0, 255); #endregion #region Constructors public VehicleSpeed() : base(0x0D, 1) { } #endregion #region Methods public override string ToString() => Speed.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/AbsoluteBarometricPressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AbsoluteBarometricPressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(A, 0, 255); #endregion #region Constructors public AbsoluteBarometricPressure() : base(0x33, 1) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/CatalystTemperatureBank1Sensor1.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CatalystTemperatureBank1Sensor1 : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new((((256 * A) + B) / 10.0) - 40, -40, 6513.5); #endregion #region Constructors public CatalystTemperatureBank1Sensor1() : base(0x3C, 2) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/CatalystTemperatureBank1Sensor2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CatalystTemperatureBank1Sensor2 : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new((((256 * A) + B) / 10.0) - 40, -40, 6513.5); #endregion #region Constructors public CatalystTemperatureBank1Sensor2() : base(0x3D, 2) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/CatalystTemperatureBank2Sensor1.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CatalystTemperatureBank2Sensor1 : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new((((256 * A) + B) / 10.0) - 40, -40, 6513.5); #endregion #region Constructors public CatalystTemperatureBank2Sensor1() : base(0x3E, 2) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/CatalystTemperatureBank2Sensor2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CatalystTemperatureBank2Sensor2 : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new((((256 * A) + B) / 10.0) - 40, -40, 6513.5); #endregion #region Constructors public CatalystTemperatureBank2Sensor2() : base(0x3F, 2) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/CommandedEGR.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CommandedEGR : AbstractOBDData { #region Properties & Fields public Percent EGR => new(A / 2.55, 0, 100); #endregion #region Constructors public CommandedEGR() : base(0x2C, 1) { } #endregion #region Methods public override string ToString() => EGR.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/CommandedEvaporativePurge.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CommandedEvaporativePurge : AbstractOBDData { #region Properties & Fields public Percent Purge => new(A / 2.55, 0, 100); #endregion #region Constructors public CommandedEvaporativePurge() : base(0x2E, 1) { } #endregion #region Methods public override string ToString() => Purge.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/DistanceTraveledSinceCodesCleared.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class DistanceTraveledSinceCodesCleared : AbstractOBDData { #region Properties & Fields public Kilometre Distance => new((256 * A) + B, 0, 65535); #endregion #region Constructors public DistanceTraveledSinceCodesCleared() : base(0x31, 2) { } #endregion #region Methods public override string ToString() => Distance.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/DistanceTraveledWithMILOn.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class DistanceTraveledWithMILOn : AbstractOBDData { #region Properties & Fields public Kilometre Distance => new((256 * A) + B, 0, 65535); #endregion #region Constructors public DistanceTraveledWithMILOn() : base(0x21, 2) { } #endregion #region Methods public override string ToString() => Distance.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/EGRError.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EGRError : AbstractOBDData { #region Properties & Fields public Percent Error => new((A / 1.28) - 100, -100, 99.2); #endregion #region Constructors public EGRError() : base(0x2D, 1) { } #endregion #region Methods public override string ToString() => Error.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/EvapSystemVaporPressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EvapSystemVaporPressure : AbstractOBDData { #region Properties & Fields public Pascal Pressure => new(((256 * A) + B) / 4.0, -8192, 8191.75); #endregion #region Constructors public EvapSystemVaporPressure() : base(0x32, 2) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/FuelRailGaugePressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelRailGaugePressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(10 * ((256 * A) + B), 0, 655350); #endregion #region Constructors public FuelRailGaugePressure() : base(0x23, 2) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/FuelRailPressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelRailPressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(0.079 * ((256 * A) + B), 0, 5177.265); #endregion #region Constructors public FuelRailPressure() : base(0x22, 2) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/FuelTankLevelInput.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelTankLevelInput : AbstractOBDData { #region Properties & Fields public Percent Level => new(A / 2.55, 0, 100); #endregion #region Constructors public FuelTankLevelInput() : base(0x2F, 1) { } #endregion #region Methods public override string ToString() => Level.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor1FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor1FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor1FuelAir() : base(0x24, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor1FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor1FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor1FuelAir2() : base(0x34, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor2FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor2FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor2FuelAir() : base(0x25, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor2FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor2FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor2FuelAir2() : base(0x35, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor3FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor3FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor3FuelAir() : base(0x26, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor3FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor3FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor3FuelAir2() : base(0x36, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor4FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor4FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor4FuelAir() : base(0x27, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor4FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor4FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor4FuelAir2() : base(0x37, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor5FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor5FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor5FuelAir() : base(0x28, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor5FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor5FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor5FuelAir2() : base(0x38, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor6FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor6FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor6FuelAir() : base(0x29, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor6FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor6FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor6FuelAir2() : base(0x39, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor7FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor7FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor7FuelAir() : base(0x2A, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor7FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor7FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor7FuelAir2() : base(0x3A, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor8FuelAir.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor8FuelAir : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Volt Voltage => new((80 / 25536.0) * ((256 * C) + D), 0, 8 - double.Epsilon); #endregion #region Constructors public OxygenSensor8FuelAir() : base(0x2B, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/OxygenSensor8FuelAir2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class OxygenSensor8FuelAir2 : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new((2.0 / 25536.0) * ((256 * A) + B), 0, 2 - double.Epsilon); public Milliampere Current => new((C + (D / 256.0)) - 128, -128, 128 - double.Epsilon); #endregion #region Constructors public OxygenSensor8FuelAir2() : base(0x3B, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/PidsSupported21_40.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupported21_40 : AbstractPidsSupported { #region Constructors public PidsSupported21_40() : base(0x20, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/20-3F/WarmUpsSinceCodesCleared.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class WarmUpsSinceCodesCleared : AbstractOBDData { #region Properties & Fields public Count WarmUps => new(A, 0, 255); #endregion #region Constructors public WarmUpsSinceCodesCleared() : base(0x30, 1) { } #endregion #region Methods public override string ToString() => WarmUps.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AbsoluteEvapSystemVaporPressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AbsoluteEvapSystemVaporPressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(((256 * A) + B) / 200.0, 0, 327.675); #endregion #region Constructors public AbsoluteEvapSystemVaporPressure() : base(0x53, 2) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AbsoluteLoadValue.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AbsoluteLoadValue : AbstractOBDData { #region Properties & Fields public new Percent Load => new(((256 * A) + B) / 2.55, 0, 25700); #endregion #region Constructors public AbsoluteLoadValue() : base(0x43, 2) { } #endregion #region Methods public override string ToString() => Load.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AbsoluteThrottlePositionB.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AbsoluteThrottlePositionB : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public AbsoluteThrottlePositionB() : base(0x47, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AbsoluteThrottlePositionC.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AbsoluteThrottlePositionC : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public AbsoluteThrottlePositionC() : base(0x48, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AcceleratorPedalPositionD.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AcceleratorPedalPositionD : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public AcceleratorPedalPositionD() : base(0x49, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AcceleratorPedalPositionE.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AcceleratorPedalPositionE : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public AcceleratorPedalPositionE() : base(0x4A, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AcceleratorPedalPositionF.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AcceleratorPedalPositionF : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public AcceleratorPedalPositionF() : base(0x4B, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/AmbientAirTemperature.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class AmbientAirTemperature : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new(A - 40, -40, 215); #endregion #region Constructors public AmbientAirTemperature() : base(0x46, 1) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/CommandedThrottleActuator.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class CommandedThrottleActuator : AbstractOBDData { #region Properties & Fields public Percent Value => new(A / 2.55, 0, 100); #endregion #region Constructors public CommandedThrottleActuator() : base(0x4C, 1) { } #endregion #region Methods public override string ToString() => Value.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/ControlModuleVoltage.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ControlModuleVoltage : AbstractOBDData { #region Properties & Fields public Volt Voltage => new(((256 * A) + B) / 1000.0, 0, 65.535); #endregion #region Constructors public ControlModuleVoltage() : base(0x42, 2) { } #endregion #region Methods public override string ToString() => Voltage.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/EngineFuelRate.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EngineFuelRate : AbstractOBDData { #region Properties & Fields public LitresPerHour FuelRate => new(((256 * A) + B) / 20.0, 0, 3212.75); #endregion #region Constructors public EngineFuelRate() : base(0x5E, 2) { } #endregion #region Methods public override string ToString() => FuelRate.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/EngineOilTemperature.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EngineOilTemperature : AbstractOBDData { #region Properties & Fields public DegreeCelsius Temperature => new(A - 40, -40, 210); #endregion #region Constructors public EngineOilTemperature() : base(0x5C, 1) { } #endregion #region Methods public override string ToString() => Temperature.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/EthanolFuel.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EthanolFuel : AbstractOBDData { #region Properties & Fields public Percent Value => new(A / 2.55, 0, 100); #endregion #region Constructors public EthanolFuel() : base(0x52, 1) { } #endregion #region Methods public override string ToString() => Value.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/EvapSystemVaporPressure2.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EvapSystemVaporPressure2 : AbstractOBDData { #region Properties & Fields public Pascal Pressure => new(((A * 256) + B) - 32767, -32767, 32768); #endregion #region Constructors public EvapSystemVaporPressure2() : base(0x54, 2) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/FuelAirCommandedEquivalenceRatio.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelAirCommandedEquivalenceRatio : AbstractOBDData { #region Properties & Fields public Ratio Ratio => new((2.0 / 65536.0) * ((256 * A) + B), 0, 2.0 - double.Epsilon); #endregion #region Constructors public FuelAirCommandedEquivalenceRatio() : base(0x44, 2) { } #endregion #region Methods public override string ToString() => Ratio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/FuelInjectionTiming.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelInjectionTiming : AbstractOBDData { #region Properties & Fields public Degree Timing => new((((256 * A) + B) / 128.0) - 210, -210, 301.992); #endregion #region Constructors public FuelInjectionTiming() : base(0x5D, 2) { } #endregion #region Methods public override string ToString() => Timing.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/FuelRailAbsolutePressure.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class FuelRailAbsolutePressure : AbstractOBDData { #region Properties & Fields public Kilopascal Pressure => new(10 * ((256 * A) + B), 0, 655350); #endregion #region Constructors public FuelRailAbsolutePressure() : base(0x59, 2) { } #endregion #region Methods public override string ToString() => Pressure.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/FuelType.cs ================================================ namespace OBD.NET.OBDData; public class FuelType : AbstractOBDData { #region Properties & Fields public FuelTypeValue Type => (FuelTypeValue)A; #endregion #region Constructors public FuelType() : base(0x51, 1) { } #endregion #region Methods public override string ToString() => Type.ToString(); #endregion #region Enum public enum FuelTypeValue { NotAvailable = 0, Gasoline = 1, Methanol = 2, Ethanol = 3, Diesel = 4, LPG = 5, CNG = 6, Propane = 7, Electric = 8, BifuelGasoline = 9, BifuelMethanol = 10, BifuelEthanol = 11, BifuelLPG = 12, BifuelCNG = 13, BifuelPropane = 14, BifuelElectricity = 15, BifuelElectricAndCombustionEngine = 16, HybridGasoline = 17, HybridEthanol = 18, HybridDiesel = 19, HybridElectric = 20, HybridElectricAndCombustionEngine = 21, HybridRegenerative = 22, BifuelDiesel = 23 } #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/HybridBatteryPackRemainingLife.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class HybridBatteryPackRemainingLife : AbstractOBDData { #region Properties & Fields public Percent RemainingLife => new(A / 2.55, 0, 100); #endregion #region Constructors public HybridBatteryPackRemainingLife() : base(0x5B, 1) { } #endregion #region Methods public override string ToString() => RemainingLife.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/LongTermSecondaryOxygenSensorTrimBank13.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class LongtTermSecondaryOxygenSensorTrimBank13 : AbstractOBDData { #region Properties & Fields public Percent Bank1 => new((A / 1.28) - 100, -100, 99.2); public Percent Bank3 => new((B / 1.28) - 100, -100, 99.2); #endregion #region Constructors public LongtTermSecondaryOxygenSensorTrimBank13() : base(0x56, 2) { } #endregion #region Methods public override string ToString() => Bank1.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/LongTermSecondaryOxygenSensorTrimBank24.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class LongTermSecondaryOxygenSensorTrimBank24 : AbstractOBDData { #region Properties & Fields public Percent Bank2 => new((A / 1.28) - 100, -100, 99.2); public Percent Bank4 => new((B / 1.28) - 100, -100, 99.2); #endregion #region Constructors public LongTermSecondaryOxygenSensorTrimBank24() : base(0x58, 2) { } #endregion #region Methods public override string ToString() => Bank2.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/MaximumValueForAirFlowRate.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class MaximumValueForAirFlowRate : AbstractOBDData { #region Properties & Fields public GramPerSec Value => new(A * 10, 0, 2550); #endregion #region Constructors public MaximumValueForAirFlowRate() : base(0x50, 4) { } #endregion #region Methods public override string ToString() => Value.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/MaximumValues.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class MaximumValues : AbstractOBDData { #region Properties & Fields public Ratio FuelAirEquivalenceRatio => new(A, 0, 255); public Volt OxygenSensorVoltage => new(B, 0, 255); public Milliampere OxygenSensorCurrent => new(C, 0, 255); public Kilopascal IntakeManifoldAbsolutePressure => new(D * 10, 0, 2550); #endregion #region Constructors public MaximumValues() : base(0x4F, 4) { } #endregion #region Methods public override string ToString() => FuelAirEquivalenceRatio.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/MonitorStatusThisDriveCycle.cs ================================================ namespace OBD.NET.OBDData; public class MonitorStatusThisDriveCycle : AbstractOBDData { #region Properties & Fields public bool IsComponentsTestAvailable => (B & (1 << 3)) != 0; public bool IsComponentsTestComplete => (B & (1 << 7)) == 0; public bool IsFuelSystemTestAvailable => (B & (1 << 1)) != 0; public bool IsFuelSystemTestComplete => (B & (1 << 5)) == 0; public bool IsMisfireTestAvailable => (B & (1 << 0)) != 0; public bool IsMisfireTestComplete => (B & (1 << 4)) == 0; public bool IsEGRSystemTestAvailable => (C & (1 << 7)) != 0; public bool IsEGRSystemTestComplete => (D & (1 << 7)) == 0; public bool IsOxygenSensorHeaterTestAvailable => (C & (1 << 6)) != 0; public bool IsOxygenSensorHeaterTestComplete => (D & (1 << 6)) == 0; public bool IsOxygenSensorTestAvailable => (C & (1 << 5)) != 0; public bool IsOxygenSensorTestComplete => (D & (1 << 5)) == 0; public bool IsACRefrigerantTestAvailable => (C & (1 << 4)) != 0; public bool IsACRefrigerantTestComplete => (D & (1 << 4)) == 0; public bool IsSecondaryAirSystemTestAvailable => (C & (1 << 3)) != 0; public bool IsSecondaryAirSystemTestComplete => (D & (1 << 3)) == 0; public bool IsEvaporativeSystemTestAvailable => (C & (1 << 2)) != 0; public bool IsEvaporativeSystemTestComplete => (D & (1 << 2)) == 0; public bool IsHeatedCatalystTestAvailable => (C & (1 << 1)) != 0; public bool IsHeatedCatalystTestComplete => (D & (1 << 1)) == 0; public bool IsCatalystAvailable => (C & (1 << 0)) != 0; public bool IsCatalystComplete => (D & (1 << 0)) == 0; #endregion #region Constructors public MonitorStatusThisDriveCycle() : base(0x41, 4) { } #endregion #region Methods public override string ToString() => string.Empty; #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/PidsSupported41_60.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupported41_60 : AbstractPidsSupported { #region Constructors public PidsSupported41_60() : base(0x40, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/RelativeAcceleratorPedalPosition.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class RelativeAcceleratorPedalPosition : AbstractOBDData { #region Properties & Fields public Percent PedalPosition => new(A / 2.55, 0, 100); #endregion #region Constructors public RelativeAcceleratorPedalPosition() : base(0x5A, 1) { } #endregion #region Methods public override string ToString() => PedalPosition.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/RelativeThrottlePosition.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class RelativeThrottlePosition : AbstractOBDData { #region Properties & Fields public Percent Position => new(A / 2.55, 0, 100); #endregion #region Constructors public RelativeThrottlePosition() : base(0x45, 1) { } #endregion #region Methods public override string ToString() => Position.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/ShortTermSecondaryOxygenSensorTrimBank13.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ShortTermSecondaryOxygenSensorTrimBank13 : AbstractOBDData { #region Properties & Fields public Percent Bank1 => new((A / 1.28) - 100, -100, 99.2); public Percent Bank3 => new((B / 1.28) - 100, -100, 99.2); #endregion #region Constructors public ShortTermSecondaryOxygenSensorTrimBank13() : base(0x55, 2) { } #endregion #region Methods public override string ToString() => Bank1.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/ShortTermSecondaryOxygenSensorTrimBank24.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ShortTermSecondaryOxygenSensorTrimBank24 : AbstractOBDData { #region Properties & Fields public Percent Bank2 => new((A / 1.28) - 100, -100, 99.2); public Percent Bank4 => new((B / 1.28) - 100, -100, 99.2); #endregion #region Constructors public ShortTermSecondaryOxygenSensorTrimBank24() : base(0x57, 2) { } #endregion #region Methods public override string ToString() => Bank2.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/TimeRunWithMILOn.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class TimeRunWithMILOn : AbstractOBDData { #region Properties & Fields public Minute Time => new((256 * A) + B, 0, 65535); #endregion #region Constructors public TimeRunWithMILOn() : base(0x4D, 2) { } #endregion #region Methods public override string ToString() => Time.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/40-5F/TimeSinceTroubleCodesCleared.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class TimeSinceTroubleCodesCleared : AbstractOBDData { #region Properties & Fields public Minute Time => new((256 * A) + B, 0, 65535); #endregion #region Constructors public TimeSinceTroubleCodesCleared() : base(0x4E, 2) { } #endregion #region Methods public override string ToString() => Time.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/ActualEnginePercentTorque.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class ActualEnginePercentTorque : AbstractOBDData { #region Properties & Fields public Percent Torque => new(A - 125, -125, 125); #endregion #region Constructors public ActualEnginePercentTorque() : base(0x62, 1) { } #endregion #region Methods public override string ToString() => Torque.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/DriversDemandEnginePercentTorque.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class DriversDemandEnginePercentTorque : AbstractOBDData { #region Properties & Fields public Percent Torque => new(A - 125, -125, 125); #endregion #region Constructors public DriversDemandEnginePercentTorque() : base(0x61, 1) { } #endregion #region Methods public override string ToString() => Torque.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/EngineCoolantTemperatureSensor.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EngineCoolantTemperatureSensor : AbstractOBDData { #region Properties & Fields public int SensorsSupported => A; public DegreeCelsius Sensor1 => new(B - 40, -40, 215); public DegreeCelsius Sensor2 => new(C - 40, -40, 215); #endregion #region Constructors public EngineCoolantTemperatureSensor() : base(0x67, 3) { } #endregion #region Methods public override string ToString() => Sensor1.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/EnginePercentTorqueData.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EnginePercentTorqueData : AbstractOBDData { #region Properties & Fields public Percent Idle => new(A - 125, -125, 125); public Percent EnginePoint1 => new(B - 125, -125, 125); public Percent EnginePoint2 => new(C - 125, -125, 125); public Percent EnginePoint3 => new(D - 125, -125, 125); public Percent EnginePoint4 => new(E - 125, -125, 125); #endregion #region Constructors public EnginePercentTorqueData() : base(0x64, 5) { } #endregion #region Methods public override string ToString() => Idle.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/EngineReferenceTorque.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class EngineReferenceTorque : AbstractOBDData { #region Properties & Fields public NewtonMetre Torque => new((256 * A) + B, 0, 65535); #endregion #region Constructors public EngineReferenceTorque() : base(0x63, 2) { } #endregion #region Methods public override string ToString() => Torque.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/IntakeAirTemperatureSensor.cs ================================================ using OBD.NET.DataTypes; namespace OBD.NET.OBDData; public class IntakeAirTemperatureSensor : AbstractOBDData { #region Properties & Fields public int SensorsSupported => A; public DegreeCelsius Bank1Sensor1 => new(B - 40, -40, 215); public DegreeCelsius Bank1Sensor2 => new(C - 40, -40, 215); public DegreeCelsius Bank1Sensor3 => new(D - 40, -40, 215); public DegreeCelsius Bank2Sensor1 => new(E - 40, -40, 215); public DegreeCelsius Bank2Sensor2 => new(RawData[5] - 40, -40, 215); public DegreeCelsius Bank2Sensor3 => new(RawData[6] - 40, -40, 215); #endregion #region Constructors public IntakeAirTemperatureSensor() : base(0x68, 7) { } #endregion #region Methods public override string ToString() => Bank1Sensor1.ToString(); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/60-7F/PidsSupported61_80.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupported61_80 : AbstractPidsSupported { #region Constructors public PidsSupported61_80() : base(0x60, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/80-9F/PidsSupported81_A0.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupported81_A0 : AbstractPidsSupported { #region Constructors public PidsSupported81_A0() : base(0x80, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/A0-BF/PidsSupportedA1_C0.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupportedA1_C0 : AbstractPidsSupported { #region Constructors public PidsSupportedA1_C0() : base(0xA0, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/AbstractOBDData.cs ================================================ using System; using OBD.NET.Extensions; namespace OBD.NET.OBDData; public abstract class AbstractOBDData : IOBDData { #region Properties & Fields public byte PID { get; } private readonly int _length; private byte[] _rawData = Array.Empty(); public byte[] RawData { get => _rawData; set { if (value.Length != _length) throw new ArgumentException("The provided raw-data is not valid", nameof(value)); _rawData = value; } } public bool IsValid => RawData.Length == _length; protected byte A => RawData.Length > 0 ? RawData[0] : default; protected byte B => RawData.Length > 1 ? RawData[1] : default; protected byte C => RawData.Length > 2 ? RawData[2] : default; protected byte D => RawData.Length > 3 ? RawData[3] : default; protected byte E => RawData.Length > 4 ? RawData[4] : default; #endregion #region Constructors protected AbstractOBDData(byte pid, int length) { this.PID = pid; this._length = length; } protected AbstractOBDData(byte pid, int length, byte[] rawData) : this(pid, length) { this.RawData = rawData; } #endregion #region Methods public void Load(string data) { try { if (((data.Length % 2) != 0) || ((data.Length / 2) < _length)) throw new ArgumentException("The provided data is not valid", nameof(data)); _rawData = new byte[_length]; for (int i = 0; i < _length; ++i) _rawData[i] = (byte)((data[i << 1].GetHexVal() << 4) + (data[(i << 1) + 1].GetHexVal())); } catch { _rawData = Array.Empty(); throw; } } #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/AbstractPidsSupported.cs ================================================ using System.Collections; using System.Collections.Generic; namespace OBD.NET.OBDData; public abstract class AbstractPidsSupported : AbstractOBDData { #region Properties & Fields public int[] SupportedPids { get { List supportedPids = new(); BitArray bitArray = new(new[] { D, C, B, A }); for (int i = 0x01; i <= 0x20; i++) if (bitArray.Get(bitArray.Length - i)) supportedPids.Add(PID + i); return supportedPids.ToArray(); } } #endregion #region Constructors public AbstractPidsSupported(byte pid, int length) : base(pid, length) { } #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/C0-DF/PidsSupportedC1_E0.cs ================================================ namespace OBD.NET.OBDData; public class PidsSupportedC1_E0 : AbstractPidsSupported { #region Constructors public PidsSupportedC1_E0() : base(0xC0, 4) { } #endregion #region Methods public override string ToString() => string.Join(",", SupportedPids); #endregion } ================================================ FILE: OBD.NET/OBD.NET/OBDData/IOBDData.cs ================================================ namespace OBD.NET.OBDData; public interface IOBDData { byte PID { get; } void Load(string data); } ================================================ FILE: OBD.NET/OBD.NET/Properties/launchSettings.json ================================================ { "profiles": { "OBD.NET": { "commandName": "Project" } } } ================================================ FILE: OBD.NET/OBD.NET/Util/AsyncManulResetEvent.cs ================================================ using System.Threading; using System.Threading.Tasks; namespace OBD.NET.Util; /// /// Notifies one or more waiting awaiters that an event has occurred /// public class AsyncManualResetEvent { #region Properties & Fields private volatile TaskCompletionSource _tcs = new(); #endregion #region Methods /// /// Waits the async. /// /// public Task WaitAsync() => _tcs.Task; //public void Set() { m_tcs.TrySetResult(true); } /// /// Sets the state of the event to signaled, allowing one or more waiting awaiters to proceed. /// public void Set() { TaskCompletionSource tcs = _tcs; Task.Factory.StartNew(s => ((TaskCompletionSource)s!).TrySetResult(true), tcs, CancellationToken.None, TaskCreationOptions.PreferFairness, TaskScheduler.Default); tcs.Task.Wait(); } /// /// Sets the state of the event to nonsignaled, causing awaiters to block. /// public void Reset() { while (true) { TaskCompletionSource tcs = _tcs; if (!tcs.Task.IsCompleted || (Interlocked.CompareExchange(ref _tcs, new TaskCompletionSource(), tcs) == tcs)) return; } } #endregion } ================================================ FILE: OBD.NET/OBD.NET.Unix.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.0.32014.148 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OBD.NET", "OBD.NET\OBD.NET.csproj", "{F60052E8-1201-4A5A-ADD7-6367C5424F74}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleClient", "ConsoleClient\ConsoleClient.csproj", "{8AC58110-3925-481F-9D85-4B809D7D18B9}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Debug|ARM = Debug|ARM Debug|ARM64 = Debug|ARM64 Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 Release|Any CPU = Release|Any CPU Release|ARM = Release|ARM Release|ARM64 = Release|ARM64 Release|x64 = Release|x64 Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|Any CPU.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM64.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM64.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x64.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x64.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x86.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x86.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|Any CPU.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|Any CPU.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM64.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM64.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x64.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x64.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x86.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x86.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|Any CPU.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM64.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM64.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x64.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x64.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x86.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x86.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|Any CPU.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|Any CPU.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM64.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM64.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x64.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x64.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x86.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {949E7C1D-8E95-46CF-B659-C6A15678A0D5} EndGlobalSection EndGlobal ================================================ FILE: OBD.NET/OBD.NET.sln ================================================  Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 VisualStudioVersion = 17.0.32014.148 MinimumVisualStudioVersion = 10.0.40219.1 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "OBD.NET", "OBD.NET\OBD.NET.csproj", "{F60052E8-1201-4A5A-ADD7-6367C5424F74}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleClient", "ConsoleClient\ConsoleClient.csproj", "{8AC58110-3925-481F-9D85-4B809D7D18B9}" EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU Debug|ARM = Debug|ARM Debug|ARM64 = Debug|ARM64 Debug|x64 = Debug|x64 Debug|x86 = Debug|x86 Release|Any CPU = Release|Any CPU Release|ARM = Release|ARM Release|ARM64 = Release|ARM64 Release|x64 = Release|x64 Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|Any CPU.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM64.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|ARM64.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x64.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x64.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x86.ActiveCfg = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Debug|x86.Build.0 = Debug|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|Any CPU.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|Any CPU.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM64.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|ARM64.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x64.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x64.Build.0 = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x86.ActiveCfg = Release|Any CPU {F60052E8-1201-4A5A-ADD7-6367C5424F74}.Release|x86.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|Any CPU.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM64.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|ARM64.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x64.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x64.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x86.ActiveCfg = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Debug|x86.Build.0 = Debug|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|Any CPU.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|Any CPU.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM64.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|ARM64.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x64.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x64.Build.0 = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x86.ActiveCfg = Release|Any CPU {8AC58110-3925-481F-9D85-4B809D7D18B9}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {949E7C1D-8E95-46CF-B659-C6A15678A0D5} EndGlobalSection EndGlobal ================================================ FILE: README.md ================================================ # OBD.NET C#-Library to read/write data from/to a car through an ELM327-/STN1170-Adapter ## Projects * [OBD.NET](https://www.nuget.org/packages/OBD.NET) - OBD-II implementation in .NET 6/5 and .NET Framework 4.8 * ConsoleClient - Example client application using SerialConnection, running with .NET 6 ## Usage * Add the `OBD.NET` package to project ```csharp public class Program { public static void Main(string[] args) { if (args.Length < 1) { Console.WriteLine("Parameter ComPort needed."); IEnumerable availablePorts = SerialConnection.GetAvailablePorts(); Console.WriteLine("\nAvailable ports:"); foreach (string port in availablePorts) { Console.WriteLine(port); } return; } string comPort = args[0]; using SerialConnection connection = new SerialConnection(comPort); using ELM327 dev = new ELM327(connection, new OBDConsoleLogger(OBDLogLevel.Debug)); dev.SubscribeDataReceived((sender, data) => Console.WriteLine("EngineRPM: " + data.Data.Rpm)); dev.SubscribeDataReceived((sender, data) => Console.WriteLine("VehicleSpeed: " + data.Data)); dev.SubscribeDataReceived((sender, data) => Console.WriteLine($"PID {data.Data.PID.ToHexString()}: {data.Data}")); dev.Initialize(); dev.RequestData(); for (int i = 0; i < 5; i++) { dev.RequestData(); dev.RequestData(); Thread.Sleep(1000); } Console.ReadLine(); //Async example // MainAsync(comPort).Wait(); //Console.ReadLine(); } /// /// Async example using new RequestDataAsync /// /// The COM port. /// public static async Task MainAsync(string comPort) { using SerialConnection connection = new SerialConnection(comPort); using ELM327 dev = new ELM327(connection, new OBDConsoleLogger(OBDLogLevel.Debug)); dev.Initialize(); EngineRPM engineRpm = await dev.RequestDataAsync(); Console.WriteLine("Data: " + engineRpm.Rpm); engineRpm = await dev.RequestDataAsync(); Console.WriteLine("Data: " + engineRpm.Rpm); VehicleSpeed vehicleSpeed = await dev.RequestDataAsync(); Console.WriteLine("Data: " + vehicleSpeed.Speed); engineRpm = await dev.RequestDataAsync(); Console.WriteLine("Data: " + engineRpm.Rpm); } } ```