Mercurial > public > ostc4
annotate ostc4pack/src/OSTC4pack_V4.cpp @ 803:96ffad0a4e57
Cleanup initialisation / deinitialization:
The UART1 is now deactivated during sleep and will be reactivated with the default baudrate 19200. This avoid unpredicted behavior in case of sleep => awake transitions (always start from scratch)
| author | Ideenmodellierer |
|---|---|
| date | Thu, 10 Aug 2023 21:30:24 +0200 |
| parents | 01f40cb1057e |
| children |
| rev | line source |
|---|---|
| 49 | 1 #include <iostream> |
| 2 | |
| 3 /* run this program using the console pauser or add your own getch, system("pause") or input loop */ | |
| 4 | |
| 5 | |
| 6 | |
| 7 | |
| 8 #include <stdlib.h> | |
| 9 | |
| 10 /******************************************************************************/ | |
| 11 /* Start of crcmodel.h */ | |
| 12 /******************************************************************************/ | |
| 13 /* */ | |
| 14 /* Author : Ross Williams (ross@guest.adelaide.edu.au.). */ | |
| 15 /* Date : 3 June 1993. */ | |
| 16 /* Status : Public domain. */ | |
| 17 /* */ | |
| 18 /* Description : This is the header (.h) file for the reference */ | |
| 19 /* implementation of the Rocksoft^tm Model CRC Algorithm. For more */ | |
| 20 /* information on the Rocksoft^tm Model CRC Algorithm, see the document */ | |
| 21 /* titled "A Painless Guide to CRC Error Detection Algorithms" by Ross */ | |
| 22 /* Williams (ross@guest.adelaide.edu.au.). This document is likely to be in */ | |
| 23 /* "ftp.adelaide.edu.au/pub/rocksoft". */ | |
| 24 /* */ | |
| 25 /* Note: Rocksoft is a trademark of Rocksoft Pty Ltd, Adelaide, Australia. */ | |
| 26 /* */ | |
| 27 /******************************************************************************/ | |
| 28 /* */ | |
| 29 /* How to Use This Package */ | |
| 30 /* ----------------------- */ | |
| 31 /* Step 1: Declare a variable of type cm_t. Declare another variable */ | |
| 32 /* (p_cm say) of type p_cm_t and initialize it to point to the first */ | |
| 33 /* variable (e.g. p_cm_t p_cm = &cm_t). */ | |
| 34 /* */ | |
| 35 /* Step 2: Assign values to the parameter fields of the structure. */ | |
| 36 /* If you don't know what to assign, see the document cited earlier. */ | |
| 37 /* For example: */ | |
| 38 /* p_cm->cm_width = 16; */ | |
| 39 /* p_cm->cm_poly = 0x8005L; */ | |
| 40 /* p_cm->cm_init = 0L; */ | |
| 41 /* p_cm->cm_refin = TRUE; */ | |
| 42 /* p_cm->cm_refot = TRUE; */ | |
| 43 /* p_cm->cm_xorot = 0L; */ | |
| 44 /* Note: Poly is specified without its top bit (18005 becomes 8005). */ | |
| 45 /* Note: Width is one bit less than the raw poly width. */ | |
| 46 /* */ | |
| 47 /* Step 3: Initialize the instance with a call cm_ini(p_cm); */ | |
| 48 /* */ | |
| 49 /* Step 4: Process zero or more message bytes by placing zero or more */ | |
| 50 /* successive calls to cm_nxt. Example: cm_nxt(p_cm,ch); */ | |
| 51 /* */ | |
| 52 /* Step 5: Extract the CRC value at any time by calling crc = cm_crc(p_cm); */ | |
| 53 /* If the CRC is a 16-bit value, it will be in the bottom 16 bits. */ | |
| 54 /* */ | |
| 55 /******************************************************************************/ | |
| 56 /* */ | |
| 57 /* Design Notes */ | |
| 58 /* ------------ */ | |
| 59 /* PORTABILITY: This package has been coded very conservatively so that */ | |
| 60 /* it will run on as many machines as possible. For example, all external */ | |
| 61 /* identifiers have been restricted to 6 characters and all internal ones to */ | |
| 62 /* 8 characters. The prefix cm (for Crc Model) is used as an attempt to avoid */ | |
| 63 /* namespace collisions. This package is endian independent. */ | |
| 64 /* */ | |
| 65 /* EFFICIENCY: This package (and its interface) is not designed for */ | |
| 66 /* speed. The purpose of this package is to act as a well-defined reference */ | |
| 67 /* model for the specification of CRC algorithms. If you want speed, cook up */ | |
| 68 /* a specific table-driven implementation as described in the document cited */ | |
| 69 /* above. This package is designed for validation only; if you have found or */ | |
| 70 /* implemented a CRC algorithm and wish to describe it as a set of parameters */ | |
| 71 /* to the Rocksoft^tm Model CRC Algorithm, your CRC algorithm implementation */ | |
| 72 /* should behave identically to this package under those parameters. */ | |
| 73 /* */ | |
| 74 /******************************************************************************/ | |
| 75 | |
| 76 /* The following #ifndef encloses this entire */ | |
| 77 /* header file, rendering it indempotent. */ | |
| 78 #ifndef CM_DONE | |
| 79 #define CM_DONE | |
| 80 | |
| 81 /******************************************************************************/ | |
| 82 | |
| 83 /* The following definitions are extracted from my style header file which */ | |
| 84 /* would be cumbersome to distribute with this package. The DONE_STYLE is the */ | |
| 85 /* idempotence symbol used in my style header file. */ | |
| 86 | |
| 87 #ifndef DONE_STYLE | |
| 88 | |
| 89 typedef unsigned long ulong; | |
| 90 typedef unsigned char * p_ubyte_; | |
| 91 | |
| 92 #ifndef TRUE | |
| 93 #define FALSE 0 | |
| 94 #define TRUE 1 | |
| 95 #endif | |
| 96 | |
| 97 /* Change to the second definition if you don't have prototypes. */ | |
| 98 #define P_(A) A | |
| 99 /* #define P_(A) () */ | |
| 100 | |
| 101 /* Uncomment this definition if you don't have void. */ | |
| 102 /* typedef int void; */ | |
| 103 | |
| 104 #endif | |
| 105 | |
| 106 /******************************************************************************/ | |
| 107 | |
| 108 /* CRC Model Abstract Type */ | |
| 109 /* ----------------------- */ | |
| 110 /* The following type stores the context of an executing instance of the */ | |
| 111 /* model algorithm. Most of the fields are model parameters which must be */ | |
| 112 /* set before the first initializing call to cm_ini. */ | |
| 113 typedef struct | |
| 114 { | |
| 115 int cm_width; /* Parameter: Width in bits [8,32]. */ | |
| 116 ulong cm_poly; /* Parameter: The algorithm's polynomial. */ | |
| 117 ulong cm_init; /* Parameter: Initial register value. */ | |
| 118 bool cm_refin; /* Parameter: Reflect input bytes? */ | |
| 119 bool cm_refot; /* Parameter: Reflect output CRC? */ | |
| 120 ulong cm_xorot; /* Parameter: XOR this to output CRC. */ | |
| 121 | |
| 122 ulong cm_reg; /* Context: Context during execution. */ | |
| 123 } cm_t; | |
| 124 typedef cm_t *p_cm_t; | |
| 125 | |
| 126 /******************************************************************************/ | |
| 127 | |
| 128 /* Functions That Implement The Model */ | |
| 129 /* ---------------------------------- */ | |
| 130 /* The following functions animate the cm_t abstraction. */ | |
| 131 | |
| 132 void cm_ini P_((p_cm_t p_cm)); | |
| 133 /* Initializes the argument CRC model instance. */ | |
| 134 /* All parameter fields must be set before calling this. */ | |
| 135 | |
| 136 void cm_nxt P_((p_cm_t p_cm,int ch)); | |
| 137 /* Processes a single message byte [0,255]. */ | |
| 138 | |
| 139 void cm_blk P_((p_cm_t p_cm,p_ubyte_ blk_adr,ulong blk_len)); | |
| 140 /* Processes a block of message bytes. */ | |
| 141 | |
| 142 ulong cm_crc P_((p_cm_t p_cm)); | |
| 143 /* Returns the CRC value for the message bytes processed so far. */ | |
| 144 | |
| 145 /******************************************************************************/ | |
| 146 | |
| 147 /* Functions For Table Calculation */ | |
| 148 /* ------------------------------- */ | |
| 149 /* The following function can be used to calculate a CRC lookup table. */ | |
| 150 /* It can also be used at run-time to create or check static tables. */ | |
| 151 | |
| 152 ulong cm_tab P_((p_cm_t p_cm,int index)); | |
| 153 /* Returns the i'th entry for the lookup table for the specified algorithm. */ | |
| 154 /* The function examines the fields cm_width, cm_poly, cm_refin, and the */ | |
| 155 /* argument table index in the range [0,255] and returns the table entry in */ | |
| 156 /* the bottom cm_width bytes of the return value. */ | |
| 157 | |
| 158 /******************************************************************************/ | |
| 159 | |
| 160 /* End of the header file idempotence #ifndef */ | |
| 161 #endif | |
| 162 | |
| 163 /******************************************************************************/ | |
| 164 /* End of crcmodel.h */ | |
| 165 /******************************************************************************/ | |
| 166 | |
| 167 | |
| 168 /******************************************************************************/ | |
| 169 /* Start of crcmodel.c */ | |
| 170 /******************************************************************************/ | |
| 171 /* */ | |
| 172 /* Author : Ross Williams (ross@guest.adelaide.edu.au.). */ | |
| 173 /* Date : 3 June 1993. */ | |
| 174 /* Status : Public domain. */ | |
| 175 /* */ | |
| 176 /* Description : This is the implementation (.c) file for the reference */ | |
| 177 /* implementation of the Rocksoft^tm Model CRC Algorithm. For more */ | |
| 178 /* information on the Rocksoft^tm Model CRC Algorithm, see the document */ | |
| 179 /* titled "A Painless Guide to CRC Error Detection Algorithms" by Ross */ | |
| 180 /* Williams (ross@guest.adelaide.edu.au.). This document is likely to be in */ | |
| 181 /* "ftp.adelaide.edu.au/pub/rocksoft". */ | |
| 182 /* */ | |
| 183 /* Note: Rocksoft is a trademark of Rocksoft Pty Ltd, Adelaide, Australia. */ | |
| 184 /* */ | |
| 185 /******************************************************************************/ | |
| 186 /* */ | |
| 187 /* Implementation Notes */ | |
| 188 /* -------------------- */ | |
| 189 /* To avoid inconsistencies, the specification of each function is not echoed */ | |
| 190 /* here. See the header file for a description of these functions. */ | |
| 191 /* This package is light on checking because I want to keep it short and */ | |
| 192 /* simple and portable (i.e. it would be too messy to distribute my entire */ | |
| 193 /* C culture (e.g. assertions package) with this package. */ | |
| 194 /* */ | |
| 195 /******************************************************************************/ | |
| 196 | |
| 197 #include "crcmodel.h" | |
| 198 | |
| 199 /******************************************************************************/ | |
| 200 | |
| 201 /* The following definitions make the code more readable. */ | |
| 202 | |
| 203 #define BITMASK(X) (1L << (X)) | |
| 204 #define MASK32 0xFFFFFFFFL | |
| 205 #define LOCAL static | |
| 206 | |
| 207 /******************************************************************************/ | |
| 208 | |
| 209 ulong reflect P_((ulong v,int b)) | |
| 210 { | |
| 211 int i; | |
| 212 ulong t = v; | |
| 213 for (i=0; i<b; i++) | |
| 214 { | |
| 215 if (t & 1L) | |
| 216 v|= BITMASK((b-1)-i); | |
| 217 else | |
| 218 v&= ~BITMASK((b-1)-i); | |
| 219 t>>=1; | |
| 220 } | |
| 221 return v; | |
| 222 } | |
| 223 | |
| 224 /******************************************************************************/ | |
| 225 | |
| 226 LOCAL ulong widmask (p_cm_t p_cm) | |
| 227 { | |
| 228 return (((1L<<(p_cm->cm_width-1))-1L)<<1)|1L; | |
| 229 } | |
| 230 | |
| 231 /******************************************************************************/ | |
| 232 | |
| 233 void cm_ini (p_cm_t p_cm) | |
| 234 { | |
| 235 p_cm->cm_reg = p_cm->cm_init; | |
| 236 } | |
| 237 | |
| 238 /******************************************************************************/ | |
| 239 | |
| 240 void cm_nxt (p_cm_t p_cm,int ch) | |
| 241 { | |
| 242 int i; | |
| 243 ulong uch = (ulong) ch; | |
| 244 ulong topbit = BITMASK(p_cm->cm_width-1); | |
| 245 | |
| 246 if (p_cm->cm_refin) uch = reflect(uch,8); | |
| 247 p_cm->cm_reg ^= (uch << (p_cm->cm_width-8)); | |
| 248 for (i=0; i<8; i++) | |
| 249 { | |
| 250 if (p_cm->cm_reg & topbit) | |
| 251 p_cm->cm_reg = (p_cm->cm_reg << 1) ^ p_cm->cm_poly; | |
| 252 else | |
| 253 p_cm->cm_reg <<= 1; | |
| 254 p_cm->cm_reg &= widmask(p_cm); | |
| 255 } | |
| 256 } | |
| 257 | |
| 258 /******************************************************************************/ | |
| 259 | |
| 260 void cm_blk (p_cm_t p_cm,p_ubyte_ blk_adr,ulong blk_len) | |
| 261 { | |
| 262 while (blk_len--) cm_nxt(p_cm,*blk_adr++); | |
| 263 } | |
| 264 | |
| 265 /******************************************************************************/ | |
| 266 | |
| 267 ulong cm_crc (p_cm_t p_cm) | |
| 268 { | |
| 269 if (p_cm->cm_refot) | |
| 270 return p_cm->cm_xorot ^ reflect(p_cm->cm_reg,p_cm->cm_width); | |
| 271 else | |
| 272 return p_cm->cm_xorot ^ p_cm->cm_reg; | |
| 273 } | |
| 274 | |
| 275 /******************************************************************************/ | |
| 276 | |
| 277 ulong cm_tab (p_cm_t p_cm,int index) | |
| 278 { | |
| 279 int i; | |
| 280 ulong r; | |
| 281 ulong topbit = BITMASK(p_cm->cm_width-1); | |
| 282 ulong inbyte = (ulong) index; | |
| 283 | |
| 284 if (p_cm->cm_refin) inbyte = reflect(inbyte,8); | |
| 285 r = inbyte << (p_cm->cm_width-8); | |
| 286 for (i=0; i<8; i++) | |
| 287 if (r & topbit) | |
| 288 r = (r << 1) ^ p_cm->cm_poly; | |
| 289 else | |
| 290 r<<=1; | |
| 291 if (p_cm->cm_refin) r = reflect(r,p_cm->cm_width); | |
| 292 return r & widmask(p_cm); | |
| 293 } | |
| 294 | |
| 295 /******************************************************************************/ | |
| 296 /* End of crcmodel.c */ | |
| 297 /******************************************************************************/ | |
| 298 | |
| 299 #define uint32_t unsigned int | |
| 300 #define uint8_t unsigned char | |
| 301 | |
| 302 uint32_t CRC_CalcBlockCRC(uint32_t *buffer, uint32_t words) | |
| 303 { | |
| 304 cm_t crc_model; | |
| 305 uint32_t word_to_do; | |
| 306 uint8_t byte_to_do; | |
| 307 int i; | |
| 308 | |
| 309 // Values for the STM32F generator. | |
| 310 | |
| 311 crc_model.cm_width = 32; // 32-bit CRC | |
| 312 crc_model.cm_poly = 0x04C11DB7; // CRC-32 polynomial | |
| 313 crc_model.cm_init = 0xFFFFFFFF; // CRC initialized to 1's | |
| 314 crc_model.cm_refin = FALSE; // CRC calculated MSB first | |
| 315 crc_model.cm_refot = FALSE; // Final result is not bit-reversed | |
| 316 crc_model.cm_xorot = 0x00000000; // Final result XOR'ed with this | |
| 317 | |
| 318 cm_ini(&crc_model); | |
| 319 | |
| 320 while (words--) | |
| 321 { | |
| 322 // The STM32F10x hardware does 32-bit words at a time!!! | |
| 323 | |
| 324 word_to_do = *buffer++; | |
| 325 | |
| 326 // Do all bytes in the 32-bit word. | |
| 327 | |
| 328 for (i = 0; i < sizeof(word_to_do); i++) | |
| 329 { | |
| 330 // We calculate a *byte* at a time. If the CRC is MSB first we | |
| 331 // do the next MS byte and vica-versa. | |
| 332 | |
| 333 if (crc_model.cm_refin == FALSE) | |
| 334 { | |
| 335 // MSB first. Do the next MS byte. | |
| 336 | |
| 337 byte_to_do = (uint8_t) ((word_to_do & 0xFF000000) >> 24); | |
| 338 word_to_do <<= 8; | |
| 339 } | |
| 340 else | |
| 341 { | |
| 342 // LSB first. Do the next LS byte. | |
| 343 | |
| 344 byte_to_do = (uint8_t) (word_to_do & 0x000000FF); | |
| 345 word_to_do >>= 8; | |
| 346 } | |
| 347 | |
| 348 cm_nxt(&crc_model, byte_to_do); | |
| 349 } | |
| 350 } | |
| 351 | |
| 352 // Return the final result. | |
| 353 | |
| 354 return (cm_crc(&crc_model)); | |
| 355 } | |
| 356 | |
| 357 | |
| 358 unsigned checksum(void *buffer, size_t len, unsigned int seed) | |
| 359 { | |
| 360 unsigned char *buf = (unsigned char *)buffer; | |
| 361 size_t i; | |
| 362 | |
| 363 for (i = 0; i < len; ++i) | |
| 364 seed += (unsigned int)(*buf++); | |
| 365 return seed; | |
| 366 } | |
| 367 | |
| 368 unsigned int crc32c_checksum(unsigned char* message, int length) { | |
| 369 int i, j; | |
| 370 unsigned int byte, crc, mask; | |
| 371 static unsigned int table[256] = {0}; | |
| 372 | |
| 373 /* Set up the table, if necessary. */ | |
| 374 | |
| 375 if (table[1] == 0) { | |
| 376 for (byte = 0; byte <= 255; byte++) { | |
| 377 crc = byte; | |
| 378 for (j = 7; j >= 0; j--) { // Do eight times. | |
| 379 mask = -(crc & 1); | |
| 380 crc = (crc >> 1) ^ (0xEDB88320 & mask); | |
| 381 } | |
| 382 table[byte] = crc; | |
| 383 } | |
| 384 } | |
| 385 | |
| 386 /* Through with table setup, now calculate the CRC. */ | |
| 387 i = 0; | |
| 388 crc = 0xFFFFFFFF; | |
| 389 while (length--) { | |
| 390 byte = message[i]; | |
| 391 crc = (crc >> 8) ^ table[(crc ^ byte) & 0xFF]; | |
| 392 i = i + 1; | |
| 393 } | |
| 394 return ~crc; | |
| 395 } | |
| 396 | |
| 397 | |
| 398 | |
| 399 | |
| 400 | |
| 401 | |
| 402 /******************************************************************************/ | |
| 403 | |
| 404 /* MAIN */ | |
| 405 /* ----------------------- */ | |
| 406 /* */ | |
| 407 | |
| 408 | |
| 409 #include <stdio.h> | |
| 410 #include <string.h> | |
| 411 int main(int argc, char** argv) { | |
| 412 | |
| 413 | |
|
162
ad98da7e74f8
OSTC4pack_V4: do not hard code output filename for fonts
Jan Mulder <jlmulder@xs4all.nl>
parents:
49
diff
changeset
|
414 if (argc != 3) { |
|
ad98da7e74f8
OSTC4pack_V4: do not hard code output filename for fonts
Jan Mulder <jlmulder@xs4all.nl>
parents:
49
diff
changeset
|
415 fprintf(stderr, "Usage: OSTC4pack_V4 <type> <bin file>\n"); |
|
ad98da7e74f8
OSTC4pack_V4: do not hard code output filename for fonts
Jan Mulder <jlmulder@xs4all.nl>
parents:
49
diff
changeset
|
416 return(-1); |
|
ad98da7e74f8
OSTC4pack_V4: do not hard code output filename for fonts
Jan Mulder <jlmulder@xs4all.nl>
parents:
49
diff
changeset
|
417 } |
|
ad98da7e74f8
OSTC4pack_V4: do not hard code output filename for fonts
Jan Mulder <jlmulder@xs4all.nl>
parents:
49
diff
changeset
|
418 |
| 699 | 419 FILE *fp; |
| 49 | 420 size_t len; |
| 421 unsigned char buf[1050000]; | |
| 422 char *file = argv[2]; | |
| 423 int type = atoi(argv[1]); | |
| 424 unsigned int pruefsumme; | |
| 425 | |
| 426 //write File with length and cheksum | |
| 699 | 427 char filename[500], filenameout[511]; |
| 49 | 428 sprintf(filename,"%s",file); |
| 429 int filelength = strlen(filename); | |
| 430 filename[filelength -4] = 0; | |
| 431 | |
| 432 if (NULL == (fp = fopen(file, "rb"))) | |
| 433 { | |
| 434 printf("Unable to open %s for reading\n", file); | |
| 435 return -1; | |
| 436 } | |
| 437 len = fread(buf, sizeof(char), sizeof(buf), fp); | |
| 699 | 438 printf("%d bytes read (hex: %#x )\n", (uint32_t)len, (uint32_t)len); |
| 49 | 439 // unsigned int checksum = crc32c_checksum(buf, len); |
| 440 unsigned int checksum = CRC_CalcBlockCRC((uint32_t *)buf, (uint32_t)(len/4)); | |
| 441 printf("The checksum of %s is %#x\n", file, checksum); | |
| 442 | |
| 443 fclose(fp); | |
| 444 if(type == 0) | |
| 445 sprintf(filenameout,"%s_upload.bin",filename); | |
| 446 else | |
| 447 if(type == 2) | |
|
162
ad98da7e74f8
OSTC4pack_V4: do not hard code output filename for fonts
Jan Mulder <jlmulder@xs4all.nl>
parents:
49
diff
changeset
|
448 sprintf(filenameout,"%s_upload.bin",filename); |
| 49 | 449 else |
| 450 sprintf(filenameout,"%s_upload.bin",filename); | |
| 451 | |
| 452 unsigned char buf2[4]; | |
| 453 | |
| 454 buf2[0] = 0xFF & (len >> 24);; | |
| 455 buf2[1] = 0xFF & (len >> 16);; | |
| 456 buf2[2] = 0xFF & (len >> 8); | |
| 457 buf2[3] = 0xFF & len; | |
| 699 | 458 fp = fopen(filenameout, "wb"); |
| 49 | 459 fwrite(buf2,sizeof(char),4,fp); |
| 460 | |
| 461 | |
| 462 unsigned char buf3offset[4]; | |
| 463 unsigned char bufVersion[4]; | |
| 464 if(type == 2) | |
| 465 { | |
| 466 buf3offset[0] = 0x10; | |
| 467 buf3offset[1] = 0x00; | |
| 468 buf3offset[2] = 0x03; | |
| 469 buf3offset[3] = 0x20; | |
| 470 bufVersion[0] = buf[0x00]; | |
| 471 bufVersion[1] = buf[0x01]; | |
| 472 bufVersion[2] = buf[0x02]; | |
| 473 bufVersion[3] = buf[0x03]; | |
| 474 } | |
| 475 else | |
| 476 if(type == 0) | |
| 477 { | |
| 478 buf3offset[0] = 0xFE; | |
| 479 buf3offset[1] = 'R'; | |
| 480 buf3offset[2] = 'T'; | |
| 481 buf3offset[3] = 'E'; | |
| 482 bufVersion[0] = buf[0x5000]; | |
| 483 bufVersion[1] = buf[0x5001]; | |
| 484 bufVersion[2] = buf[0x5002]; | |
| 485 bufVersion[3] = buf[0x5003]; | |
| 486 } | |
| 487 else | |
| 488 { | |
| 489 buf3offset[0] = 0xFF; | |
| 490 buf3offset[1] = 0; | |
| 491 buf3offset[2] = 'H'; | |
| 492 buf3offset[3] = 'W'; | |
| 493 bufVersion[0] = buf[0x10000]; | |
| 494 bufVersion[1] = buf[0x10001]; | |
| 495 bufVersion[2] = buf[0x10002]; | |
| 496 bufVersion[3] = buf[0x10003]; | |
| 497 } | |
| 498 | |
| 499 fwrite(buf3offset,sizeof(char),4,fp); | |
| 500 | |
| 501 pruefsumme = len + (256*256*256*buf3offset[0]) + (256*256*buf3offset[1]) + (256*buf3offset[2]) + buf3offset[3]; | |
| 502 fwrite(&pruefsumme,sizeof(char),4,fp); | |
| 503 | |
| 504 fwrite(bufVersion,sizeof(char),4,fp); | |
| 505 | |
| 506 for(int i = 0;i <len;i++) | |
| 507 { | |
| 699 | 508 if(fwrite(&buf[i],1,1,fp) != 1) |
| 49 | 509 printf("error writing\n"); |
| 510 } | |
| 511 | |
| 512 | |
| 513 buf2[0] = 0xFF & (checksum >> 24);// & 0xFF000000; | |
| 514 buf2[1] = 0xFF & (checksum >> 16); | |
| 515 buf2[2] = 0xFF & (checksum >> 8); | |
| 516 buf2[3] = 0xFF & checksum; | |
| 517 | |
| 518 fwrite(buf2,sizeof(char),4,fp); | |
| 699 | 519 |
| 520 fclose(fp); | |
| 49 | 521 } |