| Autor |
Nachricht |
Markus W.
Unregistrierter
|
Markus W. Unregistrierter
19:19:37 08.03.2010 Titel: |
Boost Serielle Schnittstelle |
Zitieren |
Hallo,
ich habe bis jetzt immer die von .Net zur Verfügung gestellte Schnittstelle genutzt. Jetzt möchte ich mein Programm aber wahrscheinlich doch in der Konsole entwickeln. Dazu habe ich mir mal die boost Lib angesehen.
In .Net ging das ja ganz einfach:
| C/C++ Code: | serialPort1->PortName=...
serialPort1->Open();
| |
| C/C++ Code: | serialPort1->PortName=...
serialPort1->Open();
| |
| C/C++ Code: | 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.
| C/C++ Code: | io_service io;
serial_port port( io, "COM1" ); | |
| C/C++ Code: | io_service io;
serial_port port( io, "COM1" ); | |
| C/C++ Code: | io_service io;
serial_port port( io, "COM1" ); | |
Aber warum man jetzt nicht einfach.
Die Einstellungen sind auch total aufwendig:
| C/C++ Code: | | port.set_option(boost::asio::serial_port_base::baud_rate(9600) ); | |
| C/C++ Code: | | port.set_option(boost::asio::serial_port_base::baud_rate(9600) ); | |
| C/C++ Code: | | 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 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. |
|
|
|
|
evilissimo
Chefkoch
Benutzerprofil
Anmeldungsdatum: 12.11.2003
Beiträge: 2283
|
|
evilissimo Chefkoch
21:05:04 08.03.2010 Titel: |
|
Zitieren |
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
21:16:41 08.03.2010 Titel: |
|
Zitieren |
Wie erstelle ich denn dann einen Port, ohne ihn zu öffnen? Wenn ich das "COM1" beim erstellen weglasse kommt eine exception. |
|
|
|
|
theta
Mitglied
Benutzerprofil
Anmeldungsdatum: 26.09.2008
Beiträge: 3814
|
|
theta Mitglied
00:19:28 09.03.2010 Titel: |
|
Zitieren |
Lies die Dokumentation genauer:
Hier eine Einstiegshilfe:
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 | #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;
}
} | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 | #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;
}
} | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33 | #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;
}
} | |
|
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
01:05:38 09.03.2010 Titel: |
|
Zitieren |
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. |
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
11:18:00 11.03.2010 Titel: |
|
Zitieren |
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. |
|
|
|
|
blub²
Mitglied
Benutzerprofil
Anmeldungsdatum: 07.03.2008
Beiträge: 458
|
|
blub² Mitglied
11:47:11 11.03.2010 Titel: |
|
Zitieren |
Wie hast du es denn bisher integriert? Du musst halt dafür sorgen dass wenn jemand auf deinen Button drückt z.B.
| C/C++ Code: | | serialPort.set_option(serial_port::baud_rate(9600));
| |
| C/C++ Code: | | serialPort.set_option(serial_port::baud_rate(9600));
| |
| C/C++ Code: | | 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:
| C/C++ Code: | | mySerialPort.setBaudRate(38400);
| |
| C/C++ Code: | | mySerialPort.setBaudRate(38400);
| |
| C/C++ Code: | | mySerialPort.setBaudRate(38400);
| |
|
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
22:52:38 11.03.2010 Titel: |
|
Zitieren |
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. |
|
|
|
|
theta
Mitglied
Benutzerprofil
Anmeldungsdatum: 26.09.2008
Beiträge: 3814
|
|
theta Mitglied
23:01:25 11.03.2010 Titel: |
|
Zitieren |
Sehe dein Problem nicht. Mach halt ein Dialog, der die Settings hat und leite diese dann bei OnOk() an die Serielle Schnittstelle weiter.
Simon |
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
23:05:29 11.03.2010 Titel: |
|
Zitieren |
Naja im Moment bin ich ja noch in der Konsole da gibts keinen Button ;-). |
|
|
|
|
theta
Mitglied
Benutzerprofil
Anmeldungsdatum: 26.09.2008
Beiträge: 3814
|
|
theta Mitglied
23:38:38 11.03.2010 Titel: |
|
Zitieren |
Aha, und auch da gibts kein Problem, oder? |
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
00:01:54 12.03.2010 Titel: |
|
Zitieren |
Naja ich finde es halt recht unübersichtlich jedes mal wenn ich die Schnittstelle wo brauche so etwas schreiben zu müssen:
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12 | 1
2
3
4
5
6
7
8
9
10
11
12 | 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(); | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12 | 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(); | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12 | 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(...); |
|
|
|
|
branleb
Mitglied
Benutzerprofil
Anmeldungsdatum: 29.05.2005
Beiträge: 566
|
|
branleb Mitglied
00:41:03 12.03.2010 Titel: |
|
Zitieren |
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. |
_________________
Don't hate the Hacker. Hate the Code!
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
00:49:15 26.03.2010 Titel: |
|
Zitieren |
So ich habe jetzt mal versucht davon eine Klasse abzuleiten:
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | #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 */
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | #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 */
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | #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 */
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | #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));
} | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | #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));
} | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | #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:
| Code: | 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
| |
| Code: | 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
| |
| Code: | 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? |
|
|
|
|
theta
Mitglied
Benutzerprofil
Anmeldungsdatum: 26.09.2008
Beiträge: 3814
|
|
theta Mitglied
10:13:51 26.03.2010 Titel: |
|
Zitieren |
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 |
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
11:58:53 26.03.2010 Titel: |
|
Zitieren |
Meinst du eher so:
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | #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 */
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | #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 */
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | #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 */
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9 | 1
2
3
4
5
6
7
8
9 | #include "SerialPort.h"
SerialPort::SerialPort():ioService(new boost::asio::io_service), serialPort(new boost::asio::serial_port(*ioService)){
}
SerialPort::~SerialPort() {
delete serialPort;
delete ioService;
}
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9 | #include "SerialPort.h"
SerialPort::SerialPort():ioService(new boost::asio::io_service), serialPort(new boost::asio::serial_port(*ioService)){
}
SerialPort::~SerialPort() {
delete serialPort;
delete ioService;
}
| |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9 | #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. |
|
|
|
|
theta
Mitglied
Benutzerprofil
Anmeldungsdatum: 26.09.2008
Beiträge: 3814
|
|
theta Mitglied
12:11:48 26.03.2010 Titel: |
|
Zitieren |
| Zitat: | | Sind Statische Objekte in der Verwendung besser als Dynamische? |
Kann man nicht generell sagen.
Edit:
Ja, ich meinte eher so (keine Vererbung mehr).
Simon |
Zuletzt bearbeitet von theta am 12:12:36 26.03.2010, insgesamt 1-mal bearbeitet |
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
12:33:56 26.03.2010 Titel: |
|
Zitieren |
so hier die aktuelle Implementation:
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 | #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;
}
} | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 | #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;
}
} | |
| C/C++ Code: | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50 | #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? |
|
|
|
|
Markus W.
Unregistrierter
|
|
Markus W. Unregistrierter
17:19:28 26.03.2010 Titel: |
|
Zitieren |
|
|
Twitter
Facebook