Rev 877 | Rev 879 | Go to most recent revision | Only display areas with differences | Regard whitespace | Details | Blame | Last modification | View Log | SVN | RSS feed
| Rev 877 | Rev 878 | ||
|---|---|---|---|
| 1 | using System; |
1 | using System; |
| 2 | using System.Collections.Generic; |
2 | using System.Collections.Generic; |
| 3 | using System.Text; |
3 | using System.Text; |
| 4 | using System.Threading; |
4 | using System.Threading; |
| 5 | 5 | ||
| 6 | //this class should probably be integrated into canNMT instead |
6 | //this class should probably be integrated into canNMT instead |
| 7 | 7 | ||
| 8 | public class Downloader { |
8 | public class Downloader { |
| 9 | private HexFile hf; |
9 | private HexFile hf; |
| 10 | private DaemonConnection dc; |
10 | private DaemonConnection dc; |
| 11 | private bool isBiosUpdate; |
11 | private bool isBiosUpdate; |
| 12 | private ulong dlOffset = 0; |
12 | private ulong dlOffset = 0; |
| 13 | //private Thread down; |
13 | //private Thread down; |
| 14 | private byte receiveID; |
14 | private byte receiveID; |
| 15 | private uint hwid; |
15 | private uint hwid; |
| 16 | private bool HWID_INUSE; |
16 | private bool HWID_INUSE; |
| 17 | 17 | ||
| 18 | private enum dState { SEND_START, WAIT_ACK_PRG, SEND_PGM_DATA, WAIT_ACK_DATA, RESEND_ADDR, WAIT_DONE, SEND_DONE, SEND_BIOS_UPDATE, SEND_RESET, DONE, DEBUG_STATE2, WAIT_BOOT, SEND_EMPTY_START, WAIT_ACK_PRG_EMPTY, SEND_EMPTY_DATA, WAIT_ACK_EMPTY_DATA, SEND_DONE_EMPTY, WAIT_DONE_EMPTY}; |
18 | private enum dState { SEND_START, WAIT_ACK_PRG, SEND_PGM_DATA, WAIT_ACK_DATA, RESEND_ADDR, WAIT_DONE, SEND_DONE, SEND_BIOS_UPDATE, SEND_RESET, DONE, DEBUG_STATE2, WAIT_BOOT, SEND_EMPTY_START, WAIT_ACK_PRG_EMPTY, SEND_EMPTY_DATA, WAIT_ACK_EMPTY_DATA, SEND_DONE_EMPTY, WAIT_DONE_EMPTY}; |
| 19 | 19 | ||
| 20 | private const byte CAN_NMT = 0x00; |
20 | private const byte CAN_NMT = 0x00; |
| 21 | 21 | ||
| 22 | private const byte CAN_NMT_RESET = 0x04; |
22 | private const byte CAN_NMT_RESET = 0x04; |
| 23 | private const byte CAN_NMT_BIOS_START = 0x08; |
23 | private const byte CAN_NMT_BIOS_START = 0x08; |
| 24 | private const byte CAN_NMT_PGM_START = 0x0C; |
24 | private const byte CAN_NMT_PGM_START = 0x0C; |
| 25 | private const byte CAN_NMT_PGM_DATA = 0x10; |
25 | private const byte CAN_NMT_PGM_DATA = 0x10; |
| 26 | private const byte CAN_NMT_PGM_END = 0x14; |
26 | private const byte CAN_NMT_PGM_END = 0x14; |
| 27 | private const byte CAN_NMT_PGM_COPY = 0x18; |
27 | private const byte CAN_NMT_PGM_COPY = 0x18; |
| 28 | private const byte CAN_NMT_PGM_ACK = 0x1C; |
28 | private const byte CAN_NMT_PGM_ACK = 0x1C; |
| 29 | private const byte CAN_NMT_PGM_NACK = 0x20; |
29 | private const byte CAN_NMT_PGM_NACK = 0x20; |
| 30 | private const byte CAN_NMT_START_APP = 0x24; |
30 | private const byte CAN_NMT_START_APP = 0x24; |
| 31 | private const byte CAN_NMT_APP_START = 0x28; |
31 | private const byte CAN_NMT_APP_START = 0x28; |
| 32 | private const byte CAN_NMT_HEARTBEAT = 0x2C; |
32 | private const byte CAN_NMT_HEARTBEAT = 0x2C; |
| 33 | 33 | ||
| 34 | private const byte MY_ID = 0x00; |
34 | private const byte MY_ID = 0x00; |
| 35 | //private const byte TARGET_ID = 0x78; |
35 | //private const byte TARGET_ID = 0x78; |
| 36 | private const byte MY_NID = 0x0; |
36 | private const byte MY_NID = 0x0; |
| 37 | private const byte ADDR0_INDEX = 0; |
37 | private const byte ADDR0_INDEX = 0; |
| 38 | private const byte ADDR1_INDEX = 1; |
38 | private const byte ADDR1_INDEX = 1; |
| 39 | private const byte ADDR2_INDEX = 2; |
39 | private const byte ADDR2_INDEX = 2; |
| 40 | private const byte ADDR3_INDEX = 3; |
40 | private const byte ADDR3_INDEX = 3; |
| 41 | 41 | ||
| 42 | private const byte HWID0_INDEX = 4; |
42 | private const byte HWID0_INDEX = 4; |
| 43 | private const byte HWID1_INDEX = 5; |
43 | private const byte HWID1_INDEX = 5; |
| 44 | private const byte HWID2_INDEX = 6; |
44 | private const byte HWID2_INDEX = 6; |
| 45 | private const byte HWID3_INDEX = 7; |
45 | private const byte HWID3_INDEX = 7; |
| 46 | 46 | ||
| 47 | private const int TIMEOUT_MS = 1000; |
47 | private const int TIMEOUT_MS = 1000; |
| 48 | private const int TIMEOUT_SHORT_MS = 200; |
48 | private const int TIMEOUT_SHORT_MS = 200; |
| 49 | 49 | ||
| 50 | private long timeStart = 0; |
50 | private long timeStart = 0; |
| 51 | 51 | ||
| 52 | public Downloader(HexFile hf, DaemonConnection dc, byte receiveID, bool isBiosUpdate, bool HWID_INUSE, uint hwid) { |
52 | public Downloader(HexFile hf, DaemonConnection dc, byte receiveID, bool isBiosUpdate, bool HWID_INUSE, uint hwid) { |
| 53 | this.hf = hf; |
53 | this.hf = hf; |
| 54 | this.dc = dc; |
54 | this.dc = dc; |
| 55 | this.receiveID = receiveID; |
55 | this.receiveID = receiveID; |
| 56 | this.isBiosUpdate = isBiosUpdate; |
56 | this.isBiosUpdate = isBiosUpdate; |
| 57 | this.hwid = hwid; |
57 | this.hwid = hwid; |
| 58 | this.HWID_INUSE = HWID_INUSE; |
58 | this.HWID_INUSE = HWID_INUSE; |
| 59 | } |
59 | } |
| 60 | 60 | ||
| 61 | public int calcCRC(HexFile hf) { |
61 | public int calcCRC(HexFile hf) { |
| 62 | int crc=0; |
62 | int crc=0; |
| 63 | for (ulong i=hf.getAddrLower(); i <= hf.getAddrUpper(); i++) { |
63 | for (ulong i=hf.getAddrLower(); i <= hf.getAddrUpper(); i++) { |
| 64 | crc = crc16_update(crc, hf.getByte(i)); |
64 | crc = crc16_update(crc, hf.getByte(i)); |
| 65 | } |
65 | } |
| 66 | return crc; |
66 | return crc; |
| 67 | } |
67 | } |
| 68 | 68 | ||
| 69 | public int crc16_update(int crc, byte a) { |
69 | public int crc16_update(int crc, byte a) { |
| 70 | int i; |
70 | int i; |
| 71 | crc ^= a; |
71 | crc ^= a; |
| 72 | for (i = 0; i < 8; ++i) { |
72 | for (i = 0; i < 8; ++i) { |
| 73 | if ((crc & 1) != 0) |
73 | if ((crc & 1) != 0) |
| 74 | crc = (crc >> 1) ^ 0xA001; |
74 | crc = (crc >> 1) ^ 0xA001; |
| 75 | else |
75 | else |
| 76 | crc = (crc >> 1); |
76 | crc = (crc >> 1); |
| 77 | } |
77 | } |
| 78 | return crc; |
78 | return crc; |
| 79 | } |
79 | } |
| 80 | 80 | ||
| 81 | public bool go() { |
81 | public bool go() { |
| 82 | if (dc==null || hf==null || hf.getLength()==0) return false; |
82 | if (dc==null || hf==null || hf.getLength()==0) return false; |
| 83 | return downloader(); |
83 | return downloader(); |
| 84 | } |
84 | } |
| 85 | 85 | ||
| 86 | public void abort() { |
86 | public void abort() { |
| 87 | //if (down != null && down.IsAlive) down.Abort(); |
87 | //if (down != null && down.IsAlive) down.Abort(); |
| 88 | } |
88 | } |
| 89 | 89 | ||
| 90 | public bool downloader() { |
90 | public bool downloader() { |
| 91 | dState pgs = dState.SEND_START; |
91 | dState pgs = dState.SEND_START; |
| 92 | int t = 0; |
92 | int t = 0; |
| 93 | int t2 = 0; |
93 | int t2 = 0; |
| 94 | CanPacket outCm = null; |
94 | CanPacket outCm = null; |
| 95 | CanPacket cm = null; |
95 | CanPacket cm = null; |
| 96 | byte[] data = new byte[8]; |
96 | byte[] data = new byte[8]; |
| 97 | uint byteSent = 0; |
97 | uint byteSent = 0; |
| 98 | ulong currentAddress = 0; |
98 | ulong currentAddress = 0; |
| 99 | bool done = false; |
99 | bool done = false; |
| 100 | bool errorOccured = false; |
100 | bool errorOccured = false; |
| 101 | 101 | ||
| 102 | //int rotstate=0; |
102 | //int rotstate=0; |
| 103 |
|
103 | //int dldisplaystate=0; |
| - | 104 | double lastpercent=0; |
|
| - | 105 | double lasttenpercent=0; |
|
| - | 106 | int nrOfTicks=0; |
|
| 104 | 107 | ||
| 105 | try { |
108 | try { |
| 106 | if (isBiosUpdate) { |
109 | if (isBiosUpdate) { |
| 107 | dlOffset = hf.getAddrLower(); |
110 | dlOffset = hf.getAddrLower(); |
| 108 | //Console.WriteLine(dlOffset); |
111 | //Console.WriteLine(dlOffset); |
| 109 | //dlOffset = 200; |
112 | //dlOffset = 200; |
| 110 | } |
113 | } |
| 111 | 114 | ||
| 112 | CanNMT cpn = new CanNMT(HWID_INUSE); |
115 | CanNMT cpn = new CanNMT(HWID_INUSE); |
| 113 | cpn.setReceiver(receiveID); |
116 | cpn.setReceiver(receiveID); |
| 114 | bool hasMessage = false; |
117 | bool hasMessage = false; |
| 115 | 118 | ||
| 116 | while (!done) { |
119 | while (!done) { |
| 117 | Thread.Sleep(1); |
120 | Thread.Sleep(1); |
| 118 | 121 | ||
| 119 | switch (pgs) { |
122 | switch (pgs) { |
| 120 | case dState.SEND_START: |
123 | case dState.SEND_START: |
| 121 | // Send boot start packet to target. |
124 | // Send boot start packet to target. |
| 122 | // and wait for ack. |
125 | // and wait for ack. |
| 123 | currentAddress = hf.getAddrLower(); |
126 | currentAddress = hf.getAddrLower(); |
| 124 | //data[RID_INDEX] = TARGET_ID; |
127 | //data[RID_INDEX] = TARGET_ID; |
| 125 | data[ADDR0_INDEX] = (byte)((currentAddress-dlOffset) & 0x0000FF); |
128 | data[ADDR0_INDEX] = (byte)((currentAddress-dlOffset) & 0x0000FF); |
| 126 | data[ADDR1_INDEX] = (byte)(((currentAddress-dlOffset) & 0x00FF00) >> 8); |
129 | data[ADDR1_INDEX] = (byte)(((currentAddress-dlOffset) & 0x00FF00) >> 8); |
| 127 | data[ADDR2_INDEX] = (byte)(((currentAddress-dlOffset) & 0xFF0000) >> 16); |
130 | data[ADDR2_INDEX] = (byte)(((currentAddress-dlOffset) & 0xFF0000) >> 16); |
| 128 | data[ADDR3_INDEX] = 0; |
131 | data[ADDR3_INDEX] = 0; |
| 129 | if (HWID_INUSE) { |
132 | if (HWID_INUSE) { |
| 130 | data[HWID0_INDEX] = (byte)((hwid) & 0xFF); |
133 | data[HWID0_INDEX] = (byte)((hwid) & 0xFF); |
| 131 | data[HWID1_INDEX] = (byte)((hwid>>8) & 0xFF); |
134 | data[HWID1_INDEX] = (byte)((hwid>>8) & 0xFF); |
| 132 | data[HWID2_INDEX] = (byte)((hwid>>16) & 0xFF); |
135 | data[HWID2_INDEX] = (byte)((hwid>>16) & 0xFF); |
| 133 | data[HWID3_INDEX] = (byte)((hwid>>24) & 0xFF); |
136 | data[HWID3_INDEX] = (byte)((hwid>>24) & 0xFF); |
| 134 | } |
137 | } |
| 135 | //outCm = new CanPacket(CAN_NMT, CAN_NMT_PGM_START, MY_ID, receiveID, 4, data); |
138 | //outCm = new CanPacket(CAN_NMT, CAN_NMT_PGM_START, MY_ID, receiveID, 4, data); |
| 136 | outCm = cpn.getPgmStartPacket(data); |
139 | outCm = cpn.getPgmStartPacket(data); |
| 137 | dc.sendCanPacket(outCm); |
140 | dc.sendCanPacket(outCm); |
| 138 | t = Environment.TickCount; |
141 | t = Environment.TickCount; |
| 139 | t2 = Environment.TickCount; |
142 | t2 = Environment.TickCount; |
| 140 | pgs = dState.WAIT_ACK_PRG; |
143 | pgs = dState.WAIT_ACK_PRG; |
| 141 | timeStart = Environment.TickCount; |
144 | timeStart = Environment.TickCount; |
| 142 | Console.WriteLine("Downloading..."); |
145 | Console.WriteLine("Downloading..."); |
| - | 146 | Console.Write(" 0% [ ]\r"); |
|
| 143 | Console.Write(" 0%"); |
147 | Console.Write(" 0% ["); |
| 144 | break; |
148 | break; |
| 145 | 149 | ||
| 146 | 150 | ||
| 147 | case dState.WAIT_ACK_PRG: |
151 | case dState.WAIT_ACK_PRG: |
| 148 | // Check for timeout, resend start packet in that case.. |
152 | // Check for timeout, resend start packet in that case.. |
| 149 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
153 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
| 150 | Console.WriteLine("Timeout while waiting for start prg ack."); |
154 | Console.WriteLine("Timeout while waiting for start prg ack."); |
| 151 | errorOccured = true; |
155 | errorOccured = true; |
| 152 | pgs = dState.SEND_RESET; |
156 | pgs = dState.SEND_RESET; |
| 153 | } |
157 | } |
| 154 | //Thread.Sleep(1); |
158 | //Thread.Sleep(1); |
| 155 | // If received ack. |
159 | // If received ack. |
| 156 | hasMessage = dc.getData(out cm); |
160 | hasMessage = dc.getData(out cm); |
| 157 | if (hasMessage) { |
161 | if (hasMessage) { |
| 158 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
162 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 159 | if (cpnin.isNMTPacket()) { |
163 | if (cpnin.isNMTPacket()) { |
| 160 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
164 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 161 | // If no error |
165 | // If no error |
| 162 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
166 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
| 163 | // Start sending program data.. |
167 | // Start sending program data.. |
| 164 | byteSent = 0; |
168 | byteSent = 0; |
| 165 | pgs = dState.SEND_PGM_DATA; |
169 | pgs = dState.SEND_PGM_DATA; |
| 166 | } |
170 | } |
| 167 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
171 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
| 168 | // else .. |
172 | // else .. |
| 169 | Console.WriteLine("Nack on CAN_NMT_PGM_START."); |
173 | Console.WriteLine("Nack on CAN_NMT_PGM_START."); |
| 170 | errorOccured = true; |
174 | errorOccured = true; |
| 171 | pgs = dState.SEND_RESET; |
175 | pgs = dState.SEND_RESET; |
| 172 | } |
176 | } |
| 173 | } |
177 | } |
| 174 | } |
178 | } |
| 175 | break; |
179 | break; |
| 176 | 180 | ||
| 177 | case dState.SEND_PGM_DATA: |
181 | case dState.SEND_PGM_DATA: |
| 178 | //Console.WriteLine("byteSent = "+byteSent); |
- | |
| 179 | //disable Console.Write("."); |
- | |
| 180 | //Console.Write("\b"); |
- | |
| 181 | //int curleft = Console.CursorLeft; |
- | |
| 182 | //int curtop = Console.CursorTop; |
- | |
| 183 | //Console.SetCursorPosition(curleft, curtop-1); |
- | |
| 184 | 182 | ||
| 185 | //if (rotstate==0) { |
- | |
| 186 |
|
183 | double percent = (double)byteSent*100/((double)hf.getAddrUpper()-(double)currentAddress); |
| 187 | // rotstate=1; |
- | |
| 188 | //} else if (rotstate==1) { |
- | |
| 189 | // Console.Write("\\"); |
- | |
| 190 | // rotstate=2; |
- | |
| 191 | //} else if (rotstate==2) { |
- | |
| 192 | // Console.Write("|"); |
- | |
| 193 | // rotstate=3; |
- | |
| 194 | //} else if (rotstate==3) { |
- | |
| 195 | // Console.Write("/"); |
- | |
| 196 | // rotstate=0; |
- | |
| 197 | //} |
- | |
| 198 | //Console.Write(" |
184 | //Console.Write(" 0% [ ]"); |
| 199 | //dldisplaystate |
- | |
| 200 | 185 | ||
| - | 186 | if (percent >= lastpercent+2.5) { |
|
| - | 187 | //Console.WriteLine(percent); |
|
| - | 188 | Console.Write("="); |
|
| 201 |
|
189 | nrOfTicks++; |
| - | 190 | lastpercent = lastpercent+2.5; |
|
| - | 191 | } |
|
| - | 192 | if (percent > lasttenpercent+10) { |
|
| - | 193 | Console.Write("\r"); |
|
| 202 |
|
194 | Console.Write(" "+Math.Round(percent,0)+"% ["); |
| 203 | 195 | ||
| 204 | if (percent>9 && dldisplaystate==0) { |
- | |
| 205 | Console.Write("\r"); |
- | |
| 206 |
|
196 | lasttenpercent = percent; |
| 207 | dldisplaystate=1; |
- | |
| 208 | } else if (percent>19 && dldisplaystate==1) { |
- | |
| 209 | Console.Write("\r"); |
- | |
| 210 | Console.Write(" "+percent+"%"); |
- | |
| 211 | dldisplaystate=2; |
- | |
| 212 | } else if (percent>29 && dldisplaystate==2) { |
- | |
| 213 | Console.Write("\r"); |
- | |
| 214 | Console.Write(" "+percent+"%"); |
- | |
| 215 | dldisplaystate=3; |
- | |
| 216 | } else if (percent>39 && dldisplaystate==3) { |
- | |
| 217 | Console.Write("\r"); |
- | |
| 218 | Console.Write(" "+percent+"%"); |
- | |
| 219 | dldisplaystate=4; |
- | |
| 220 | } else if (percent>49 && dldisplaystate==4) { |
- | |
| 221 | Console.Write("\r"); |
- | |
| 222 | Console.Write(" "+percent+"%"); |
- | |
| 223 | dldisplaystate=5; |
- | |
| 224 | } else if (percent>59 && dldisplaystate==5) { |
- | |
| 225 | Console.Write("\r"); |
- | |
| 226 | Console.Write(" "+percent+"%"); |
- | |
| 227 | dldisplaystate=6; |
- | |
| 228 | } else if (percent>69 && dldisplaystate==6) { |
- | |
| 229 | Console.Write("\r"); |
- | |
| 230 | Console.Write(" "+percent+"%"); |
- | |
| 231 | dldisplaystate=7; |
- | |
| 232 | } else if (percent>79 && dldisplaystate==7) { |
- | |
| 233 | Console.Write("\r"); |
- | |
| 234 | Console.Write(" "+percent+"%"); |
- | |
| 235 | dldisplaystate=8; |
- | |
| 236 | } else if (percent>89 && dldisplaystate==8) { |
- | |
| 237 | Console.Write("\r"); |
- | |
| 238 |
|
197 | for (int i=0; i<nrOfTicks; i++) { |
| 239 | dldisplaystate=9; |
- | |
| 240 | } else if (percent>99 && dldisplaystate==9) { |
- | |
| 241 | Console.Write("\r"); |
- | |
| 242 | Console.Write |
198 | Console.Write("="); |
| 243 | dldisplaystate=10; |
- | |
| 244 | } |
199 | } |
| 245 |
|
200 | } |
| - | 201 | ||
| 246 | 202 | ||
| 247 | // Send program data. |
203 | // Send program data. |
| 248 | byte datalength = 2; |
204 | byte datalength = 2; |
| 249 | for (ulong i = 0; i < 6; i++) { |
205 | for (ulong i = 0; i < 6; i++) { |
| 250 | // Populate data. |
206 | // Populate data. |
| 251 | data[i+2] = hf.getByte(currentAddress + i + byteSent); |
207 | data[i+2] = hf.getByte(currentAddress + i + byteSent); |
| 252 | if (currentAddress + i + byteSent > hf.getAddrUpper()) { |
208 | if (currentAddress + i + byteSent > hf.getAddrUpper()) { |
| 253 | break; //then done |
209 | break; //then done |
| 254 | } |
210 | } |
| 255 | datalength++; |
211 | datalength++; |
| 256 | } |
212 | } |
| 257 | data[0] = (byte)(byteSent & 0x00FF); |
213 | data[0] = (byte)(byteSent & 0x00FF); |
| 258 | data[1] = (byte)((byteSent & 0xFF00) >> 8); |
214 | data[1] = (byte)((byteSent & 0xFF00) >> 8); |
| 259 | 215 | ||
| 260 | outCm = cpn.getPgmDataPacket(data, datalength); |
216 | outCm = cpn.getPgmDataPacket(data, datalength); |
| 261 | dc.sendCanPacket(outCm); |
217 | dc.sendCanPacket(outCm); |
| 262 | 218 | ||
| 263 | t = Environment.TickCount; |
219 | t = Environment.TickCount; |
| 264 | t2 = Environment.TickCount; |
220 | t2 = Environment.TickCount; |
| 265 | byteSent += 6; |
221 | byteSent += 6; |
| 266 | pgs = dState.WAIT_ACK_DATA; |
222 | pgs = dState.WAIT_ACK_DATA; |
| 267 | break; |
223 | break; |
| 268 | 224 | ||
| 269 | 225 | ||
| 270 | case dState.WAIT_ACK_DATA: |
226 | case dState.WAIT_ACK_DATA: |
| 271 | // Wait for pgm ack. |
227 | // Wait for pgm ack. |
| 272 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
228 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
| 273 | // Woops, error. |
229 | // Woops, error. |
| 274 | Console.WriteLine("Timeout while waiting for data ack."); |
230 | Console.WriteLine("Timeout while waiting for data ack."); |
| 275 | errorOccured = true; |
231 | errorOccured = true; |
| 276 | pgs = dState.SEND_RESET; |
232 | pgs = dState.SEND_RESET; |
| 277 | } |
233 | } |
| 278 | else if ((Environment.TickCount - t2) > TIMEOUT_SHORT_MS) { |
234 | else if ((Environment.TickCount - t2) > TIMEOUT_SHORT_MS) { |
| 279 | // Woops, error. |
235 | // Woops, error. |
| 280 | //disable Console.Write(":"); |
236 | //disable Console.Write(":"); |
| 281 | byteSent -= 6; |
237 | byteSent -= 6; |
| 282 | pgs = dState.SEND_PGM_DATA; |
238 | pgs = dState.SEND_PGM_DATA; |
| 283 | break; |
239 | break; |
| 284 | } |
240 | } |
| 285 | //Thread.Sleep(1); |
241 | //Thread.Sleep(1); |
| 286 | // If received ack. |
242 | // If received ack. |
| 287 | hasMessage = dc.getData(out cm); |
243 | hasMessage = dc.getData(out cm); |
| 288 | if (hasMessage) { |
244 | if (hasMessage) { |
| 289 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
245 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 290 | if (cpnin.isNMTPacket()) { |
246 | if (cpnin.isNMTPacket()) { |
| 291 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
247 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 292 | // If no error |
248 | // If no error |
| 293 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
249 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
| 294 | //currentAddress += 2; |
250 | //currentAddress += 2; |
| 295 | // Check if end. |
251 | // Check if end. |
| 296 | if (currentAddress + byteSent > hf.getAddrUpper()) { |
252 | if (currentAddress + byteSent > hf.getAddrUpper()) { |
| 297 | // Yes, we are done, send done. |
253 | // Yes, we are done, send done. |
| 298 | pgs = dState.SEND_DONE; |
254 | pgs = dState.SEND_DONE; |
| 299 | } |
255 | } |
| 300 | else { |
256 | else { |
| 301 | // More to write. |
257 | // More to write. |
| 302 | //byteSent = 0; |
258 | //byteSent = 0; |
| 303 | pgs = dState.SEND_PGM_DATA; |
259 | pgs = dState.SEND_PGM_DATA; |
| 304 | } |
260 | } |
| 305 | } |
261 | } |
| 306 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
262 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
| 307 | // else .. |
263 | // else .. |
| 308 | Console.WriteLine("Nack on CAN_NMT_PGM_DATA."); |
264 | Console.WriteLine("Nack on CAN_NMT_PGM_DATA."); |
| 309 | errorOccured = true; |
265 | errorOccured = true; |
| 310 | pgs = dState.SEND_RESET; |
266 | pgs = dState.SEND_RESET; |
| 311 | } |
267 | } |
| 312 | } |
268 | } |
| 313 | } |
269 | } |
| 314 | break; |
270 | break; |
| 315 | 271 | ||
| 316 | case dState.SEND_DONE: |
272 | case dState.SEND_DONE: |
| 317 | Console.Write("\r"); |
273 | Console.Write("\r"); |
| 318 | Console.Write("100%"); |
274 | Console.Write("100% [========================================] "); |
| 319 | // Send done |
275 | // Send done |
| 320 | outCm = cpn.getPgmEndPacket(); |
276 | outCm = cpn.getPgmEndPacket(); |
| 321 | dc.sendCanPacket(outCm); |
277 | dc.sendCanPacket(outCm); |
| 322 | 278 | ||
| 323 | t = Environment.TickCount; |
279 | t = Environment.TickCount; |
| 324 | t2 = Environment.TickCount; |
280 | t2 = Environment.TickCount; |
| 325 | pgs = dState.WAIT_DONE; |
281 | pgs = dState.WAIT_DONE; |
| 326 | break; |
282 | break; |
| 327 | 283 | ||
| 328 | 284 | ||
| 329 | case dState.WAIT_DONE: |
285 | case dState.WAIT_DONE: |
| 330 | // Check for timeout, resend done packet in that case.. |
286 | // Check for timeout, resend done packet in that case.. |
| 331 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
287 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
| 332 | Console.WriteLine("Timeout while waiting for end prg ack."); |
288 | Console.WriteLine("Timeout while waiting for end prg ack."); |
| 333 | errorOccured = true; |
289 | errorOccured = true; |
| 334 | pgs = dState.SEND_RESET; |
290 | pgs = dState.SEND_RESET; |
| 335 | } |
291 | } |
| 336 | //Thread.Sleep(1); |
292 | //Thread.Sleep(1); |
| 337 | 293 | ||
| 338 | hasMessage = dc.getData(out cm); |
294 | hasMessage = dc.getData(out cm); |
| 339 | if (hasMessage) { |
295 | if (hasMessage) { |
| 340 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
296 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 341 | if (cpnin.isNMTPacket()) { |
297 | if (cpnin.isNMTPacket()) { |
| 342 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
298 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 343 | // If no error |
299 | // If no error |
| 344 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
300 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
| 345 | Console.WriteLine(""); |
301 | Console.WriteLine(""); |
| 346 | // |
302 | // |
| 347 | int crc = calcCRC(hf); |
303 | int crc = calcCRC(hf); |
| 348 | 304 | ||
| 349 | if (cm.getDataLength() == 2) { |
305 | if (cm.getDataLength() == 2) { |
| 350 | byte[] cmdata = cm.getData(); |
306 | byte[] cmdata = cm.getData(); |
| 351 | if ((cmdata[0] == (crc & 0xFF)) && (cmdata[1] == (crc>>8))) { |
307 | if ((cmdata[0] == (crc & 0xFF)) && (cmdata[1] == (crc>>8))) { |
| 352 | if (!isBiosUpdate) { |
308 | if (!isBiosUpdate) { |
| 353 | Console.WriteLine("Done, successfully programmed application."); |
309 | Console.WriteLine("Done, successfully programmed application."); |
| 354 | pgs = dState.SEND_RESET; |
310 | pgs = dState.SEND_RESET; |
| 355 | } else { |
311 | } else { |
| 356 | Console.WriteLine("Done, successfully programmed bios to application space."); |
312 | Console.WriteLine("Done, successfully programmed bios to application space."); |
| 357 | pgs = dState.SEND_BIOS_UPDATE; |
313 | pgs = dState.SEND_BIOS_UPDATE; |
| 358 | } |
314 | } |
| 359 | } else { |
315 | } else { |
| 360 | string nodecrc = String.Format("{0:x4}", (int)cmdata[0] + (int)(cmdata[1]<<8)); |
316 | string nodecrc = String.Format("{0:x4}", (int)cmdata[0] + (int)(cmdata[1]<<8)); |
| 361 | nodecrc = "0x"+nodecrc; |
317 | nodecrc = "0x"+nodecrc; |
| 362 | string realcrc = String.Format("{0:x4}", (int)(crc & 0xFF) + (int)(crc & 0xFF00)); |
318 | string realcrc = String.Format("{0:x4}", (int)(crc & 0xFF) + (int)(crc & 0xFF00)); |
| 363 | realcrc = "0x"+realcrc; |
319 | realcrc = "0x"+realcrc; |
| 364 | Console.WriteLine("CRC failed. Node sent CRC "+nodecrc+" but should be "+realcrc+"."); |
320 | Console.WriteLine("CRC failed. Node sent CRC "+nodecrc+" but should be "+realcrc+"."); |
| 365 | errorOccured = true; |
321 | errorOccured = true; |
| 366 | pgs = dState.SEND_RESET; |
322 | pgs = dState.SEND_RESET; |
| 367 | } |
323 | } |
| 368 | 324 | ||
| 369 | byteSent = 0; |
325 | byteSent = 0; |
| 370 | } |
326 | } |
| 371 | //Console.WriteLine("crc: " + crc + " " + (crc>>8) + " " + (crc & 0xFF)); |
327 | //Console.WriteLine("crc: " + crc + " " + (crc>>8) + " " + (crc & 0xFF)); |
| 372 | //Console.WriteLine("ACKpkg with CRC: " + cm.ToString()); |
328 | //Console.WriteLine("ACKpkg with CRC: " + cm.ToString()); |
| 373 | // |
329 | // |
| 374 | } |
330 | } |
| 375 | else if (cpnin.getType() == CAN_NMT_PGM_NACK) { |
331 | else if (cpnin.getType() == CAN_NMT_PGM_NACK) { |
| 376 | // else resend addr.. |
332 | // else resend addr.. |
| 377 | Console.WriteLine("Nack on CAN_NMT_PGM_END."); |
333 | Console.WriteLine("Nack on CAN_NMT_PGM_END."); |
| 378 | errorOccured = true; |
334 | errorOccured = true; |
| 379 | pgs = dState.SEND_RESET; |
335 | pgs = dState.SEND_RESET; |
| 380 | } |
336 | } |
| 381 | } |
337 | } |
| 382 | } |
338 | } |
| 383 | break; |
339 | break; |
| 384 | 340 | ||
| 385 | case dState.SEND_BIOS_UPDATE: |
341 | case dState.SEND_BIOS_UPDATE: |
| 386 | data[0] = (byte)(0 & 0x00FF); |
342 | data[0] = (byte)(0 & 0x00FF); |
| 387 | data[1] = (byte)((0 & 0xFF00) >> 8); |
343 | data[1] = (byte)((0 & 0xFF00) >> 8); |
| 388 | data[2] = (byte)(dlOffset & 0x00FF); |
344 | data[2] = (byte)(dlOffset & 0x00FF); |
| 389 | data[3] = (byte)((dlOffset & 0xFF00) >> 8); |
345 | data[3] = (byte)((dlOffset & 0xFF00) >> 8); |
| 390 | data[4] = (byte)((hf.getAddrUpper()-hf.getAddrLower()+1) & 0x00FF); |
346 | data[4] = (byte)((hf.getAddrUpper()-hf.getAddrLower()+1) & 0x00FF); |
| 391 | data[5] = (byte)(((hf.getAddrUpper()-hf.getAddrLower()+1) & 0xFF00) >> 8); |
347 | data[5] = (byte)(((hf.getAddrUpper()-hf.getAddrLower()+1) & 0xFF00) >> 8); |
| 392 | 348 | ||
| 393 | outCm = cpn.getPgmCopyPacket(data); |
349 | outCm = cpn.getPgmCopyPacket(data); |
| 394 | Console.WriteLine("Now say a prayer, moving bios"); |
350 | Console.WriteLine("Now say a prayer, moving bios"); |
| 395 | dc.sendCanPacket(outCm); |
351 | dc.sendCanPacket(outCm); |
| 396 | t = Environment.TickCount; |
352 | t = Environment.TickCount; |
| 397 | t2 = Environment.TickCount; |
353 | t2 = Environment.TickCount; |
| 398 | pgs = dState.WAIT_BOOT; |
354 | pgs = dState.WAIT_BOOT; |
| 399 | //pgs = dState.DONE; |
355 | //pgs = dState.DONE; |
| 400 | break; |
356 | break; |
| 401 | 357 | ||
| 402 | case dState.WAIT_BOOT: |
358 | case dState.WAIT_BOOT: |
| 403 | // Wait for node reset answer (boot msg). |
359 | // Wait for node reset answer (boot msg). |
| 404 | if ((Environment.TickCount - t) > 3*TIMEOUT_MS) { |
360 | if ((Environment.TickCount - t) > 3*TIMEOUT_MS) { |
| 405 | // Woops, error. |
361 | // Woops, error. |
| 406 | Console.WriteLine("Timeout while waiting for node to boot."); |
362 | Console.WriteLine("Timeout while waiting for node to boot."); |
| 407 | errorOccured = true; |
363 | errorOccured = true; |
| 408 | pgs = dState.SEND_DONE; |
364 | pgs = dState.SEND_DONE; |
| 409 | } |
365 | } |
| 410 | //Thread.Sleep(1); |
366 | //Thread.Sleep(1); |
| 411 | // If received boot msg. |
367 | // If received boot msg. |
| 412 | hasMessage = dc.getData(out cm); |
368 | hasMessage = dc.getData(out cm); |
| 413 | if (hasMessage) { |
369 | if (hasMessage) { |
| 414 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
370 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 415 | if (cpnin.isNMTPacket()) { |
371 | if (cpnin.isNMTPacket()) { |
| 416 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
372 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 417 | // If no error |
373 | // If no error |
| 418 | if (cpnin.getType() == CAN_NMT_BIOS_START) { |
374 | if (cpnin.getType() == CAN_NMT_BIOS_START) { |
| 419 | pgs = dState.SEND_EMPTY_START; |
375 | pgs = dState.SEND_EMPTY_START; |
| 420 | } |
376 | } |
| 421 | else { |
377 | else { |
| 422 | // else .. |
378 | // else .. |
| 423 | } |
379 | } |
| 424 | } |
380 | } |
| 425 | } |
381 | } |
| 426 | break; |
382 | break; |
| 427 | 383 | ||
| 428 | case dState.SEND_EMPTY_START: |
384 | case dState.SEND_EMPTY_START: |
| 429 | // Send boot start packet to target. |
385 | // Send boot start packet to target. |
| 430 | // and wait for ack. |
386 | // and wait for ack. |
| 431 | 387 | ||
| 432 | //data[RID_INDEX] = TARGET_ID; |
388 | //data[RID_INDEX] = TARGET_ID; |
| 433 | data[ADDR0_INDEX] = (byte)((0) & 0x0000FF); |
389 | data[ADDR0_INDEX] = (byte)((0) & 0x0000FF); |
| 434 | data[ADDR1_INDEX] = (byte)(((0) & 0x00FF00) >> 8); |
390 | data[ADDR1_INDEX] = (byte)(((0) & 0x00FF00) >> 8); |
| 435 | data[ADDR2_INDEX] = (byte)(((0) & 0xFF0000) >> 16); |
391 | data[ADDR2_INDEX] = (byte)(((0) & 0xFF0000) >> 16); |
| 436 | data[ADDR3_INDEX] = 0; |
392 | data[ADDR3_INDEX] = 0; |
| 437 | if (HWID_INUSE) { |
393 | if (HWID_INUSE) { |
| 438 | data[HWID0_INDEX] = (byte)((hwid) & 0xFF); |
394 | data[HWID0_INDEX] = (byte)((hwid) & 0xFF); |
| 439 | data[HWID1_INDEX] = (byte)((hwid>>8) & 0xFF); |
395 | data[HWID1_INDEX] = (byte)((hwid>>8) & 0xFF); |
| 440 | data[HWID2_INDEX] = (byte)((hwid>>16) & 0xFF); |
396 | data[HWID2_INDEX] = (byte)((hwid>>16) & 0xFF); |
| 441 | data[HWID3_INDEX] = (byte)((hwid>>24) & 0xFF); |
397 | data[HWID3_INDEX] = (byte)((hwid>>24) & 0xFF); |
| 442 | } |
398 | } |
| 443 | //outCm = new CanPacket(CAN_NMT, CAN_NMT_PGM_START, MY_ID, receiveID, 4, data); |
399 | //outCm = new CanPacket(CAN_NMT, CAN_NMT_PGM_START, MY_ID, receiveID, 4, data); |
| 444 | outCm = cpn.getPgmStartPacket(data); |
400 | outCm = cpn.getPgmStartPacket(data); |
| 445 | dc.sendCanPacket(outCm); |
401 | dc.sendCanPacket(outCm); |
| 446 | t = Environment.TickCount; |
402 | t = Environment.TickCount; |
| 447 | t2 = Environment.TickCount; |
403 | t2 = Environment.TickCount; |
| 448 | pgs = dState.WAIT_ACK_PRG_EMPTY; |
404 | pgs = dState.WAIT_ACK_PRG_EMPTY; |
| 449 | break; |
405 | break; |
| 450 | 406 | ||
| 451 | 407 | ||
| 452 | case dState.WAIT_ACK_PRG_EMPTY: |
408 | case dState.WAIT_ACK_PRG_EMPTY: |
| 453 | // Check for timeout, resend start packet in that case.. |
409 | // Check for timeout, resend start packet in that case.. |
| 454 | if ((Environment.TickCount - t) > 3*TIMEOUT_MS) { |
410 | if ((Environment.TickCount - t) > 3*TIMEOUT_MS) { |
| 455 | Console.WriteLine("Timeout while waiting for start prg ack during empty-first-block-cycle."); |
411 | Console.WriteLine("Timeout while waiting for start prg ack during empty-first-block-cycle."); |
| 456 | errorOccured = true; |
412 | errorOccured = true; |
| 457 | pgs = dState.SEND_RESET; |
413 | pgs = dState.SEND_RESET; |
| 458 | } |
414 | } |
| 459 | //Thread.Sleep(1); |
415 | //Thread.Sleep(1); |
| 460 | // If received ack. |
416 | // If received ack. |
| 461 | hasMessage = dc.getData(out cm); |
417 | hasMessage = dc.getData(out cm); |
| 462 | if (hasMessage) { |
418 | if (hasMessage) { |
| 463 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
419 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 464 | if (cpnin.isNMTPacket()) { |
420 | if (cpnin.isNMTPacket()) { |
| 465 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
421 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 466 | // If no error |
422 | // If no error |
| 467 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
423 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
| 468 | // Start sending program data.. |
424 | // Start sending program data.. |
| 469 | byteSent = 0; |
425 | byteSent = 0; |
| 470 | pgs = dState.SEND_EMPTY_DATA; |
426 | pgs = dState.SEND_EMPTY_DATA; |
| 471 | } |
427 | } |
| 472 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
428 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
| 473 | // else .. |
429 | // else .. |
| 474 | Console.WriteLine("Nack on CAN_NMT_PGM_START."); |
430 | Console.WriteLine("Nack on CAN_NMT_PGM_START."); |
| 475 | errorOccured = true; |
431 | errorOccured = true; |
| 476 | pgs = dState.SEND_RESET; |
432 | pgs = dState.SEND_RESET; |
| 477 | } |
433 | } |
| 478 | } |
434 | } |
| 479 | } |
435 | } |
| 480 | break; |
436 | break; |
| 481 | 437 | ||
| 482 | case dState.SEND_EMPTY_DATA: |
438 | case dState.SEND_EMPTY_DATA: |
| 483 | // Send program data. |
439 | // Send program data. |
| 484 | data[0] = 0; |
440 | data[0] = 0; |
| 485 | data[1] = 0; |
441 | data[1] = 0; |
| 486 | data[2] = 0xff; |
442 | data[2] = 0xff; |
| 487 | data[3] = 0xff; |
443 | data[3] = 0xff; |
| 488 | 444 | ||
| 489 | outCm = cpn.getPgmDataPacket(data, 4); |
445 | outCm = cpn.getPgmDataPacket(data, 4); |
| 490 | dc.sendCanPacket(outCm); |
446 | dc.sendCanPacket(outCm); |
| 491 | 447 | ||
| 492 | t = Environment.TickCount; |
448 | t = Environment.TickCount; |
| 493 | t2 = Environment.TickCount; |
449 | t2 = Environment.TickCount; |
| 494 | byteSent += 6; |
450 | byteSent += 6; |
| 495 | pgs = dState.WAIT_ACK_EMPTY_DATA; |
451 | pgs = dState.WAIT_ACK_EMPTY_DATA; |
| 496 | break; |
452 | break; |
| 497 | 453 | ||
| 498 | 454 | ||
| 499 | case dState.WAIT_ACK_EMPTY_DATA: |
455 | case dState.WAIT_ACK_EMPTY_DATA: |
| 500 | // Wait for pgm ack. |
456 | // Wait for pgm ack. |
| 501 | if ((Environment.TickCount - t) > 2*TIMEOUT_MS) { |
457 | if ((Environment.TickCount - t) > 2*TIMEOUT_MS) { |
| 502 | // Woops, error. |
458 | // Woops, error. |
| 503 | Console.WriteLine("Timeout while waiting for data ack."); |
459 | Console.WriteLine("Timeout while waiting for data ack."); |
| 504 | errorOccured = true; |
460 | errorOccured = true; |
| 505 | pgs = dState.SEND_RESET; |
461 | pgs = dState.SEND_RESET; |
| 506 | } |
462 | } |
| 507 | //Thread.Sleep(1); |
463 | //Thread.Sleep(1); |
| 508 | // If received ack. |
464 | // If received ack. |
| 509 | hasMessage = dc.getData(out cm); |
465 | hasMessage = dc.getData(out cm); |
| 510 | if (hasMessage) { |
466 | if (hasMessage) { |
| 511 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
467 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 512 | if (cpnin.isNMTPacket()) { |
468 | if (cpnin.isNMTPacket()) { |
| 513 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
469 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 514 | // If no error |
470 | // If no error |
| 515 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
471 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
| 516 | pgs = dState.SEND_DONE_EMPTY; |
472 | pgs = dState.SEND_DONE_EMPTY; |
| 517 | } |
473 | } |
| 518 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
474 | else if (cpnin.getType() == CAN_NMT_PGM_NACK ) { |
| 519 | // else .. |
475 | // else .. |
| 520 | Console.WriteLine("Nack on CAN_NMT_PGM_DATA."); |
476 | Console.WriteLine("Nack on CAN_NMT_PGM_DATA."); |
| 521 | errorOccured = true; |
477 | errorOccured = true; |
| 522 | pgs = dState.SEND_RESET; |
478 | pgs = dState.SEND_RESET; |
| 523 | } |
479 | } |
| 524 | } |
480 | } |
| 525 | } |
481 | } |
| 526 | break; |
482 | break; |
| 527 | 483 | ||
| 528 | case dState.SEND_DONE_EMPTY: |
484 | case dState.SEND_DONE_EMPTY: |
| 529 | // Send done |
485 | // Send done |
| 530 | outCm = cpn.getPgmEndPacket(); |
486 | outCm = cpn.getPgmEndPacket(); |
| 531 | dc.sendCanPacket(outCm); |
487 | dc.sendCanPacket(outCm); |
| 532 | 488 | ||
| 533 | t = Environment.TickCount; |
489 | t = Environment.TickCount; |
| 534 | t2 = Environment.TickCount; |
490 | t2 = Environment.TickCount; |
| 535 | pgs = dState.WAIT_DONE_EMPTY; |
491 | pgs = dState.WAIT_DONE_EMPTY; |
| 536 | break; |
492 | break; |
| 537 | 493 | ||
| 538 | 494 | ||
| 539 | case dState.WAIT_DONE_EMPTY: |
495 | case dState.WAIT_DONE_EMPTY: |
| 540 | // Check for timeout, resend done packet in that case.. |
496 | // Check for timeout, resend done packet in that case.. |
| 541 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
497 | if ((Environment.TickCount - t) > TIMEOUT_MS) { |
| 542 | Console.WriteLine("Timeout while waiting for end prg ack."); |
498 | Console.WriteLine("Timeout while waiting for end prg ack."); |
| 543 | errorOccured = true; |
499 | errorOccured = true; |
| 544 | pgs = dState.SEND_RESET; |
500 | pgs = dState.SEND_RESET; |
| 545 | } |
501 | } |
| 546 | //Thread.Sleep(1); |
502 | //Thread.Sleep(1); |
| 547 | 503 | ||
| 548 | hasMessage = dc.getData(out cm); |
504 | hasMessage = dc.getData(out cm); |
| 549 | if (hasMessage) { |
505 | if (hasMessage) { |
| 550 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
506 | CanNMT cpnin = new CanNMT(cm, HWID_INUSE); |
| 551 | if (cpnin.isNMTPacket()) { |
507 | if (cpnin.isNMTPacket()) { |
| 552 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
508 | //if (cpnin.isNMTPacket() && (cpnin.getSender() == receiveID)) { |
| 553 | // If no error |
509 | // If no error |
| 554 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
510 | if (cpnin.getType() == CAN_NMT_PGM_ACK) { |
| 555 | Console.WriteLine(""); |
511 | Console.WriteLine(""); |
| 556 | // |
512 | // |
| 557 | Console.WriteLine("Done, successfully cleaned application flash."); |
513 | Console.WriteLine("Done, successfully cleaned application flash."); |
| 558 | pgs = dState.SEND_RESET; |
514 | pgs = dState.SEND_RESET; |
| 559 | } |
515 | } |
| 560 | else if (cpnin.getType() == CAN_NMT_PGM_NACK) { |
516 | else if (cpnin.getType() == CAN_NMT_PGM_NACK) { |
| 561 | // else resend addr.. |
517 | // else resend addr.. |
| 562 | Console.WriteLine("Nack on CAN_NMT_PGM_END."); |
518 | Console.WriteLine("Nack on CAN_NMT_PGM_END."); |
| 563 | errorOccured = true; |
519 | errorOccured = true; |
| 564 | pgs = dState.SEND_RESET; |
520 | pgs = dState.SEND_RESET; |
| 565 | } |
521 | } |
| 566 | } |
522 | } |
| 567 | } |
523 | } |
| 568 | break; |
524 | break; |
| 569 | case dState.SEND_RESET: |
525 | case dState.SEND_RESET: |
| 570 | // Send reset |
526 | // Send reset |
| 571 | cpn.doReset(dc, receiveID, hwid); |
527 | cpn.doReset(dc, receiveID, hwid); |
| 572 | t = Environment.TickCount; |
528 | t = Environment.TickCount; |
| 573 | t2 = Environment.TickCount; |
529 | t2 = Environment.TickCount; |
| 574 | pgs = dState.DONE; |
530 | pgs = dState.DONE; |
| 575 | break; |
531 | break; |
| 576 | 532 | ||
| 577 | 533 | ||
| 578 | case dState.DONE: |
534 | case dState.DONE: |
| 579 | done = true; |
535 | done = true; |
| 580 | //down.Abort(); |
536 | //down.Abort(); |
| 581 | if (!errorOccured) { |
537 | if (!errorOccured) { |
| 582 | long tsecs = ((Environment.TickCount - timeStart) / 1000); |
538 | long tsecs = ((Environment.TickCount - timeStart) / 1000); |
| 583 | double bitRate = hf.getLength() / ((double)(Environment.TickCount - timeStart) / 1000.0); |
539 | double bitRate = hf.getLength() / ((double)(Environment.TickCount - timeStart) / 1000.0); |
| 584 | 540 | ||
| 585 | if (tsecs <= 0) tsecs = 1; |
541 | if (tsecs <= 0) tsecs = 1; |
| 586 | long mins = tsecs / 60; |
542 | long mins = tsecs / 60; |
| 587 | long secs = tsecs % 60; |
543 | long secs = tsecs % 60; |
| 588 | string pad = ""; |
544 | string pad = ""; |
| 589 | if (secs < 10) { |
545 | if (secs < 10) { |
| 590 | pad = "0"; |
546 | pad = "0"; |
| 591 | } |
547 | } |
| 592 | Console.WriteLine("Time spent: " + mins + ":" + pad + secs + ", " + Math.Round(bitRate, 2) + " bytes/s"); |
548 | Console.WriteLine("Time spent: " + mins + ":" + pad + secs + ", " + Math.Round(bitRate, 2) + " bytes/s"); |
| 593 | } |
549 | } |
| 594 | //Console.Write("> "); |
550 | //Console.Write("> "); |
| 595 | break; |
551 | break; |
| 596 | } |
552 | } |
| 597 | } |
553 | } |
| 598 | 554 | ||
| 599 | } catch(Exception) { |
555 | } catch(Exception) { |
| 600 | Console.WriteLine("Exception occured"); |
556 | Console.WriteLine("Exception occured"); |
| 601 | //Console.WriteLine(e); |
557 | //Console.WriteLine(e); |
| 602 | //skriva ut antal bytes skrivna vore bra här, kanske nån annan form av hjälp för debug, något gick snett liksom |
558 | //skriva ut antal bytes skrivna vore bra här, kanske nån annan form av hjälp för debug, något gick snett liksom |
| 603 | 559 | ||
| 604 | } |
560 | } |
| 605 | 561 | ||
| 606 | return !errorOccured; |
562 | return !errorOccured; |
| 607 | } |
563 | } |
| 608 | } |
564 | } |
| 609 | 565 | ||