Statistics
| Branch: | Tag: | Revision:

amiro-os / include / amiro / memoryLayout.h @ 58fe0e0b

History | View | Annotate | Download (8.9 KB)

1 58fe0e0b Thomas Schöpping
#ifndef AMIRO_FILESYSTEMIO_H_
2
#define AMIRO_FILESYSTEMIO_H_
3
4
/*! \brief memory layouts for the eeproms
5
 *
6
 * This header defines the memory layout.
7
 * Every memory layout starts with a preamble
8
 * of 3 byte. The first one is a magic byte
9
 * for checking purpose. The second one declares
10
 * the byte structure major version (BSMV) and the third
11
 * the byte structure minor version (bsmv) of the subsequently
12
 * bytes in the memory. With different major versions, the
13
 * layout of the memory may totaly change, so one should
14
 * not read from such a different layout if the version
15
 * differs from the expected one. With greater minor
16
 * versions the old memory layout may not change, but
17
 * new elements emerge.
18
 */
19
20
#include <amiro/eeprom/at24.hpp>
21
#include <chprintf.h>
22
23
namespace amiro {
24
namespace fileSystemIo {
25
26
  class FileSystemIoBase {
27
28
  public:
29
    AT24 *at24c01;
30
    const uint8_t BSMV;
31
    const uint8_t bsmv;
32
    const uint8_t HMV;
33
    const uint8_t hmv;
34
    const uint8_t magicByteValue = 0xAAu;
35
36
    // TODO implement CRC check
37
    struct preamble {
38
      uint8_t magicByte;
39
      uint8_t byteStructureMajorVersion;
40
      uint8_t byteStructureMinorVersion;
41
      uint8_t hardwareMajorVersion;
42
      uint8_t hardwareMinorVersion;
43
      uint8_t reserved_0x04_0x14[15];
44
    };
45
46
    enum{
47
      OK                    = 0x00u,
48
      NOT_IMPLEMENTED       = 0x01u,
49
      WRONG_BSMV            = 0x02u,
50
      WRONG_bsmv            = 0x03u,
51
      IO_ERROR              = 0x04u,
52
      WRONG_MAGICBYTE_VALUE = 0x05u,
53
      WRONG_INDEX           = 0x06u,
54
      WRONG_HMV             = 0x07u,
55
      WRONG_hmv             = 0x08u,
56
    };
57
58
  public:
59
60
    FileSystemIoBase(AT24 *at24c01, uint8_t BSMV, uint8_t bsmv, uint8_t HMV, uint8_t hmv)
61
      : at24c01(at24c01),
62
        BSMV(BSMV),
63
        bsmv(bsmv),
64
        HMV(HMV),
65
        hmv(hmv) {
66
     }
67
68
    msg_t getCheck(){
69
70
      // Get the preamble
71
      const uint8_t bufferSize = sizeof(FileSystemIoBase::preamble);
72
      uint8_t buffer[bufferSize];
73
      chFileStreamSeek((BaseFileStream*)at24c01, offsetof(FileSystemIoBase::preamble, magicByte));
74
      msg_t bytesWritten = chSequentialStreamRead((BaseFileStream*)at24c01, (uint8_t*) buffer, sizeof(FileSystemIoBase::preamble));
75
76
      if (bytesWritten != bufferSize) {
77
        return IO_ERROR;
78
      } else if (buffer[offsetof(FileSystemIoBase::preamble, magicByte)] != magicByteValue) {
79
        return WRONG_MAGICBYTE_VALUE;
80
      } else if (buffer[offsetof(FileSystemIoBase::preamble, byteStructureMajorVersion)] != BSMV) {
81
        return WRONG_BSMV;
82
      } else if (buffer[offsetof(FileSystemIoBase::preamble, byteStructureMinorVersion)] < bsmv) {
83
        return WRONG_bsmv;
84
      } else if (buffer[offsetof(FileSystemIoBase::preamble, hardwareMajorVersion)] != HMV) {
85
        return WRONG_HMV;
86
      } else if (buffer[offsetof(FileSystemIoBase::preamble, hardwareMinorVersion)] < hmv) {
87
        return WRONG_hmv;
88
      } else {
89
        return OK;
90
      }
91
    }
92
93
    msg_t initMemory(){
94
95
      // Get the preamble
96
      const uint8_t bufferSize = offsetof(FileSystemIoBase::preamble, hardwareMinorVersion) + 1;
97
      uint8_t buffer[bufferSize];
98
99
      chFileStreamSeek((BaseFileStream*)at24c01, offsetof(FileSystemIoBase::preamble, magicByte));
100
101
      buffer[offsetof(FileSystemIoBase::preamble, magicByte)]                 = magicByteValue;
102
      buffer[offsetof(FileSystemIoBase::preamble, byteStructureMajorVersion)] = BSMV;
103
      buffer[offsetof(FileSystemIoBase::preamble, byteStructureMinorVersion)] = bsmv;
104
      buffer[offsetof(FileSystemIoBase::preamble, hardwareMajorVersion)]      = HMV;
105
      buffer[offsetof(FileSystemIoBase::preamble, hardwareMinorVersion)]      = hmv;
106
107
      msg_t bytesWritten = chSequentialStreamWrite((BaseFileStream*)at24c01, (uint8_t*) buffer, bufferSize);
108
109
      if (bytesWritten != bufferSize) {
110
        return IO_ERROR;
111
      } else {
112
        return OK;
113
      }
114
    }
115
116
117
118
};
119
120
121
class DiWheelDriveFSIO : public FileSystemIoBase {
122
  private:
123
124
    /** \brief Layout for DiWheelDriveFSIO with BSMV 1 and bsmv 1*/
125
    struct DiWheelDrive_1_1 {
126
      uint8_t  reserved_0x00_0x14[20];
127
      uint16_t vcnl4020offset[4];       // U [12, 13, 15, 16]
128
      uint8_t  generalPurpose[96];      // 1Cx_7Cx
129
      uint8_t  reserved_0x7D_0x80[4];   // TODO CRC
130
    };
131
132
  public:
133
    DiWheelDriveFSIO(AT24 *at24c01, uint8_t BSMV, uint8_t bsmv, uint8_t HMV, uint8_t hmv)
134
      : FileSystemIoBase(at24c01, BSMV, bsmv, HMV, hmv) {
135
136
    }
137
138
    msg_t getVcnl4020Offset (uint16_t *buffer, uint8_t idx) {
139
140
      msg_t bytesWritten;
141
      const uint8_t bufferSize = sizeof(uint16_t);
142
143
      // Check if the vcnl index is in a valid range
144
      if (idx >= sizeof(DiWheelDrive_1_1::vcnl4020offset)) {
145
        return WRONG_INDEX;
146
      }
147
148
      // Get the data out of the memory
149
      switch (this->BSMV) {
150
        case 0x01u:
151
          // Set the pointer to the address
152
          chFileStreamSeek((BaseFileStream*)at24c01, offsetof(DiWheelDriveFSIO::DiWheelDrive_1_1, vcnl4020offset[idx]));
153
          switch (this->bsmv) {
154
            default:
155
              bytesWritten = chSequentialStreamRead((BaseFileStream*)at24c01, (uint8_t*) buffer, bufferSize);
156
              break;
157
          }
158
          break;
159
        }
160
161
        if (bytesWritten != bufferSize) {
162
          return IO_ERROR;
163
        } else {
164
          return OK;
165
        }
166
    }
167
168
    msg_t setVcnl4020Offset (uint16_t *buffer, uint8_t idx) {
169
170
      msg_t bytesWritten;
171
      const uint8_t bufferSize = sizeof(uint16_t);
172
173
      // Check if the vcnl index is in a valid range
174
      if (idx >= sizeof(DiWheelDrive_1_1::vcnl4020offset)) {
175
        return WRONG_INDEX;
176
      }
177
178
      // Get the data out of the memory
179
      switch (this->BSMV) {
180
        case 0x01u:
181
          // Set the pointer to the address
182
          chFileStreamSeek((BaseFileStream*)at24c01, offsetof(DiWheelDriveFSIO::DiWheelDrive_1_1, vcnl4020offset[idx]));
183
          switch (this->bsmv) {
184
            default:
185
              bytesWritten = chSequentialStreamWrite((BaseFileStream*)at24c01, (const uint8_t*) buffer, bufferSize);
186
              break;
187
          }
188
          break;
189
        }
190
191
        if (bytesWritten != bufferSize) {
192
          return IO_ERROR;
193
        } else {
194
          return OK;
195
        }
196
    }
197
};
198
199
class PowerBoardFSIO : public FileSystemIoBase {
200
  private:
201
202
    /** \brief Layout for PowerBoardFSIO with BSMV 1 and bsmv 1*/
203
    struct PowerBoard_1_1 {
204
      uint8_t  reserved_0x00_0x14[20];
205
      uint16_t vcnl4020offset[8];        // U1.Proximity [11, 21, 31, 41, 12, 22, 32, 42]
206
      uint8_t  generalPurpose[88];       // 24x_7Cx
207
      uint8_t  reserved_0x7D_0x80[4];    // TODO CRC
208
    };
209
210
  public:
211
    PowerBoardFSIO(AT24 *at24c01, uint8_t BSMV, uint8_t bsmv, uint8_t HMV, uint8_t hmv)
212
      : FileSystemIoBase(at24c01, BSMV, bsmv, HMV, hmv) {
213
214
    }
215
216
    msg_t getVcnl4020Offset (uint16_t *buffer, uint8_t idx) {
217
218
      msg_t bytesWritten;
219
      const uint8_t bufferSize = sizeof(uint16_t);
220
221
      // Check if the vcnl index is in a valid range
222
      if (idx >= sizeof(PowerBoard_1_1::vcnl4020offset)) {
223
        return WRONG_INDEX;
224
      }
225
226
      // Get the data out of the memory
227
      switch (this->BSMV) {
228
        case 0x01u:
229
          // Set the pointer to the address
230
          chFileStreamSeek((BaseFileStream*)at24c01, offsetof(PowerBoardFSIO::PowerBoard_1_1, vcnl4020offset[idx]));
231
          switch (this->bsmv) {
232
            default:
233
              bytesWritten = chSequentialStreamRead((BaseFileStream*)at24c01, (uint8_t*) buffer, bufferSize);
234
              break;
235
          }
236
          break;
237
        }
238
239
        if (bytesWritten != bufferSize) {
240
          return IO_ERROR;
241
        } else {
242
          return OK;
243
        }
244
    }
245
246
    msg_t setVcnl4020Offset (uint16_t *buffer, uint8_t idx) {
247
248
      msg_t bytesWritten;
249
      const uint8_t bufferSize = sizeof(uint16_t);
250
251
      // Check if the vcnl index is in a valid range
252
      if (idx >= sizeof(PowerBoard_1_1::vcnl4020offset)) {
253
        return WRONG_INDEX;
254
      }
255
256
      // Get the data out of the memory
257
      switch (this->BSMV) {
258
        case 0x01u:
259
          // Set the pointer to the address
260
          chFileStreamSeek((BaseFileStream*)at24c01, offsetof(PowerBoardFSIO::PowerBoard_1_1, vcnl4020offset[idx]));
261
          switch (this->bsmv) {
262
            default:
263
              bytesWritten = chSequentialStreamWrite((BaseFileStream*)at24c01, (const uint8_t*) buffer, bufferSize);
264
              break;
265
          }
266
          break;
267
        }
268
269
        if (bytesWritten != bufferSize) {
270
          return IO_ERROR;
271
        } else {
272
          return OK;
273
        }
274
    }
275
};
276
277
class LightRingFSIO : public FileSystemIoBase {
278
  private:
279
280
    /** \brief Layout for LightRingFSIO with BSMV 1 and bsmv 1*/
281
    struct LightRing_1_1 {
282
      uint8_t  reserved_0x00_0x14[20];
283
      uint8_t  generalPurpose[104];      // 15x_80x
284
      uint8_t  reserved_0x7D_0x80[4];    // TODO CRC
285
    };
286
287
  public:
288
    LightRingFSIO(AT24 *at24c01, uint8_t BSMV, uint8_t bsmv, uint8_t HMV, uint8_t hmv)
289
      : FileSystemIoBase(at24c01, BSMV, bsmv, HMV, hmv) {
290
291
    }
292
};
293
294
}
295
}
296
297
#endif /* AMIRO_FILESYSTEMIO_H_ */