3. Boost Serielle Schnittstelle

Boost Serielle Schnittstelle

  • T

    Lies die Dokumentation genauer:

    Hier eine Einstiegshilfe:

    #include <string>
#include <iostream>
#include <boost\asio.hpp>
#include <boost\system\system_error.hpp>

int _tmain(int /*argc*/, _TCHAR* /*argv*/[])
{
    using namespace boost::system;
    using namespace boost::asio;

    io_service ioService;
    serial_port serialPort(ioService);

    try
    {
        serialPort.open("\\\\.\\COM1");

        serialPort.set_option(serial_port::baud_rate(9600));
        serialPort.set_option(serial_port::parity(serial_port::parity::none));
        serialPort.set_option(serial_port::character_size(serial_port::character_size(8)));
        serialPort.set_option(serial_port::stop_bits(serial_port::stop_bits::one));
        serialPort.set_option(serial_port::flow_control(serial_port::flow_control::none));

        std::string s = "test";
        serialPort.write_some(buffer(s));

        serialPort.close();
    }
    catch (system_error& error)
    {
        std::cout << error.what() << std::endl;
    }
}
    0
  • ?

    Gut mein Fehler war, dass man anscheinend nicht die Eigenschaften setzen kann, bevor der COM Port geöffnet ist.
    Nur wie integriere ich so was in mein Projekt. Also das ich per Menü den COM Port setzen kann verbinden und trennen etc. Schreibt man dafür eine Klasse, die den ganzen Aufwand verbirgt? Oder via Funktion, was ja aber nicht im Sinne der OOP ist.

    0
  • ?

    Kann mir keiner helfen und erklären, wie man so was in ein Projekt implementiert. Es geht ja nicht einmal um boost, sondern allgemein um solche fremden Libs.

    0
  • B

    Wie hast du es denn bisher integriert? Du musst halt dafür sorgen dass wenn jemand auf deinen Button drückt z.B.

    serialPort.set_option(serial_port::baud_rate(9600));

    ausgeführt wird.

    Wie du das dann genau umsetzt hängt von der Situation ab. Du kannst das ganze natürlich in eine Klasse packen und dann irgendwie sowas machen:

    mySerialPort.setBaudRate(38400);
    0
  • ?

    Bisher habe ich es halt in der Main drinnen, da ich erst einmal in der Konsole teste. Und es ist halt extrem unübersichtlich wie ich finde, wenn ich um eine Schnittstelle einzustellen etliche Befehle brauche.

    0
  • T

    Sehe dein Problem nicht. Mach halt ein Dialog, der die Settings hat und leite diese dann bei OnOk() an die Serielle Schnittstelle weiter.

    Simon

    0
  • ?

    Naja im Moment bin ich ja noch in der Konsole da gibts keinen Button ;-).

    0
  • T

    Aha, und auch da gibts kein Problem, oder?

    0
  • ?

    Naja ich finde es halt recht unübersichtlich jedes mal wenn ich die Schnittstelle wo brauche so etwas schreiben zu müssen:

    serialPort.open("\\\\.\\COM1");

        serialPort.set_option(serial_port::baud_rate(9600));
        serialPort.set_option(serial_port::parity(serial_port::parity::none));
        serialPort.set_option(serial_port::character_size(serial_port::character_size(8)));
        serialPort.set_option(serial_port::stop_bits(serial_port::stop_bits::one));
        serialPort.set_option(serial_port::flow_control(serial_port::flow_control::none));

        std::string s = "test";
        serialPort.write_some(buffer(s));

        serialPort.close();

    Zumal mir nicht gefällt, dass man um die Optionen zu setzen die Schnittstelle erst öffnen muss. Das fand ich bei .Net besser gelöst.

    com->set...;
    com->open();
    com->send(...);
    com->close(...);

    0

  • Wenn dir die API nicht passt, such dir eine andere...

    Aber zum eigentlichen Problem:
    Verpack die Port Steuerung in eine eigene Port Klasse für dich.
    Kannst die Boostklasse ja als Basisklasse nehmen - oder als Member, auf dem du die Operationen ausführst. Dann musst du die optionen nicht "immer wieder" setzen.
    Setzen musst du sie, weil hier eben auch andere Werte möglich wären. Ich weis ja nicht, wie .Net das macht, wenn du ne andere Baudrate nutzen willst.

    0
  • ?

    So ich habe jetzt mal versucht davon eine Klasse abzuleiten:

    #ifndef SERIALPORT_H
#define	SERIALPORT_H
#include <boost/asio.hpp>
#include <string>

class SerialPort :public boost::asio::serial_port {
public:
    SerialPort();
    void set_name(const std::string &new_name) {name=new_name;}
    void set_baudrate(int new_baudrate) {baudrate=new_baudrate;}
    void open();
    void write(const std::string &text);

private:
    int baudrate;
    std::string name;
    boost::asio::io_service ioService;

};

#endif	/* SERIALPORT_H */

    #include "SerialPort.h"

SerialPort::SerialPort():boost::asio::serial_port(ioService) {

}

void SerialPort::open() {
    boost::asio::serial_port::open(name);
    boost::asio::serial_port::set_option(boost::asio::serial_port::baud_rate(baudrate));
    boost::asio::serial_port::set_option(boost::asio::serial_port::parity(boost::asio::serial_port::parity::none));
    boost::asio::serial_port::set_option(boost::asio::serial_port::character_size(boost::asio::serial_port::character_size(8)));
    boost::asio::serial_port::set_option(boost::asio::serial_port::stop_bits(boost::asio::serial_port::stop_bits::one));
    boost::asio::serial_port::set_option(boost::asio::serial_port::flow_control(boost::asio::serial_port::flow_control::none));
}

void SerialPort::write(const std::string &text) {
    boost::asio::serial_port::write_some(boost::asio::buffer(text));
}

    mit folgendem Ergebnis, beim Objekt anlegen:

    terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::system::system_error> >'
  what():  mutex: Invalid argument

    Der Fehler muss also schon im Konstruktor liegen. Ich versuche das Basisobjekt mit dem IoService zu Initialisieren. Das müsste doch eigentlich funktionieren, oder etwa nicht?

    0
  • T

    1. Warum leitest Du ab? Warum nicht einfach eine Komposition / Aggregation?
    2. Das ioService Objekt ist noch nicht konstruiert wenn es an den Konstruktor der Basis Klasse (serial_port) übergeben wird.

    BTW: Ev. gefällt Dir diese Implementation besser (sie ist sehr zu empfehlen):
    http://www.codeproject.com/KB/system/serial.aspx

    Simon

    0
  • ?

    Meinst du eher so:

    #ifndef SERIALPORT_H
#define	SERIALPORT_H
#include <boost/asio.hpp>
#include <string>

class SerialPort{
public:
    SerialPort();
    ~SerialPort();
    void set_name(const std::string &new_name) {name=new_name;}
    void set_baudrate(int new_baudrate) {baudrate=new_baudrate;}

private:
    int baudrate;
    std::string name;
    boost::asio::io_service *ioService;
    boost::asio::serial_port *serialPort;

};

#endif	/* SERIALPORT_H */

    #include "SerialPort.h"

SerialPort::SerialPort():ioService(new boost::asio::io_service), serialPort(new boost::asio::serial_port(*ioService)){
}

SerialPort::~SerialPort() {
    delete serialPort;
    delete ioService;
}

    Dazu noch mal ein paar Fragen.
    Ich habe das jetzt mit Dynamischen Objekten gemacht. Mit statischen habe ich es nciht hin bekommen. Sind Statische Objekte in der Verwendung besser als Dynamische?

    Die von dir genannte Lib läuft leider nur unter Windows.

    0
  • T

    Sind Statische Objekte in der Verwendung besser als Dynamische?

    Kann man nicht generell sagen.

    Edit:
    Ja, ich meinte eher so (keine Vererbung mehr).

    Simon

    0
  • ?

    so hier die aktuelle Implementation:

    #include "SerialPort.h"

SerialPort::SerialPort()
    :ioService(new boost::asio::io_service), serialPort(new boost::asio::serial_port(*ioService)),baudrate(0),name(""){
}

SerialPort::~SerialPort() {
    delete serialPort;
    delete ioService;
}

void SerialPort::open() {
    if(name=="" && baudrate==0) {
        throw "Kein Portname angegeben und keine Baudrate definiert!";
    }else if(name=="") {
        throw "Kein Portname angegeben!";
    } else if(baudrate==0) {
        throw "Keine Baudrate definiert!";
    }
    serialPort->open(name);
    serialPort->set_option(boost::asio::serial_port::baud_rate(baudrate));
    serialPort->set_option(boost::asio::serial_port::parity(boost::asio::serial_port::parity::none));
    serialPort->set_option(boost::asio::serial_port::character_size(boost::asio::serial_port::character_size(8)));
    serialPort->set_option(boost::asio::serial_port::stop_bits(boost::asio::serial_port::stop_bits::one));
    serialPort->set_option(boost::asio::serial_port::flow_control(boost::asio::serial_port::flow_control::none));
}

void SerialPort::close() {
    serialPort->close();
}

void SerialPort::write(const std::string &text) {
    serialPort->write_some(boost::asio::buffer(text));
}

void SerialPort::set_name(const std::string& new_name) {
    if(serialPort->is_open()) {
        throw "Port " + name + " ist geöffnet";
    }
    name=new_name;
}

void SerialPort::set_baudrate(int new_baudrate) {
    if(isOpen()) {
        serialPort->set_option(boost::asio::serial_port::baud_rate(new_baudrate));
        baudrate=new_baudrate;
    } else {
        baudrate=new_baudrate;
    }
}

    Kann man da noch was verbessern. Was jetzt noch fehlt ist die Read Implementierung. Ich würde das lesen in einen neuen Thread auslagern. Aber wie kann ich da am besten überprüfen, ob neue Bytes da sind, außer alle so und so viele ms zu lesen und gucken, ob was da ist?

    0
  • ?

    Hier ist was zum Daten Lesen.
    http://lists.boost.org/boost-users/2009/04/46978.php

    Das kann man anscheinend gut in einen Thread auslagern. Nur sehe ich bei dem Code noch nciht so richtig durch. Wie die Buffer etc. gehandhabt werden.

    0
Anmelden zum Antworten