← Back to branch summary

~vibhavp/ubuntu/saucy/urg/merge-from-debian

« back to all changes in this revision

Viewing changes to src/cpp/connection/SerialDevice.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Albert Huang
  • Date: 2011-05-20 11:33:03 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110520113303-u8niofzwzcea0osk
Tags: 0.8.12-1
http://bugs.debian.org/624987
* New upstream release (closes: #624987)
* Add debian/watch file
* Bump standards-version to 3.9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/cpp/connection/SerialDevice.cpp
4
4
 
5
5
  \author Satofumi KAMIMURA
6
6
 
7
 
  $Id: SerialDevice.cpp 1454 2009-10-26 03:59:39Z satofumi $
 
7
  $Id: SerialDevice.cpp 1811 2010-04-30 16:12:05Z satofumi $
8
8
*/
9
9
 
10
10
#include "SerialDevice.h"
25
25
 
26
26
struct SerialDevice::pImpl
27
27
{
28
 
  string error_message_;
29
 
  long baudrate_;
30
 
  RawSerialDevice raw_;
31
 
  RingBuffer<char> ring_buffer_; //!< ��M�o�b�t�@
32
 
 
33
 
 
34
 
  pImpl(void) : error_message_("no error"), baudrate_(0)
35
 
  {
36
 
  }
37
 
 
38
 
 
39
 
  void updateRingBuffer(void)
40
 
  {
41
 
    enum { BufferSize = 2048 };
42
 
    char buffer[BufferSize];
43
 
 
44
 
    int n = raw_.receive(buffer, BufferSize, 0);
45
 
    if (n > 0) {
46
 
      ring_buffer_.put(buffer, n);
47
 
    }
48
 
  }
49
 
 
50
 
 
51
 
  int receive(char* data, size_t count, int timeout)
52
 
  {
53
 
    if (! isConnected()) {
54
 
      error_message_ = "no connection.";
55
 
      return -1;
56
 
    }
57
 
    if (count == 0) {
58
 
      return 0;
59
 
    }
60
 
 
61
 
    size_t filled = 0;
62
 
 
63
 
    size_t ring_filled = ring_buffer_.size();
64
 
    if (ring_filled < count) {
65
 
      updateRingBuffer();
66
 
    }
67
 
 
68
 
    // �o�b�t�@�Ƀf�[�^������ꍇ�A�o�b�t�@����f�[�^���i�[����
69
 
    size_t read_size = std::min(count, ring_buffer_.size());
70
 
    ring_buffer_.get(data, read_size);
71
 
    filled += read_size;
72
 
 
73
 
    // �o�b�t�@����̏ꍇ�A�c��̃f�[�^�̓V�X�e�����璼�ړǂݍ���
74
 
    read_size = max(0, static_cast<int>(count - filled));
75
 
    if (read_size > 0) {
76
 
      int n = raw_.receive(&data[filled], static_cast<int>(read_size), timeout);
77
 
      if (n < 0) {
78
 
        error_message_ = raw_.what();
79
 
        return n;
80
 
      }
81
 
      filled += n;
82
 
    }
83
 
    return static_cast<int>(filled);
84
 
  }
85
 
 
86
 
 
87
 
  bool isConnected(void)
88
 
  {
89
 
    return raw_.isConnected();
90
 
  }
 
28
    string error_message_;
 
29
    long baudrate_;
 
30
    RawSerialDevice raw_;
 
31
    RingBuffer<char> ring_buffer_; //!< ��M�o�b�t�@
 
32
 
 
33
 
 
34
    pImpl(void) : error_message_("no error"), baudrate_(0)
 
35
    {
 
36
    }
 
37
 
 
38
 
 
39
    void updateRingBuffer(void)
 
40
    {
 
41
        enum { BufferSize = 2048 };
 
42
        char buffer[BufferSize];
 
43
 
 
44
        int n = raw_.receive(buffer, BufferSize, 0);
 
45
        if (n > 0) {
 
46
            ring_buffer_.put(buffer, n);
 
47
        }
 
48
    }
 
49
 
 
50
 
 
51
    int receive(char* data, size_t count, int timeout)
 
52
    {
 
53
        if (! isConnected()) {
 
54
            error_message_ = "no connection.";
 
55
            return -1;
 
56
        }
 
57
        if (count == 0) {
 
58
            return 0;
 
59
        }
 
60
 
 
61
        size_t filled = 0;
 
62
 
 
63
        size_t ring_filled = ring_buffer_.size();
 
64
        if (ring_filled < count) {
 
65
            updateRingBuffer();
 
66
        }
 
67
 
 
68
        // �o�b�t�@�Ƀf�[�^������ꍇ�A�o�b�t�@����f�[�^���i�[����
 
69
        size_t read_size = std::min(count, ring_buffer_.size());
 
70
        ring_buffer_.get(data, read_size);
 
71
        filled += read_size;
 
72
 
 
73
        // �o�b�t�@����̏ꍇ�A�c��̃f�[�^�̓V�X�e�����璼�ړǂݍ���
 
74
        read_size = max(0, static_cast<int>(count - filled));
 
75
        if (read_size > 0) {
 
76
            int n = raw_.receive(&data[filled],
 
77
                                 static_cast<int>(read_size), timeout);
 
78
            if (n < 0) {
 
79
                error_message_ = raw_.what();
 
80
                return n;
 
81
            }
 
82
            filled += n;
 
83
        }
 
84
        return static_cast<int>(filled);
 
85
    }
 
86
 
 
87
 
 
88
    bool isConnected(void)
 
89
    {
 
90
        return raw_.isConnected();
 
91
    }
91
92
};
92
93
 
93
94
 
98
99
 
99
100
SerialDevice::~SerialDevice(void)
100
101
{
101
 
  disconnect();
 
102
    disconnect();
102
103
}
103
104
 
104
105
 
105
106
const char* SerialDevice::what(void) const
106
107
{
107
 
  return pimpl->error_message_.c_str();
 
108
    return pimpl->error_message_.c_str();
108
109
}
109
110
 
110
111
 
111
112
bool SerialDevice::connect(const char* device, long baudrate)
112
113
{
113
 
  disconnect();
114
 
  clear();
115
 
  if (! pimpl->raw_.connect(device, baudrate)) {
116
 
    pimpl->error_message_ = pimpl->raw_.what();
117
 
    return false;
118
 
  } else {
119
 
    return true;
120
 
  }
 
114
    disconnect();
 
115
    clear();
 
116
    if (! pimpl->raw_.connect(device, baudrate)) {
 
117
        pimpl->error_message_ = pimpl->raw_.what();
 
118
        return false;
 
119
    } else {
 
120
        return true;
 
121
    }
121
122
}
122
123
 
123
124
 
124
125
void SerialDevice::disconnect(void)
125
126
{
126
 
  return pimpl->raw_.disconnect();
 
127
    return pimpl->raw_.disconnect();
127
128
}
128
129
 
129
130
 
130
131
bool SerialDevice::setBaudrate(long baudrate)
131
132
{
132
 
  if (! pimpl->raw_.setBaudrate(baudrate)) {
133
 
    pimpl->error_message_ = pimpl->raw_.what();
134
 
    pimpl->baudrate_ = 0;
135
 
    return false;
136
 
  }
137
 
  pimpl->baudrate_ = baudrate;
138
 
  return true;
 
133
    if (! pimpl->raw_.setBaudrate(baudrate)) {
 
134
        pimpl->error_message_ = pimpl->raw_.what();
 
135
        pimpl->baudrate_ = 0;
 
136
        return false;
 
137
    }
 
138
    pimpl->baudrate_ = baudrate;
 
139
    return true;
139
140
}
140
141
 
141
142
 
142
143
long SerialDevice::baudrate(void) const
143
144
{
144
 
  return pimpl->baudrate_;
 
145
    return pimpl->baudrate_;
145
146
}
146
147
 
147
148
 
148
149
bool SerialDevice::isConnected(void) const
149
150
{
150
 
  return pimpl->isConnected();
 
151
    return pimpl->isConnected();
151
152
}
152
153
 
153
154
 
154
155
int SerialDevice::send(const char* data, size_t count)
155
156
{
156
 
  if (! isConnected()) {
157
 
    pimpl->error_message_ = "no connection.";
158
 
    return 0;
159
 
  }
 
157
    if (! isConnected()) {
 
158
        pimpl->error_message_ = "no connection.";
 
159
        return 0;
 
160
    }
160
161
 
161
 
  int n = pimpl->raw_.send(data, static_cast<int>(count));
162
 
  if (n < 0) {
163
 
    pimpl->error_message_ = pimpl->raw_.what();
164
 
  }
165
 
  return n;
 
162
    int n = pimpl->raw_.send(data, static_cast<int>(count));
 
163
    if (n < 0) {
 
164
        pimpl->error_message_ = pimpl->raw_.what();
 
165
    }
 
166
    return n;
166
167
}
167
168
 
168
169
 
169
170
int SerialDevice::receive(char* data, size_t count, int timeout)
170
171
{
171
 
  if (! isConnected()) {
172
 
    pimpl->error_message_ = "no connection.";
173
 
    return 0;
174
 
  }
 
172
    if (! isConnected()) {
 
173
        pimpl->error_message_ = "no connection.";
 
174
        return 0;
 
175
    }
175
176
 
176
 
  return pimpl->receive(data, count, timeout);
 
177
    return pimpl->receive(data, count, timeout);
177
178
}
178
179
 
179
180
 
180
181
size_t SerialDevice::size(void) const
181
182
{
182
 
  pimpl->updateRingBuffer();
183
 
  return pimpl->ring_buffer_.size();
 
183
    pimpl->updateRingBuffer();
 
184
    return pimpl->ring_buffer_.size();
184
185
}
185
186
 
186
187
 
187
188
void SerialDevice::flush(void)
188
189
{
189
 
  if (! isConnected()) {
190
 
    pimpl->error_message_ = "no connection.";
191
 
    return;
192
 
  }
 
190
    if (! isConnected()) {
 
191
        pimpl->error_message_ = "no connection.";
 
192
        return;
 
193
    }
193
194
 
194
 
  return pimpl->raw_.flush();
 
195
    return pimpl->raw_.flush();
195
196
}
196
197
 
197
198
 
198
199
void SerialDevice::clear(void)
199
200
{
200
 
  pimpl->raw_.flush();
201
 
  pimpl->ring_buffer_.clear();
 
201
    pimpl->raw_.flush();
 
202
    pimpl->ring_buffer_.clear();
202
203
}
203
204
 
204
205
 
205
206
void SerialDevice::ungetc(const char ch)
206
207
{
207
 
  if (! isConnected()) {
208
 
    pimpl->error_message_ = "no connection.";
209
 
    return;
210
 
  }
 
208
    if (! isConnected()) {
 
209
        pimpl->error_message_ = "no connection.";
 
210
        return;
 
211
    }
211
212
 
212
 
  pimpl->ring_buffer_.ungetc(ch);
 
213
    pimpl->ring_buffer_.ungetc(ch);
213
214
}