Update MKR 1000 WiFi Firmware

Copy
1/*
2
3  FirmwareUpdate.h - Firmware Updater for WiFi101 / WINC1500.
4
5  Copyright (c) 2015 Arduino LLC.  All right reserved.
6
7  This library is free software; you can redistribute it and/or
8
9  modify it under the terms of the GNU Lesser General Public
10
11  License as published by the Free Software Foundation; either
12
13  version 2.1 of the License, or (at your option) any later version.
14
15  This library is distributed in the hope that it will be useful,
16
17  but WITHOUT ANY WARRANTY; without even the implied warranty of
18
19  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
21  Lesser General Public License for more details.
22
23  You should have received a copy of the GNU Lesser General Public
24
25  License along with this library; if not, write to the Free Software
26
27  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
28
29*/
30
31#include <WiFi101.h>
32#include <spi_flash/include/spi_flash.h>
33
34typedef struct __attribute__((__packed__)) {
35
36  uint8_t command;
37
38  uint32_t address;
39
40  uint32_t arg1;
41
42  uint16_t payloadLength;
43
44  // payloadLenght bytes of data follows...
45} UartPacket;
46
47static const int MAX_PAYLOAD_SIZE = 1024;
48
49#define CMD_READ_FLASH        0x01
50#define CMD_WRITE_FLASH       0x02
51#define CMD_ERASE_FLASH       0x03
52#define CMD_MAX_PAYLOAD_SIZE  0x50
53#define CMD_HELLO             0x99
54
55void setup() {
56
57  Serial.begin(115200);
58
59  nm_bsp_init();
60
61  if (m2m_wifi_download_mode() != M2M_SUCCESS) {
62
63    Serial.println(F("Failed to put the WiFi module in download mode"));
64
65    while (true)
66
67      ;
68
69  }
70}
71
72void receivePacket(UartPacket *pkt, uint8_t *payload) {
73
74  // Read command
75
76  uint8_t *p = reinterpret_cast<uint8_t *>(pkt);
77
78  uint16_t l = sizeof(UartPacket);
79
80  while (l > 0) {
81
82    int c = Serial.read();
83
84    if (c == -1)
85
86      continue;
87
88    *p++ = c;
89
90    l--;
91
92  }
93
94  // Convert parameters from network byte order to cpu byte order
95
96  pkt->address = fromNetwork32(pkt->address);
97
98  pkt->arg1 = fromNetwork32(pkt->arg1);
99
100  pkt->payloadLength = fromNetwork16(pkt->payloadLength);
101
102  // Read payload
103
104  l = pkt->payloadLength;
105
106  while (l > 0) {
107
108    int c = Serial.read();
109
110    if (c == -1)
111
112      continue;
113
114    *payload++ = c;
115
116    l--;
117
118  }
119}
120
121// Allocated statically so the compiler can tell us
122// about the amount of used RAM
123static UartPacket pkt;
124static uint8_t payload[MAX_PAYLOAD_SIZE];
125
126void loop() {
127
128  receivePacket(&pkt, payload);
129
130  if (pkt.command == CMD_HELLO) {
131
132    if (pkt.address == 0x11223344 && pkt.arg1 == 0x55667788)
133
134      Serial.print("v10000");
135
136  }
137
138  if (pkt.command == CMD_MAX_PAYLOAD_SIZE) {
139
140    uint16_t res = toNetwork16(MAX_PAYLOAD_SIZE);
141
142    Serial.write(reinterpret_cast<uint8_t *>(&res), sizeof(res));
143
144  }
145
146  if (pkt.command == CMD_READ_FLASH) {
147
148    uint32_t address = pkt.address;
149
150    uint32_t len = pkt.arg1;
151
152    if (spi_flash_read(payload, address, len) != M2M_SUCCESS) {
153
154      Serial.println("ER");
155
156    } else {
157
158      Serial.write(payload, len);
159
160      Serial.print("OK");
161
162    }
163
164  }
165
166  if (pkt.command == CMD_WRITE_FLASH) {
167
168    uint32_t address = pkt.address;
169
170    uint32_t len = pkt.payloadLength;
171
172    if (spi_flash_write(payload, address, len) != M2M_SUCCESS) {
173
174      Serial.print("ER");
175
176    } else {
177
178      Serial.print("OK");
179
180    }
181
182  }
183
184  if (pkt.command == CMD_ERASE_FLASH) {
185
186    uint32_t address = pkt.address;
187
188    uint32_t len = pkt.arg1;
189
190    if (spi_flash_erase(address, len) != M2M_SUCCESS) {
191
192      Serial.print("ER");
193
194    } else {
195
196      Serial.print("OK");
197
198    }
199
200  }
201}

Copy
1/*
2
3  Endianness.ino - Network byte order conversion functions.
4
5  Copyright (c) 2015 Arduino LLC.  All right reserved.
6
7  This library is free software; you can redistribute it and/or
8
9  modify it under the terms of the GNU Lesser General Public
10
11  License as published by the Free Software Foundation; either
12
13  version 2.1 of the License, or (at your option) any later version.
14
15  This library is distributed in the hope that it will be useful,
16
17  but WITHOUT ANY WARRANTY; without even the implied warranty of
18
19  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
20
21  Lesser General Public License for more details.
22
23  You should have received a copy of the GNU Lesser General Public
24
25  License along with this library; if not, write to the Free Software
26
27  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
28
29*/
30
31bool isBigEndian() {
32
33  uint32_t test = 0x11223344;
34
35  uint8_t *pTest = reinterpret_cast<uint8_t *>(&test);
36
37  return pTest[0] == 0x11;
38}
39
40uint32_t fromNetwork32(uint32_t from) {
41
42  static const bool be = isBigEndian();
43
44  if (be) {
45
46    return from;
47
48  } else {
49
50    uint8_t *pFrom = reinterpret_cast<uint8_t *>(&from);
51
52    uint32_t to;
53
54    to = pFrom[0]; to <<= 8;
55
56    to |= pFrom[1]; to <<= 8;
57
58    to |= pFrom[2]; to <<= 8;
59
60    to |= pFrom[3];
61
62    return to;
63
64  }
65}
66
67uint16_t fromNetwork16(uint16_t from) {
68
69  static bool be = isBigEndian();
70
71  if (be) {
72
73    return from;
74
75  } else {
76
77    uint8_t *pFrom = reinterpret_cast<uint8_t *>(&from);
78
79    uint16_t to;
80
81    to = pFrom[0]; to <<= 8;
82
83    to |= pFrom[1];
84
85    return to;
86
87  }
88}
89
90uint32_t toNetwork32(uint32_t to) {
91
92  return fromNetwork32(to);
93}
94
95uint16_t toNetwork16(uint16_t to) {
96
97  return fromNetwork16(to);
98}