Home

Awesome

<div align="center"> <img src="https://github.com/asv-soft/asv-drones-gui-afis/assets/151620493/932425b6-547e-4d35-bf90-6430265c8e97" width="300px" margin-left="200px"> </div>

Deploy Nuget for Windows

Asv.Gnss

1. Introduction

GNSS library for parsing RTCMv2, RTCMv3, NMEA and control recievers througt SBF, ComNav, UBX protocols for .NET

This solution can be used with the main project Asv.Drones, you can find out more about it here. You can also use it in your own projects installing this library via nuget

    Install-Package Asv.Gnss -Version X.X.X

2. Example usage

2.1 If you want to use this library in your project, then here are some guidelines on how to use it:

// create connection with default parsers: Nmea,RTCMv2,RTCMv3,ComNav,Ubx,Sbf
var connection = GnssFactory.CreateDefault("tcp://10.10.5.28:64101");
// for TCP client connection:               tcp://127.0.0.1:9002
// for TCP server(listen) connection:       tcp://127.0.0.1:9002?srv=true
// for UDP connection:                      udp://127.0.0.1:1234?rhost=127.0.0.1&rport=1235
// for COM\serial port connection Linux:    serial:/dev/ttyACM0?br=115200
// for COM\serial port connection Windows:  serial:COM4?br=115200
connection
    .Filter<RtcmV2Message1>()
    .Subscribe(_ => { /* do something with RTCM Differential GPS Corrections (Fixed) message */ });
connection
    .Filter<RtcmV3Message1006>()
    .Subscribe(_ => { /* do something with RTCM 1006 Stationary RTK Reference Station ARP */ });
    
// you can control GNSS receivers through connection too


// for example configures the SinoGNSS receiver to fix the height at the last calculated value
ComNavAsciiCommandHelper.FixAuto(connection);
// enable send NMEA GPGLL messages through 1 sec 
ComNavAsciiCommandHelper.LogCommand(connection, ComNavMessageEnum.GPGLL, period: 1, trigger: ComNavTriggerEnum.ONTIME).Wait();

2.2 And here is an example for UBlox devices:

var device = new UbxDevice("serial:COM10?br=115200");
await device.SetupByDefault();
await device.SetSurveyInMode(minDuration: 60, positionAccuracyLimit: 2);
device.Connection.Filter<RtcmV3Msm4>().Subscribe(_ => { /* do something with RTCM */ });

2.3 How To Build Asv-GNSS using Asv.Drones

2.3.1 Setup required dependencies for Asv.Drones: Make sure next components installed:

.NET SDK 7 - https://dotnet.microsoft.com/en-us/download/dotnet/7.0 ; AvaloniaUI - https://docs.avaloniaui.net/docs/get-started/install ; Execute dotnet install (package name) command to setup required packages.

2.3.2 Clone project repository: git clone https://github.com/your-repository-url.git

3. Getting Started

Setting Up the Development Environment

To ensure a smooth development experience, follow the steps below to set up your development environment:

1. Prerequisites:

2. .NET Installation:

3. Version Control:

4. Clone the Repository:

5. Restore Dependencies:

6. Open in IDE:

7. Build and Run:

Congratulations! Your development environment is now set up, and you are ready to start contributing to the project. If you encounter any issues during the setup process, refer to the project's documentation or reach out to the development team for assistance.

4. Code Structure

The organization of the codebase plays a crucial role in maintaining a clean, scalable, and easily understandable project. This section outlines the structure of our codebase, highlighting key directories and their purposes.

4.1 Solution Organization

Our solution is organized the following way:

4.2 Naming Conventions

Consistent naming conventions are essential for code readability. Throughout the codebase, we follow the guidelines outlined in our documentation

These conventions contribute to a unified and coherent codebase.

By adhering to this organized structure and naming conventions, we aim to create a codebase that is easy to navigate, scalable, and conducive to collaboration among developers.

5. Coding Style

Maintaining a consistent coding style across the project enhances readability, reduces errors, and facilitates collaboration. The following guidelines outline our preferred coding style for C#:

5.1 C# Coding Style

5.1.1 Formatting

5.1.2 Naming Conventions

5.1.3 Language Features

5.2 Documentation

5.2.1 Comments

5.2.2 Code Comments

By adhering to these coding style guidelines, we aim to create code that is easy to read, understand, and maintain.

6. Version Control

Version control is a fundamental aspect of our development process, providing a systematic way to track changes, collaborate with team members, and manage the evolution of our codebase. We utilize Git as our version control system.

6.1 Branching Strategy

6.1.1 Feature Branches

For each new feature or bug fix, create a dedicated feature branch. The branch name should be descriptive of the feature or issue it addresses.

# Example: Creating a new feature branch
git checkout -b feature/my-new-feature

5.1.2 Hotfix Branches

In case of critical issues in the production environment, create a hotfix branch. This allows for a quick resolution without affecting the main development branch.

# Example: Creating a hotfix branch
git checkout -b hotfix/1.0.1

6.2 Commit Messages

Write clear and concise commit messages that convey the purpose of the change. Follow these guidelines:

Example:

# Good
git commit -m "Add user authentication feature"

# Bad
git commit -m "Updated stuff"

6.3 Pull Requests

Before merging changes into the main branch, create a pull request (PR). This allows for code review and ensures that changes adhere to coding standards.

6.4 Merging Strategy

Adopt a merging strategy based on the nature of the changes:

# Example: Merging a feature branch
git checkout main
git merge --no-ff feature/my-new-feature

6.5 Repository Hosting

Our Git repository is hosted on GitHub. Ensure that you have the necessary permissions and follow best practices for repository management.

By following these version control practices, we aim to maintain a well-organized and collaborative development process.

7. Build and Deployment

The build and deployment processes are crucial components of our development workflow. This section outlines the steps for building the project and deploying it using GitHub Releases.

7.1 Build Process

To compile the project, use the following command:

dotnet build

This command compiles the code and produces executable binaries.

7.2 Deployment using GitHub Releases

Our application is deployed using GitHub Releases.

Latest release can be found here.

8. Contributing

We welcome contributions from the community to help enhance and improve our project. Before contributing, please take a moment to review this guide.

8.1 Code Reviews

All code changes undergo a review process to ensure quality and consistency. Here are the steps to follow:

  1. Fork the Repository: Start by forking the repository to your own GitHub account.

  2. Create a Feature Branch: Create a new branch for your feature or bug fix.

    git checkout -b feature/my-feature
    
  3. Commit Changes: Make your changes, commit them with clear and concise messages, and push the branch to your forked repository.

    git commit -m "Add new feature"
    git push origin feature/my-feature
    
  4. Open a Pull Request (PR): Submit a pull request to the main repository, detailing the changes made and any relevant information. Ensure your PR adheres to the established coding standards.

  5. Code Review: Participate in the code review process by responding to feedback and making necessary adjustments. Addressing comments promptly helps streamline the review process.

  6. Merge: Once the code review is complete and the changes are approved, your pull request will be merged into the main branch.

8.2 Submitting Changes

Before submitting changes, ensure the following:

8.3 Communication

For larger changes or feature additions, it's beneficial to discuss the proposed changes beforehand. Engage with the community through:

8.4 Contributor License Agreement (CLA)

By contributing to this project, you agree that your contributions will be licensed under the project's license. If a Contributor License Agreement (CLA) is required, it will be provided in the repository.

We appreciate your contributions, and together we can make this project even better!

9. Code Documentation

Clear and comprehensive code documentation is essential for ensuring that developers can easily understand, use, and contribute to the project. Follow these guidelines for documenting your code:

9.1 Inline Comments

Use inline comments to explain specific sections of your code, especially for complex logic or non-intuitive implementations. Follow these principles:

Example:

// Calculate the sum of two numbers
int CalculateSum(int a, int b)
{
    return a + b;
}

9.2 XML Documentation

For classes, methods, properties, and other significant code elements, use XML documentation comments to provide comprehensive information. Follow these guidelines:

Example:

/// <summary>
/// Represents a utility class for mathematical operations.
/// </summary>
public class MathUtility
{
    /// <summary>
    /// Calculates the sum of two numbers.
    /// </summary>
    /// <param name="a">The first number.</param>
    /// <param name="b">The second number.</param>
    /// <returns>The sum of the two numbers.</returns>
    public int CalculateSum(int a, int b)
    {
        return a + b;
    }
}

9.3 Consistency

Ensure consistency in your documentation style across the codebase. Consistent documentation makes it easier for developers to navigate and understand the project.

By following these documentation guidelines, we aim to create a codebase that is not only functional but also accessible and easily maintainable for all contributors.

9. Security

Ensuring the security of our software is paramount to maintaining the integrity and confidentiality of user data. Developers should adhere to best practices and follow guidelines outlined in this section.

10.1 Code Security Practices

10.1.1 Input Validation

Always validate and sanitize user input to prevent injection attacks and ensure the integrity of your application.

// Example for C#
public ActionResult ProcessUserInput(string userInput)
{
    if (string.IsNullOrWhiteSpace(userInput))
    {
        // Handle invalid input
    }

    // Process input
}

10.1.2 Authentication and Authorization

Implement secure authentication and authorization mechanisms to control access to sensitive functionalities and data. Leverage industry-standard protocols like OAuth when applicable.

10.1.3 Secure Communication

Ensure that communication between components, APIs, and external services is encrypted using secure protocols (e.g., HTTPS).

10.2 Dependency Security

10.2.1 Dependency Scanning

Regularly scan and update dependencies to identify and address security vulnerabilities. Leverage tools and services that provide automated dependency analysis.

10.2.2 Minimal Dependencies

Keep dependencies to a minimum and only include libraries and packages that are actively maintained and have a good security track record.

10.3 Data Protection

10.3.1 Encryption

Sensitive data, both at rest and in transit, should be encrypted. Utilize strong encryption algorithms and ensure proper key management.

10.3.2 Data Backups

Implement regular data backup procedures to prevent data loss in the event of security incidents or system failures.

10.4 Secure Coding Standards

Adhere to secure coding standards to mitigate common vulnerabilities. Follow principles such as the OWASP Top Ten to address security concerns in your codebase.

10.5 Reporting Security Issues

If you discover a security vulnerability or have concerns about the security of the project, please report it immediately to our team at our telegram channel. Do not disclose security-related issues publicly until they have been addressed.

10.6 Security Training

Encourage ongoing security training for all team members to stay informed about the latest security threats and best practices. Knowledgeable developers are key to maintaining a secure codebase.

By incorporating security practices into our development process, we aim to create a robust and secure software environment for our users.

11. License

This project is licensed under the terms of the MIT License. A copy of the MIT License is provided in the LICENSE file.

MIT License

MIT License
https://github.com/asv-soft/asv-gnss?tab=MIT-1-ov-file
Copyright (c) 2023 Asv Soft

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Using the MIT License

The MIT License is a permissive open-source license that allows for the free use, modification, and distribution of the software. It is important to review and understand the terms of the license before using, contributing to, or distributing this software.

By contributing to this project, you agree that your contributions will be licensed under the MIT License.

For more details about the MIT License, please visit opensource.org/licenses/MIT.

12. Contact

If you have questions, suggestions, or need assistance with the project, we encourage you to reach out through the following channels:

12.1 Telegram Channel

Visit our Telegram channel: ASVSoft on Telegram

Feel free to join our Telegram community to engage in discussions, seek help, or share your insights.

12.2 GitHub Issues

For bug reports, feature requests, or any project-related discussions, please use our GitHub Issues:

Project Issues on GitHub

Our GitHub repository is the central hub for project-related discussions and issue tracking. Please check existing issues before creating new ones to avoid duplication.

12.3 Security Concerns

If you discover a security vulnerability or have concerns about the security of the project, please report it immediately to our telegram channel: ASVSoft on Telegram. Do not disclose security-related issues publicly until they have been addressed.

12.4 General Inquiries

For general inquiries or if you prefer email communication, you can reach us at me@asv.me.

We value your feedback and contributions, and we look forward to hearing from you!