serialPort1->PortName=...
serialPort1->Open();

In Boost geht das alles irgendwie unnötig kompliziert.
http://www.boost.org/doc/libs/1_41_0/doc/html/boost_asio/overview/serial_ports.html

Also erst einmal braucht man ein IO Device, warum auch immer.

io_service io;
serial_port port( io, "COM1" );

Aber warum man jetzt nicht einfach.

Die Einstellungen sind auch total aufwendig:

port.set_option(boost::asio::serial_port_base::baud_rate(9600) );

Da braucht man erst einmal ein Baudraten Objekt, warum auch immer.

Aber warum ich jetzt nicht einfach

port.open();

machen kann erschließt
sich mir immer noch nicht.

Kann mir da bitte jemand helfen? Ich möchte einen Seriellen Port erstellen, den Port Namen und die Baudrate einstellen, den Port öffnen, ein Zeichen senden und wieder schließen. In .Net war das alles selbsterklärend. In Boost irgendwie überhaupt nicht.

Ich kenne mich aber nicht mit serial_port aus. Du könntest ja mal diesen Code ausprobieren:

http://www.college-code.com/blog/wp-content/uploads/2008/11/boost_serial_port_demo.cpp

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;
    }
}

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);

Simon

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(...);

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.

#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?

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

Simon

#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.

Sind Statische Objekte in der Verwendung besser als Dynamische?

Kann man nicht generell sagen.

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

Simon

#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?

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.