MemoryDevice.h
Go to the documentation of this file.
1 /****
2  * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
3  * Created 2015 by Skurydin Alexey
4  * http://github.com/anakod/Sming
5  * All files of the Sming Core are provided under the LGPL v3 license.
6  *
7  * MemoryDevice.h
8  *
9  * @author: October 2020 - mikee47 <mike@sillyhouse.net>
10  *
11 */
12 
13 #pragma once
14 
15 #include "Device.h"
16 
17 namespace HSPI
18 {
23 class MemoryDevice : public Device
24 {
25 public:
26  using Device::Device;
27 
33  virtual size_t getSize() const = 0;
34 
39  virtual void prepareWrite(HSPI::Request& req, uint32_t address) = 0;
40 
47  void prepareWrite(HSPI::Request& req, uint32_t address, const void* data, size_t len)
48  {
49  prepareWrite(req, address);
50  req.out.set(data, len);
51  req.in.clear();
52  }
62  void write(uint32_t address, const void* data, size_t len)
63  {
64  Request req;
65  prepareWrite(req, address, data, len);
66  execute(req);
67  }
68 
69  void write(Request& req, uint32_t address, const void* data, size_t len, Callback callback = nullptr,
70  void* param = nullptr)
71  {
72  prepareWrite(req, address, data, len);
73  req.setAsync(callback, param);
74  execute(req);
75  }
76 
77  void write8(uint32_t address, uint8_t value)
78  {
79  Request req;
80  prepareWrite(req, address);
81  req.out.set8(value);
82  execute(req);
83  }
84 
85  void write8(Request& req, uint32_t address, uint8_t value, Callback callback = nullptr, void* param = nullptr)
86  {
87  prepareWrite(req, address);
88  req.out.set8(value);
89  req.in.clear();
90  req.setAsync(callback, param);
91  execute(req);
92  }
93 
94  void write16(uint32_t address, uint16_t value)
95  {
96  Request req;
97  prepareWrite(req, address);
98  req.out.set16(value);
99  execute(req);
100  }
101 
102  void write16(Request& req, uint32_t address, uint16_t value, Callback callback = nullptr, void* param = nullptr)
103  {
104  prepareWrite(req, address);
105  req.out.set16(value);
106  req.in.clear();
107  req.setAsync(callback, param);
108  execute(req);
109  }
110 
111  void write32(uint32_t address, uint32_t value)
112  {
113  Request req;
114  prepareWrite(req, address);
115  req.out.set32(value);
116  execute(req);
117  }
118 
119  void write32(Request& req, uint32_t address, uint32_t value, Callback callback = nullptr, void* param = nullptr)
120  {
121  prepareWrite(req, address);
122  req.out.set32(value);
123  req.in.clear();
124  req.setAsync(callback, param);
125  execute(req);
126  }
127 
128  void writeWord(Request& req, uint32_t address, uint32_t value, unsigned byteCount)
129  {
130  prepareWrite(req, address);
131  req.out.set32(value, byteCount);
132  req.in.clear();
133  execute(req);
134  }
135 
145  virtual void prepareRead(HSPI::Request& req, uint32_t address) = 0;
146 
153  void prepareRead(HSPI::Request& req, uint32_t address, void* buffer, size_t len)
154  {
155  prepareRead(req, address);
156  req.out.clear();
157  req.in.set(buffer, len);
158  }
159 
169  void read(uint32_t address, void* buffer, size_t len)
170  {
171  Request req;
172  prepareRead(req, address, buffer, len);
173  execute(req);
174  }
175 
176  uint8_t read8(uint32_t address)
177  {
178  Request req;
179  prepareRead(req, address);
180  req.in.set8(address);
181  execute(req);
182  return req.in.data8;
183  }
184 
185  uint16_t read16(uint32_t address)
186  {
187  Request req;
188  prepareRead(req, address);
189  req.in.set16(address);
190  execute(req);
191  return req.in.data16;
192  }
193 
194  uint32_t read32(uint32_t address)
195  {
196  Request req;
197  prepareRead(req, address);
198  req.in.set32(address);
199  execute(req);
200  return req.in.data32;
201  }
202 
203  uint32_t readWord(uint32_t address, unsigned byteCount)
204  {
205  Request req;
206  prepareRead(req, address);
207  req.in.set32(0, byteCount);
208  execute(req);
209  return req.in.data32;
210  }
211 
212  void read(Request& req, uint32_t address, void* buffer, size_t len, Callback callback = nullptr,
213  void* param = nullptr)
214  {
215  prepareRead(req, address, buffer, len);
216  req.setAsync(callback, param);
217  execute(req);
218  }
219 };
220 
221 } // namespace HSPI
void prepareRead(HSPI::Request &req, uint32_t address, void *buffer, size_t len)
Definition: MemoryDevice.h:153
Defines an SPI Request Packet.
Definition: HardwareSPI/src/include/HSPI/Request.h:45
void write(Request &req, uint32_t address, const void *data, size_t len, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:69
uint16_t read16(uint32_t address)
Definition: MemoryDevice.h:185
void set8(uint8_t data)
Set to single 8-bit value.
Definition: Data.h:83
Definition: Common.h:24
void(* Callback)(Request &request)
SPI completion callback routine.
Definition: HardwareSPI/src/include/HSPI/Request.h:29
uint8_t read8(uint32_t address)
Definition: MemoryDevice.h:176
Data in
Incoming data.
Definition: HardwareSPI/src/include/HSPI/Request.h:58
void writeWord(Request &req, uint32_t address, uint32_t value, unsigned byteCount)
Definition: MemoryDevice.h:128
Data out
Outgoing data.
Definition: HardwareSPI/src/include/HSPI/Request.h:57
void write8(Request &req, uint32_t address, uint8_t value, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:85
void set16(uint16_t data)
Set to single 16-bit value.
Definition: Data.h:92
void write8(uint32_t address, uint8_t value)
Definition: MemoryDevice.h:77
void clear()
Reset to zero-length.
Definition: Data.h:54
void prepareWrite(HSPI::Request &req, uint32_t address, const void *data, size_t len)
Definition: MemoryDevice.h:47
void read(uint32_t address, void *buffer, size_t len)
Read a block of data.
Definition: MemoryDevice.h:169
Device(Controller &controller)
Definition: Libraries/HardwareSPI/src/include/HSPI/Device.h:38
virtual void prepareWrite(HSPI::Request &req, uint32_t address)=0
void write32(Request &req, uint32_t address, uint32_t value, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:119
uint32_t readWord(uint32_t address, unsigned byteCount)
Definition: MemoryDevice.h:203
uint16_t data16
Definition: Data.h:36
void set(const void *data, uint16_t count)
Set to reference external data block.
Definition: Data.h:66
uint32_t data32
Definition: Data.h:37
void write32(uint32_t address, uint32_t value)
Definition: MemoryDevice.h:111
uint32_t read32(uint32_t address)
Definition: MemoryDevice.h:194
void set32(uint32_t data, uint8_t len=4)
Set to 32-bit data.
Definition: Data.h:102
void write16(uint32_t address, uint16_t value)
Definition: MemoryDevice.h:94
void write(uint32_t address, const void *data, size_t len)
Write a block of data.
Definition: MemoryDevice.h:62
void read(Request &req, uint32_t address, void *buffer, size_t len, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:212
void setAsync(Callback callback=nullptr, void *param=nullptr)
Set request to asynchronous execution with optional callback.
Definition: HardwareSPI/src/include/HSPI/Request.h:143
virtual void prepareRead(HSPI::Request &req, uint32_t address)=0
virtual size_t getSize() const =0
Manages a specific SPI device instance attached to a controller.
Definition: Libraries/HardwareSPI/src/include/HSPI/Device.h:35
uint8_t data8
Definition: Data.h:35
void write16(Request &req, uint32_t address, uint16_t value, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:102
void execute(Request &request)
Definition: Libraries/HardwareSPI/src/include/HSPI/Device.h:161
Base class for read/write addressable devices.
Definition: MemoryDevice.h:23