MemoryDevice.h
Go to the documentation of this file.
1 /****
2  * MemoryDevice.h
3  *
4  * Copyright 2020 mikee47 <mike@sillyhouse.net>
5  *
6  * This file is part of the HardwareSPI Library
7  *
8  * This library is free software: you can redistribute it and/or modify it under the terms of the
9  * GNU General Public License as published by the Free Software Foundation, version 3 or later.
10  *
11  * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
12  * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13  * See the GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License along with this library.
16  * If not, see <https://www.gnu.org/licenses/>.
17  *
18  * @author: October 2020 - mikee47 <mike@sillyhouse.net>
19  *
20  ****/
21 
22 #pragma once
23 
24 #include "Device.h"
25 
26 namespace HSPI
27 {
32 class MemoryDevice : public Device
33 {
34 public:
35  using Device::Device;
36 
37  virtual size_t getSize() const = 0;
38 
47  virtual void prepareWrite(HSPI::Request& req, uint32_t address) = 0;
48 
54  void prepareWrite(HSPI::Request& req, uint32_t address, const void* data, size_t len)
55  {
56  prepareWrite(req, address);
57  req.out.set(data, len);
58  req.in.clear();
59  }
69  void write(uint32_t address, const void* data, size_t len)
70  {
71  Request req;
72  prepareWrite(req, address, data, len);
73  execute(req);
74  }
75 
76  void write(Request& req, uint32_t address, const void* data, size_t len, Callback callback = nullptr,
77  void* param = nullptr)
78  {
79  prepareWrite(req, address, data, len);
80  req.setAsync(callback, param);
81  execute(req);
82  }
83 
84  void write8(uint32_t address, uint8_t value)
85  {
86  Request req;
87  prepareWrite(req, address);
88  req.out.set8(value);
89  execute(req);
90  }
91 
92  void write8(Request& req, uint32_t address, uint8_t value, Callback callback = nullptr, void* param = nullptr)
93  {
94  prepareWrite(req, address);
95  req.out.set8(value);
96  req.in.clear();
97  req.setAsync(callback, param);
98  execute(req);
99  }
100 
101  void write16(uint32_t address, uint16_t value)
102  {
103  Request req;
104  prepareWrite(req, address);
105  req.out.set16(value);
106  execute(req);
107  }
108 
109  void write16(Request& req, uint32_t address, uint16_t value, Callback callback = nullptr, void* param = nullptr)
110  {
111  prepareWrite(req, address);
112  req.out.set16(value);
113  req.in.clear();
114  req.setAsync(callback, param);
115  execute(req);
116  }
117 
118  void write32(uint32_t address, uint32_t value)
119  {
120  Request req;
121  prepareWrite(req, address);
122  req.out.set32(value);
123  execute(req);
124  }
125 
126  void write32(Request& req, uint32_t address, uint32_t value, Callback callback = nullptr, void* param = nullptr)
127  {
128  prepareWrite(req, address);
129  req.out.set32(value);
130  req.in.clear();
131  req.setAsync(callback, param);
132  execute(req);
133  }
134 
135  void writeWord(Request& req, uint32_t address, uint32_t value, unsigned byteCount)
136  {
137  prepareWrite(req, address);
138  req.out.set32(value, byteCount);
139  req.in.clear();
140  execute(req);
141  }
142 
151  virtual void prepareRead(HSPI::Request& req, uint32_t address) = 0;
152 
158  void prepareRead(HSPI::Request& req, uint32_t address, void* buffer, size_t len)
159  {
160  prepareRead(req, address);
161  req.out.clear();
162  req.in.set(buffer, len);
163  }
164 
174  void read(uint32_t address, void* buffer, size_t len)
175  {
176  Request req;
177  prepareRead(req, address, buffer, len);
178  execute(req);
179  }
180 
181  uint8_t read8(uint32_t address)
182  {
183  Request req;
184  prepareRead(req, address);
185  req.in.set8(address);
186  execute(req);
187  return req.in.data8;
188  }
189 
190  uint16_t read16(uint32_t address)
191  {
192  Request req;
193  prepareRead(req, address);
194  req.in.set16(address);
195  execute(req);
196  return req.in.data16;
197  }
198 
199  uint32_t read32(uint32_t address)
200  {
201  Request req;
202  prepareRead(req, address);
203  req.in.set32(address);
204  execute(req);
205  return req.in.data32;
206  }
207 
208  uint32_t readWord(uint32_t address, unsigned byteCount)
209  {
210  Request req;
211  prepareRead(req, address);
212  req.in.set32(0, byteCount);
213  execute(req);
214  return req.in.data32;
215  }
216 
217  void read(Request& req, uint32_t address, void* buffer, size_t len, Callback callback = nullptr,
218  void* param = nullptr)
219  {
220  prepareRead(req, address, buffer, len);
221  req.setAsync(callback, param);
222  execute(req);
223  }
224 };
225 
226 } // namespace HSPI
Manages a specific SPI device instance attached to a controller.
Definition: Libraries/HardwareSPI/src/include/HSPI/Device.h:45
Device(Controller &controller)
Definition: Libraries/HardwareSPI/src/include/HSPI/Device.h:47
void execute(Request &request)
Definition: Libraries/HardwareSPI/src/include/HSPI/Device.h:173
Base class for read/write addressable devices.
Definition: MemoryDevice.h:33
virtual void prepareRead(HSPI::Request &req, uint32_t address)=0
Prepare without buffer.
void write(Request &req, uint32_t address, const void *data, size_t len, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:76
void write8(uint32_t address, uint8_t value)
Definition: MemoryDevice.h:84
void write(uint32_t address, const void *data, size_t len)
Write a block of data.
Definition: MemoryDevice.h:69
uint16_t read16(uint32_t address)
Definition: MemoryDevice.h:190
void read(uint32_t address, void *buffer, size_t len)
Read a block of data.
Definition: MemoryDevice.h:174
uint32_t readWord(uint32_t address, unsigned byteCount)
Definition: MemoryDevice.h:208
uint32_t read32(uint32_t address)
Definition: MemoryDevice.h:199
void writeWord(Request &req, uint32_t address, uint32_t value, unsigned byteCount)
Definition: MemoryDevice.h:135
void write16(uint32_t address, uint16_t value)
Definition: MemoryDevice.h:101
void write8(Request &req, uint32_t address, uint8_t value, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:92
void write16(Request &req, uint32_t address, uint16_t value, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:109
virtual size_t getSize() const =0
uint8_t read8(uint32_t address)
Definition: MemoryDevice.h:181
virtual void prepareWrite(HSPI::Request &req, uint32_t address)=0
Prepare request without data.
void write32(uint32_t address, uint32_t value)
Definition: MemoryDevice.h:118
void write32(Request &req, uint32_t address, uint32_t value, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:126
void prepareWrite(HSPI::Request &req, uint32_t address, const void *data, size_t len)
Prepare request with data.
Definition: MemoryDevice.h:54
void read(Request &req, uint32_t address, void *buffer, size_t len, Callback callback=nullptr, void *param=nullptr)
Definition: MemoryDevice.h:217
void prepareRead(HSPI::Request &req, uint32_t address, void *buffer, size_t len)
Prepare with buffer.
Definition: MemoryDevice.h:158
bool(*)(Request &request) Callback
SPI completion callback routine.
Definition: HardwareSPI/src/include/HSPI/Request.h:41
Definition: Common.h:35
void set16(uint16_t data)
Set to single 16-bit value.
Definition: Data.h:107
uint32_t data32
Definition: Data.h:47
void set(const void *data, uint16_t count)
Set to reference external data block.
Definition: Data.h:76
uint16_t data16
Definition: Data.h:46
void set32(uint32_t data, uint8_t len=4)
Set to 32-bit data.
Definition: Data.h:117
void clear()
Reset to zero-length.
Definition: Data.h:64
uint8_t data8
Definition: Data.h:45
void set8(uint8_t data)
Set to single 8-bit value.
Definition: Data.h:98
Defines an SPI Request Packet.
Definition: HardwareSPI/src/include/HSPI/Request.h:57
Data in
Incoming data.
Definition: HardwareSPI/src/include/HSPI/Request.h:70
Data out
Outgoing data.
Definition: HardwareSPI/src/include/HSPI/Request.h:69
void setAsync(Callback callback=nullptr, void *param=nullptr)
Set request to asynchronous execution with optional callback.
Definition: HardwareSPI/src/include/HSPI/Request.h:142