StreamDebugger/StreamDebugger.h at master · EnviroDIY/StreamDebugger · GitHub

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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
/**
 * @file       StreamDebugger.h
 * @author     Volodymyr Shymanskyy
 * @license    This project is released under the MIT License (MIT)
 * @copyright  Copyright (c) 2016 Volodymyr Shymanskyy
 * @date       Nov 2016
 */

#ifndef StreamDebugger_h
#define StreamDebugger_h

#include <Arduino.h>

class StreamDebugger
  : public Stream
{
  public:
    StreamDebugger() {}
    StreamDebugger(Stream& data, Stream& dump) {
      setDataStream(&data);
      setDumpStream(&dump);
    }

    virtual ~StreamDebugger() {}

    virtual size_t write(uint8_t ch) {
      if (_dump)
        _dump->write(ch);
      return _data ? _data->write(ch) : 0;
    }
    virtual size_t write(const uint8_t *buffer, size_t size)
    {
      if (_dump)
        _dump->write(buffer, size);
      return _data ? _data->write(buffer, size) : 0;
    }
    virtual size_t write(const char *buffer, size_t size)
    {
      if (_dump)
        _dump->write(buffer, size);
      return _data ? _data->write(buffer, size) : 0;
    }
    virtual int read() {
      if (!_data)
        return -1;
      int ch = _data->read();
      if (ch != -1 && _dump) {
        _dump->write(ch);
      }
      return ch;
    }
    virtual int available() { return _data ? _data->available() : 0; }
    virtual int peek() { return _data ? _data->peek() : -1; }
    virtual void flush() {
      if (_data)
        _data->flush();
    }

    void directAccess() {
      int r;
      while (true) {
        if (_data && _data->available() && (r = _data->read()) != -1 && _dump)
          _dump->write(r);
        if (_dump && _dump->available() && (r = _dump->read()) != -1 && _data)
          _data->write(r);
        delay(0);
      }
    }

    void directAccessNonBlocking() {
      int r;
      while (_data && _data->available() && (r = _data->read()) != -1)
        if (_dump)
          _dump->write(r);
      while (_dump && _dump->available() && (r = _dump->read()) != -1)
        if (_data)
          _data->write(r);
    }

    void setDataStream(Stream* data) {
      _data = data;
    }

    void setDumpStream(Stream* dump) {
      _dump = dump;
    }

  private:
    Stream* _data = nullptr;
    Stream* _dump = nullptr;
};

#endif