Mercurial > public > ostc4
changeset 49:1e707b34667e
add o4pack files
| author | heinrichsweikamp |
|---|---|
| date | Mon, 30 Jul 2018 11:31:20 +0200 |
| parents | bf43851a678b |
| children | 6310a27fd6d3 |
| files | ostc4pack/OSTC4_FONT_upload.bin ostc4pack/OSTC4_RTE_upload.bin ostc4pack/OSTC4_firmware_upload.bin ostc4pack/OSTC4pack_V4.exe ostc4pack/checksum_final_add_fletcher.exe ostc4pack/src/OSTC4pack_V4.cpp ostc4pack/src/checksum_final_add_fletcher.cpp ostc4pack/step1_create_OSTC4_firmware_upload_bin.bat ostc4pack/step1_create_OSTC_RTE_upload.bat ostc4pack/step2_create_OSTC4update_bin.bat |
| diffstat | 10 files changed, 660 insertions(+), 0 deletions(-) [+] |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ostc4pack/src/OSTC4pack_V4.cpp Mon Jul 30 11:31:20 2018 +0200 @@ -0,0 +1,520 @@ +#include <iostream> + +/* run this program using the console pauser or add your own getch, system("pause") or input loop */ + + + + +#include <stdlib.h> + +/******************************************************************************/ +/* Start of crcmodel.h */ +/******************************************************************************/ +/* */ +/* Author : Ross Williams (ross@guest.adelaide.edu.au.). */ +/* Date : 3 June 1993. */ +/* Status : Public domain. */ +/* */ +/* Description : This is the header (.h) file for the reference */ +/* implementation of the Rocksoft^tm Model CRC Algorithm. For more */ +/* information on the Rocksoft^tm Model CRC Algorithm, see the document */ +/* titled "A Painless Guide to CRC Error Detection Algorithms" by Ross */ +/* Williams (ross@guest.adelaide.edu.au.). This document is likely to be in */ +/* "ftp.adelaide.edu.au/pub/rocksoft". */ +/* */ +/* Note: Rocksoft is a trademark of Rocksoft Pty Ltd, Adelaide, Australia. */ +/* */ +/******************************************************************************/ +/* */ +/* How to Use This Package */ +/* ----------------------- */ +/* Step 1: Declare a variable of type cm_t. Declare another variable */ +/* (p_cm say) of type p_cm_t and initialize it to point to the first */ +/* variable (e.g. p_cm_t p_cm = &cm_t). */ +/* */ +/* Step 2: Assign values to the parameter fields of the structure. */ +/* If you don't know what to assign, see the document cited earlier. */ +/* For example: */ +/* p_cm->cm_width = 16; */ +/* p_cm->cm_poly = 0x8005L; */ +/* p_cm->cm_init = 0L; */ +/* p_cm->cm_refin = TRUE; */ +/* p_cm->cm_refot = TRUE; */ +/* p_cm->cm_xorot = 0L; */ +/* Note: Poly is specified without its top bit (18005 becomes 8005). */ +/* Note: Width is one bit less than the raw poly width. */ +/* */ +/* Step 3: Initialize the instance with a call cm_ini(p_cm); */ +/* */ +/* Step 4: Process zero or more message bytes by placing zero or more */ +/* successive calls to cm_nxt. Example: cm_nxt(p_cm,ch); */ +/* */ +/* Step 5: Extract the CRC value at any time by calling crc = cm_crc(p_cm); */ +/* If the CRC is a 16-bit value, it will be in the bottom 16 bits. */ +/* */ +/******************************************************************************/ +/* */ +/* Design Notes */ +/* ------------ */ +/* PORTABILITY: This package has been coded very conservatively so that */ +/* it will run on as many machines as possible. For example, all external */ +/* identifiers have been restricted to 6 characters and all internal ones to */ +/* 8 characters. The prefix cm (for Crc Model) is used as an attempt to avoid */ +/* namespace collisions. This package is endian independent. */ +/* */ +/* EFFICIENCY: This package (and its interface) is not designed for */ +/* speed. The purpose of this package is to act as a well-defined reference */ +/* model for the specification of CRC algorithms. If you want speed, cook up */ +/* a specific table-driven implementation as described in the document cited */ +/* above. This package is designed for validation only; if you have found or */ +/* implemented a CRC algorithm and wish to describe it as a set of parameters */ +/* to the Rocksoft^tm Model CRC Algorithm, your CRC algorithm implementation */ +/* should behave identically to this package under those parameters. */ +/* */ +/******************************************************************************/ + +/* The following #ifndef encloses this entire */ +/* header file, rendering it indempotent. */ +#ifndef CM_DONE +#define CM_DONE + +/******************************************************************************/ + +/* The following definitions are extracted from my style header file which */ +/* would be cumbersome to distribute with this package. The DONE_STYLE is the */ +/* idempotence symbol used in my style header file. */ + +#ifndef DONE_STYLE + +typedef unsigned long ulong; +typedef unsigned char * p_ubyte_; + +#ifndef TRUE +#define FALSE 0 +#define TRUE 1 +#endif + +/* Change to the second definition if you don't have prototypes. */ +#define P_(A) A +/* #define P_(A) () */ + +/* Uncomment this definition if you don't have void. */ +/* typedef int void; */ + +#endif + +/******************************************************************************/ + +/* CRC Model Abstract Type */ +/* ----------------------- */ +/* The following type stores the context of an executing instance of the */ +/* model algorithm. Most of the fields are model parameters which must be */ +/* set before the first initializing call to cm_ini. */ +typedef struct + { + int cm_width; /* Parameter: Width in bits [8,32]. */ + ulong cm_poly; /* Parameter: The algorithm's polynomial. */ + ulong cm_init; /* Parameter: Initial register value. */ + bool cm_refin; /* Parameter: Reflect input bytes? */ + bool cm_refot; /* Parameter: Reflect output CRC? */ + ulong cm_xorot; /* Parameter: XOR this to output CRC. */ + + ulong cm_reg; /* Context: Context during execution. */ + } cm_t; +typedef cm_t *p_cm_t; + +/******************************************************************************/ + +/* Functions That Implement The Model */ +/* ---------------------------------- */ +/* The following functions animate the cm_t abstraction. */ + +void cm_ini P_((p_cm_t p_cm)); +/* Initializes the argument CRC model instance. */ +/* All parameter fields must be set before calling this. */ + +void cm_nxt P_((p_cm_t p_cm,int ch)); +/* Processes a single message byte [0,255]. */ + +void cm_blk P_((p_cm_t p_cm,p_ubyte_ blk_adr,ulong blk_len)); +/* Processes a block of message bytes. */ + +ulong cm_crc P_((p_cm_t p_cm)); +/* Returns the CRC value for the message bytes processed so far. */ + +/******************************************************************************/ + +/* Functions For Table Calculation */ +/* ------------------------------- */ +/* The following function can be used to calculate a CRC lookup table. */ +/* It can also be used at run-time to create or check static tables. */ + +ulong cm_tab P_((p_cm_t p_cm,int index)); +/* Returns the i'th entry for the lookup table for the specified algorithm. */ +/* The function examines the fields cm_width, cm_poly, cm_refin, and the */ +/* argument table index in the range [0,255] and returns the table entry in */ +/* the bottom cm_width bytes of the return value. */ + +/******************************************************************************/ + +/* End of the header file idempotence #ifndef */ +#endif + +/******************************************************************************/ +/* End of crcmodel.h */ +/******************************************************************************/ + + +/******************************************************************************/ +/* Start of crcmodel.c */ +/******************************************************************************/ +/* */ +/* Author : Ross Williams (ross@guest.adelaide.edu.au.). */ +/* Date : 3 June 1993. */ +/* Status : Public domain. */ +/* */ +/* Description : This is the implementation (.c) file for the reference */ +/* implementation of the Rocksoft^tm Model CRC Algorithm. For more */ +/* information on the Rocksoft^tm Model CRC Algorithm, see the document */ +/* titled "A Painless Guide to CRC Error Detection Algorithms" by Ross */ +/* Williams (ross@guest.adelaide.edu.au.). This document is likely to be in */ +/* "ftp.adelaide.edu.au/pub/rocksoft". */ +/* */ +/* Note: Rocksoft is a trademark of Rocksoft Pty Ltd, Adelaide, Australia. */ +/* */ +/******************************************************************************/ +/* */ +/* Implementation Notes */ +/* -------------------- */ +/* To avoid inconsistencies, the specification of each function is not echoed */ +/* here. See the header file for a description of these functions. */ +/* This package is light on checking because I want to keep it short and */ +/* simple and portable (i.e. it would be too messy to distribute my entire */ +/* C culture (e.g. assertions package) with this package. */ +/* */ +/******************************************************************************/ + +#include "crcmodel.h" + +/******************************************************************************/ + +/* The following definitions make the code more readable. */ + +#define BITMASK(X) (1L << (X)) +#define MASK32 0xFFFFFFFFL +#define LOCAL static + +/******************************************************************************/ + +ulong reflect P_((ulong v,int b)) +{ + int i; + ulong t = v; + for (i=0; i<b; i++) + { + if (t & 1L) + v|= BITMASK((b-1)-i); + else + v&= ~BITMASK((b-1)-i); + t>>=1; + } + return v; +} + +/******************************************************************************/ + +LOCAL ulong widmask (p_cm_t p_cm) +{ + return (((1L<<(p_cm->cm_width-1))-1L)<<1)|1L; +} + +/******************************************************************************/ + +void cm_ini (p_cm_t p_cm) +{ + p_cm->cm_reg = p_cm->cm_init; +} + +/******************************************************************************/ + +void cm_nxt (p_cm_t p_cm,int ch) +{ + int i; + ulong uch = (ulong) ch; + ulong topbit = BITMASK(p_cm->cm_width-1); + + if (p_cm->cm_refin) uch = reflect(uch,8); + p_cm->cm_reg ^= (uch << (p_cm->cm_width-8)); + for (i=0; i<8; i++) + { + if (p_cm->cm_reg & topbit) + p_cm->cm_reg = (p_cm->cm_reg << 1) ^ p_cm->cm_poly; + else + p_cm->cm_reg <<= 1; + p_cm->cm_reg &= widmask(p_cm); + } +} + +/******************************************************************************/ + +void cm_blk (p_cm_t p_cm,p_ubyte_ blk_adr,ulong blk_len) +{ + while (blk_len--) cm_nxt(p_cm,*blk_adr++); +} + +/******************************************************************************/ + +ulong cm_crc (p_cm_t p_cm) +{ + if (p_cm->cm_refot) + return p_cm->cm_xorot ^ reflect(p_cm->cm_reg,p_cm->cm_width); + else + return p_cm->cm_xorot ^ p_cm->cm_reg; +} + +/******************************************************************************/ + +ulong cm_tab (p_cm_t p_cm,int index) +{ + int i; + ulong r; + ulong topbit = BITMASK(p_cm->cm_width-1); + ulong inbyte = (ulong) index; + + if (p_cm->cm_refin) inbyte = reflect(inbyte,8); + r = inbyte << (p_cm->cm_width-8); + for (i=0; i<8; i++) + if (r & topbit) + r = (r << 1) ^ p_cm->cm_poly; + else + r<<=1; + if (p_cm->cm_refin) r = reflect(r,p_cm->cm_width); + return r & widmask(p_cm); +} + +/******************************************************************************/ +/* End of crcmodel.c */ +/******************************************************************************/ + +#define uint32_t unsigned int +#define uint8_t unsigned char + +uint32_t CRC_CalcBlockCRC(uint32_t *buffer, uint32_t words) + { + cm_t crc_model; + uint32_t word_to_do; + uint8_t byte_to_do; + int i; + + // Values for the STM32F generator. + + crc_model.cm_width = 32; // 32-bit CRC + crc_model.cm_poly = 0x04C11DB7; // CRC-32 polynomial + crc_model.cm_init = 0xFFFFFFFF; // CRC initialized to 1's + crc_model.cm_refin = FALSE; // CRC calculated MSB first + crc_model.cm_refot = FALSE; // Final result is not bit-reversed + crc_model.cm_xorot = 0x00000000; // Final result XOR'ed with this + + cm_ini(&crc_model); + + while (words--) + { + // The STM32F10x hardware does 32-bit words at a time!!! + + word_to_do = *buffer++; + + // Do all bytes in the 32-bit word. + + for (i = 0; i < sizeof(word_to_do); i++) + { + // We calculate a *byte* at a time. If the CRC is MSB first we + // do the next MS byte and vica-versa. + + if (crc_model.cm_refin == FALSE) + { + // MSB first. Do the next MS byte. + + byte_to_do = (uint8_t) ((word_to_do & 0xFF000000) >> 24); + word_to_do <<= 8; + } + else + { + // LSB first. Do the next LS byte. + + byte_to_do = (uint8_t) (word_to_do & 0x000000FF); + word_to_do >>= 8; + } + + cm_nxt(&crc_model, byte_to_do); + } + } + + // Return the final result. + + return (cm_crc(&crc_model)); + } + + +unsigned checksum(void *buffer, size_t len, unsigned int seed) +{ + unsigned char *buf = (unsigned char *)buffer; + size_t i; + + for (i = 0; i < len; ++i) + seed += (unsigned int)(*buf++); + return seed; +} + +unsigned int crc32c_checksum(unsigned char* message, int length) { + int i, j; + unsigned int byte, crc, mask; + static unsigned int table[256] = {0}; + + /* Set up the table, if necessary. */ + + if (table[1] == 0) { + for (byte = 0; byte <= 255; byte++) { + crc = byte; + for (j = 7; j >= 0; j--) { // Do eight times. + mask = -(crc & 1); + crc = (crc >> 1) ^ (0xEDB88320 & mask); + } + table[byte] = crc; + } + } + + /* Through with table setup, now calculate the CRC. */ + i = 0; + crc = 0xFFFFFFFF; + while (length--) { + byte = message[i]; + crc = (crc >> 8) ^ table[(crc ^ byte) & 0xFF]; + i = i + 1; + } + return ~crc; +} + + + + + + +/******************************************************************************/ + +/* MAIN */ +/* ----------------------- */ +/* */ + + +#include <stdio.h> +#include <string.h> +int main(int argc, char** argv) { + + + FILE *fp, * fpout; + size_t len; + unsigned char buf[1050000]; + char *file = argv[2]; + int type = atoi(argv[1]); + unsigned int pruefsumme; + + //write File with length and cheksum + char filename[500], filenameout[510] ; + sprintf(filename,"%s",file); + int filelength = strlen(filename); + filename[filelength -4] = 0; + + if (NULL == (fp = fopen(file, "rb"))) + { + printf("Unable to open %s for reading\n", file); + return -1; + } + len = fread(buf, sizeof(char), sizeof(buf), fp); + printf("%d bytes read (hex: %#x )\n", len,len); +// unsigned int checksum = crc32c_checksum(buf, len); + unsigned int checksum = CRC_CalcBlockCRC((uint32_t *)buf, (uint32_t)(len/4)); + printf("The checksum of %s is %#x\n", file, checksum); + + fclose(fp); + if(type == 0) + sprintf(filenameout,"%s_upload.bin",filename); + else + if(type == 2) + sprintf(filenameout,"OSTC4_FONT_upload.bin",filename); + else + sprintf(filenameout,"%s_upload.bin",filename); + + unsigned char buf2[4]; + + buf2[0] = 0xFF & (len >> 24);; + buf2[1] = 0xFF & (len >> 16);; + buf2[2] = 0xFF & (len >> 8); + buf2[3] = 0xFF & len; + fpout = fopen(filenameout, "wb"); + fwrite(buf2,sizeof(char),4,fp); + + + unsigned char buf3offset[4]; + unsigned char bufVersion[4]; + if(type == 2) + { + buf3offset[0] = 0x10; + buf3offset[1] = 0x00; + buf3offset[2] = 0x03; + buf3offset[3] = 0x20; + bufVersion[0] = buf[0x00]; + bufVersion[1] = buf[0x01]; + bufVersion[2] = buf[0x02]; + bufVersion[3] = buf[0x03]; + } + else + if(type == 0) + { + buf3offset[0] = 0xFE; + buf3offset[1] = 'R'; + buf3offset[2] = 'T'; + buf3offset[3] = 'E'; + bufVersion[0] = buf[0x5000]; + bufVersion[1] = buf[0x5001]; + bufVersion[2] = buf[0x5002]; + bufVersion[3] = buf[0x5003]; + } + else + { + buf3offset[0] = 0xFF; + buf3offset[1] = 0; + buf3offset[2] = 'H'; + buf3offset[3] = 'W'; + bufVersion[0] = buf[0x10000]; + bufVersion[1] = buf[0x10001]; + bufVersion[2] = buf[0x10002]; + bufVersion[3] = buf[0x10003]; + } + + fwrite(buf3offset,sizeof(char),4,fp); + + pruefsumme = len + (256*256*256*buf3offset[0]) + (256*256*buf3offset[1]) + (256*buf3offset[2]) + buf3offset[3]; + fwrite(&pruefsumme,sizeof(char),4,fp); + + fwrite(bufVersion,sizeof(char),4,fp); + + for(int i = 0;i <len;i++) + { + if(fwrite(&buf[i],1,1,fpout) != 1) + printf("error writing\n"); + } + + + buf2[0] = 0xFF & (checksum >> 24);// & 0xFF000000; + buf2[1] = 0xFF & (checksum >> 16); + buf2[2] = 0xFF & (checksum >> 8); + buf2[3] = 0xFF & checksum; + + fwrite(buf2,sizeof(char),4,fp); + +} + + + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ostc4pack/src/checksum_final_add_fletcher.cpp Mon Jul 30 11:31:20 2018 +0200 @@ -0,0 +1,134 @@ +#include <iostream> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#include <time.h> + +void fletcher16(unsigned char *result1, unsigned char *result2, unsigned char const *data, size_t bytes ) +{ + unsigned short sum1 = 0xff, sum2 = 0xff; + size_t tlen; + + while (bytes) { + tlen = bytes >= 20 ? 20 : bytes; + bytes -= tlen; + do { + sum2 += sum1 += *data++; + } while (--tlen); + sum1 = (sum1 & 0xff) + (sum1 >> 8); + sum2 = (sum2 & 0xff) + (sum2 >> 8); + } + /* Second reduction step to reduce sums to 8 bits */ + sum1 = (sum1 & 0xff) + (sum1 >> 8); + sum2 = (sum2 & 0xff) + (sum2 >> 8); + *result2 = (sum2 & 0xff); + *result1 = (sum1 & 0xff); +// return sum2 << 8 | sum1; +} + + +// This is a variant of fletcher16 with a 16 bit sum instead of an 8 bit sum, +// and modulo 2^16 instead of 2^16-1 +void +hw_ostc3_firmware_checksum (unsigned char *result1, unsigned char *result2, unsigned char *result3, unsigned char *result4, unsigned char const *data, size_t bytes ) +{ + unsigned short low = 0; + unsigned short high = 0; + for (unsigned int i = 0; i < bytes; i++) { + low += data[i]; + high += low; + } + *result1 = (low & 0xff); + *result2 = (low/256 & 0xff); + *result3 = (unsigned char)(high & 0xff); + *result4 = (unsigned char)((high/256) & 0xff); +// return (((unsigned int)high) << 16) + low; +} + + +int main(int argc, char** argv) { + + + FILE *fp, * fpout; + size_t lenTotal,lenTemp; + unsigned char buf[2000000]; + char *file = argv[1]; + char *file2 = argv[2]; + char *file3 = argv[3]; + unsigned int pruefsumme; + unsigned char buf2[4]; + + printf("1: %s\n", file); + printf("2: %s\n", file2); + printf("3: %s\n", file3); + printf("\n"); + + + //write File with length and cheksum + char filename[500], filenameout[510] ; + sprintf(filename,"%s",file); + int filelength = strlen(filename); + filename[filelength -4] = 0; + + lenTotal = 0; + if (NULL == (fp = fopen(file, "rb"))) + { + printf("Unable to open %s for reading\n", file); + return -1; + } + lenTemp = fread(&buf[lenTotal], sizeof(char), sizeof(buf), fp); +// lenTemp = fread(buf, sizeof(char), sizeof(buf), fp); + lenTotal = lenTemp; + printf("%d bytes read (hex: %#x )\n", lenTemp,lenTemp); + fclose(fp); + + if(file2) + { + if (NULL == (fp = fopen(file2, "rb"))) + { + printf("Unable to open %s for reading\n", file2); + return -1; + } + lenTemp = fread(&buf[lenTotal], sizeof(char), sizeof(buf)-lenTotal, fp); + lenTotal += lenTemp; + printf("%d bytes read (hex: %#x )\n", lenTemp,lenTemp); + fclose(fp); + } + if(file3) + { + if (NULL == (fp = fopen(file3, "rb"))) + { + printf("Unable to open %s for reading\n", file3); + return -1; + } + lenTemp = fread(&buf[lenTotal], sizeof(char), sizeof(buf)-lenTotal, fp); + lenTotal += lenTemp; + printf("%d bytes read (hex: %#x )\n", lenTemp,lenTemp); + fclose(fp); + } + + printf("\n"); + printf("%d bytes read (hex: %#x ) total \n", lenTotal,lenTotal); + + time_t rawtime; + time (&rawtime); + struct tm *timeinfo; + timeinfo = localtime(&rawtime); + +// sprintf(filenameout,"fwupdate_%s.bin",ctime(&rawtime)); + sprintf(filenameout,"OSTC4update_%02u%02u%02u.bin",timeinfo->tm_year-100,timeinfo->tm_mon+1,timeinfo->tm_mday); + + fpout = fopen(filenameout, "wb"); + for(int i = 0;i <lenTotal;i++) + { + if(fwrite(&buf[i],1,1,fpout) != 1) + printf("error writing\n"); + } + + hw_ostc3_firmware_checksum(&buf2[0],&buf2[1],&buf2[2],&buf2[3],buf,lenTotal); + printf("checksum %#x %#x %#x %#x\n", buf2[0],buf2[1], buf2[2], buf2[3]); + if(fwrite(&buf2[0],1,4,fpout) != 4) + printf("error writing checksum\n"); + ; + fclose(fpout); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ostc4pack/step1_create_OSTC4_firmware_upload_bin.bat Mon Jul 30 11:31:20 2018 +0200 @@ -0,0 +1,2 @@ +OSTC4pack_V4.exe 1 OSTC4_firmware.bin +PAUSE \ No newline at end of file