serial_processor.h

Go to the documentation of this file.

// Copyright (c) 2018, Smart Projects Holdings Ltd
// All rights reserved.
// See LICENSE file for license details.

#ifndef _UGCS_VSM_SERIAL_PROCESSOR_H_
#define _UGCS_VSM_SERIAL_PROCESSOR_H_

#include <ugcs/vsm/file_processor.h>
#include <ugcs/vsm/log.h>

namespace ugcs {
namespace vsm {

class Serial_processor: public File_processor {
    DEFINE_COMMON_CLASS(Serial_processor, Request_container)

public:
    class Stream: public File_processor::Stream {
        DEFINE_COMMON_CLASS(Stream, Io_stream)

    public:
        typedef Reference_guard<Ptr> Ref;

        class Mode {
        public:
            Mode() {}

            Mode &
            Baud(int baud)
            {
                this->baud = baud;
                return *this;
            }

            Mode &
            Char_size(int size)
            {
                char_size = size;
                return *this;
            }

            Mode &
            Stop_bit(bool enable)
            {
                stop_bit = enable;
                return *this;
            }

            Mode &
            Parity_check(bool enable)
            {
                parity_check = enable;
                return *this;
            }

            Mode &
            Parity(bool is_odd)
            {
                parity = is_odd;
                return *this;
            }

            Mode &
            Read_timeout(std::chrono::milliseconds timeout)
            {
                if (timeout.count() < 0) {
                    VSM_EXCEPTION(Invalid_param_exception, "Negative timeout specified.");
                }
                read_timeout = timeout;
                return *this;
            }

            int
            Get_baud() const
            {
                return baud;
            }

            int
            Get_char_size() const
            {
                return char_size;
            }

            bool
            Get_stop_bit() const
            {
                return stop_bit;
            }

            bool
            Get_parity_check() const
            {
                return parity_check;
            }

            bool
            Get_parity() const
            {
                return parity;
            }

        protected:
            // @{
            int baud = 1800;
            int char_size = 8;
            bool stop_bit = false;
            bool parity_check = false;
            bool parity = false;
            std::chrono::milliseconds read_timeout = std::chrono::milliseconds(100);
            // @}
        };

        Stream(Serial_processor::Ptr processor,
               const std::string& port_name,
               const Stream::Mode &mode,
               Native_handle::Unique_ptr&& native_handle);

    private:
        Serial_processor::Ptr processor;
        Mode mode;
    };

    template <typename... Args>
    static Ptr
    Get_instance(Args &&... args)
    {
        return singleton.Get_instance(std::forward<Args>(args)...);
    }

    Serial_processor();

    Stream::Ref
    Open(const std::string &port_name, const Stream::Mode &mode = Stream::Mode());

    static std::list<std::string>
    Enumerate_port_names();

    // Used in mac and linux.
    static const uint8_t MAX_VMIN;

private:
    static Singleton<Serial_processor> singleton;

    Stream::Native_handle::Unique_ptr
    Open_native_handle(const std::string &port_name, const Stream::Mode &mode);
};

} /* namespace vsm */
} /* namespace ugcs */

#endif /* _UGCS_VSM_SERIAL_PROCESSOR_H_ */