 |
 |
| View previous topic :: View next topic |
| Author |
Message |
silelis
Joined: 12 Jun 2007
Posts: 68
Location: Poland, podlaskie district
|
| Embed bin file (with slave IC firmware) into PIC hex |
 Posted: Mon Apr 29, 2019 5:57 am |
 |
|
Hello,
I am developing DAB+ tuner based on si468x chip.
There is boot sequence where the host (in my case PIC18) have to upload (via spi or i2c) some firmware (in bin) to DAB+ chip every time chip boots.
I know that I can upload this bin to eeprom, read it (by i2c) write it to si468x. For some reason, reading this bin from PIC flash is a must (in other case I have to redesign a huge amount of hardware) and at this moment I only allow build bin into PIC hex.
My question is how to embed this bin file into PIC hex during compilation?
I consider to rewrite (manually bin to rom char[]) but there is huge possibility of mistake!!!
I am searching for some solution like this:
| Quote: |
rom char [] = { /location_of_bin/binary_file.bin};
// of course it is only idea not final code
|
Does CCS allow to attach/include bin into PIC hex automatically? |
|
 |
Ttelmah
Joined: 11 Mar 2010
Posts: 19496
|
|
| Posted: Mon Apr 29, 2019 11:21 am |
|
|
No, but with a program that allows you to output a file as values, and
a text editor, it is pretty easy to automatically convert the bin data
to a suitable format. |
|
|
PCM programmer
Joined: 06 Sep 2003
Posts: 21708
|
|
| Posted: Mon Apr 29, 2019 1:18 pm |
|
|
WinHex will do this. Download the eval version:
http://www.x-ways.net/winhex.zip
1. Unzip and install it.
2. Load your file.
3. Go to the Edit menu, then Copy All, then select C source.
This will convert the loaded binary data into C source and copy it to
the Windows clipboard.
4. Open your text editor (CCS IDE or MPLAB or other) and paste the
C source array data into your program. Rename the array if needed. |
|
|
silelis
Joined: 12 Jun 2007
Posts: 68
Location: Poland, podlaskie district
|
|
| Posted: Tue Apr 30, 2019 5:10 am |
|
|
Great tool. Thank You for that.
My bin2C_char_table is like this. And this is correct. (y)
| Code: |
char data[940] = {
0x03, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x56, 0x34, 0x12,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2C, 0x5F, 0xBE, 0x2F, 0x01, 0x00, 0x00, 0x00,
0xEF, 0xBE, 0xAD, 0xDE, 0x50, 0x03, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x3C, 0x20, 0x50, 0x01, 0x00, 0x00, 0x00, 0x6A, 0x21, 0xD6, 0x4F,
0x89, 0xA5, 0x4C, 0xD3, 0xD4, 0x6E, 0x92, 0x9F, 0xA9, 0x31, 0x42, 0x2E, 0x20, 0x0F, 0xE2, 0x2B,
0x7F, 0x72, 0xC2, 0xD7, 0xF0, 0x52, 0x7E, 0xD1, 0x99, 0x89, 0x86, 0x4F, 0x55, 0xE7, 0x6D, 0xDE,
0x98, 0xFF, 0xD8, 0xCC, 0x71, 0xCF, 0xD2, 0x78, 0x62, 0x58, 0xA4, 0x01, 0xA7, 0x34, 0x6D, 0x73,
0x91, 0x31, 0xFA, 0x15, 0x50, 0x22, 0x9B, 0x78, 0xB5, 0x49, 0x2A, 0xD1, 0x5A, 0xDE, 0x36, 0x53,
0x85, 0xDD, 0x6D, 0x46, 0xB8, 0x06, 0xDE, 0xEC, 0x8F, 0x25, 0xDC, 0x6A, 0x16, 0x4B, 0xD8, 0x66,
0x3D, 0x9A, 0xA2, 0x8D, 0x68, 0xED, 0x67, 0xCB, 0xD1, 0x12, 0xAE, 0x75, 0x85, 0x44, 0x5C, 0x9B,
0x83, 0xC8, 0xD6, 0x37, 0x96, 0x92, 0x85, 0x9F, 0x12, 0xB3, 0x7D, 0x4F, 0x7E, 0x59, 0xCB, 0x7D,
0x0B, 0x99, 0x97, 0x7B, 0xC7, 0x60, 0x50, 0x26, 0x10, 0xFE, 0xC1, 0xF3, 0xE0, 0xD1, 0xE0, 0x16,
0xD3, 0x0D, 0xA8, 0x1C, 0xA6, 0xF7, 0x58, 0x39, 0x4F, 0x42, 0xD3, 0x23, 0xBF, 0x6A, 0xC1, 0x14,
0xAD, 0x7B, 0x80, 0x01, 0x1B, 0xCB, 0x01, 0xE3, 0x45, 0xEA, 0x62, 0x36, 0x8A, 0x06, 0x04, 0xF5,
0x97, 0xCD, 0x95, 0x84, 0xE1, 0x56, 0xB9, 0x29, 0xD4, 0xC1, 0x8E, 0x2E, 0xEC, 0x93, 0x1D, 0xF9,
0x63, 0xF4, 0x58, 0xE1, 0xC6, 0x13, 0xB0, 0x22, 0x3E, 0x79, 0x02, 0x54, 0xA2, 0x2E, 0x09, 0xC8,
0xA4, 0x7E, 0xD2, 0xD0, 0xAA, 0xEE, 0x27, 0xA0, 0x97, 0x32, 0x4C, 0xE0, 0xA6, 0xE9, 0xFE, 0x3F,
0xB2, 0xAD, 0x93, 0x2C, 0x89, 0x52, 0x58, 0x78, 0x82, 0x89, 0xB1, 0xF0, 0xD4, 0x7E, 0x60, 0x01,
0x7A, 0xBC, 0xC1, 0x62, 0xE5, 0x54, 0xE4, 0x32, 0x88, 0xC5, 0xCB, 0x05, 0xA1, 0xE7, 0x98, 0x6A,
0xE2, 0x56, 0x57, 0xF4, 0x5E, 0x47, 0xAF, 0xC8, 0x8A, 0xB3, 0x1E, 0xD0, 0x30, 0x5E, 0x1D, 0xAE,
0x0F, 0x2B, 0x19, 0x3D, 0x30, 0x06, 0x13, 0xD8, 0x0E, 0xD4, 0xBE, 0x8B, 0xE2, 0x25, 0x1E, 0x12,
0xF5, 0xA7, 0xBE, 0xCA, 0x1A, 0x29, 0x8E, 0x07, 0xA1, 0xD0, 0x09, 0x10, 0x45, 0xA2, 0xB7, 0x06,
0x78, 0x23, 0xB1, 0x99, 0x74, 0xDF, 0x11, 0x25, 0xBC, 0xE5, 0xE0, 0x17, 0x6C, 0x4F, 0x3A, 0x2D,
0x7A, 0xF7, 0x56, 0x9B, 0xD6, 0x9D, 0xAA, 0x24, 0xDB, 0x5B, 0xBD, 0xCD, 0xD2, 0xDF, 0x58, 0x6C,
0x78, 0xA2, 0x06, 0x1F, 0xC1, 0x18, 0xA8, 0x2C, 0x26, 0xC6, 0x77, 0x16, 0x01, 0x8B, 0x3E, 0x7A,
0x44, 0x4A, 0xDD, 0x06, 0xB0, 0x0E, 0xFB, 0x3D, 0xBB, 0x74, 0x39, 0xCD, 0x57, 0xBB, 0xFE, 0xE3,
0x36, 0x6D, 0x24, 0x95, 0x59, 0x6B, 0x6F, 0x93, 0xFA, 0x38, 0xF0, 0xC9, 0xD9, 0xE4, 0xC4, 0xE1,
0x02, 0x81, 0xA3, 0xBD, 0x18, 0x72, 0x49, 0xF2, 0x88, 0x09, 0xF1, 0x5A, 0x59, 0x3D, 0x75, 0xCA,
0xA6, 0x15, 0xB0, 0x5E, 0x7A, 0x7C, 0xE6, 0x87, 0x9C, 0x27, 0xA7, 0x1F, 0x10, 0x4D, 0x68, 0x8C,
0x4D, 0xD7, 0x7C, 0x38, 0x68, 0xA9, 0x63, 0xC4, 0xDA, 0xA9, 0x89, 0x7D, 0xA2, 0xE4, 0xED, 0x21,
0x0F, 0x82, 0x9C, 0x4E, 0xD9, 0x4B, 0x9F, 0xD0, 0x61, 0x36, 0x94, 0x2E, 0x61, 0xD2, 0x1A, 0x6A,
0x31, 0x3B, 0x2B, 0x7B, 0x14, 0xB5, 0x4C, 0x3D, 0x89, 0x8E, 0x7B, 0xA7, 0x3D, 0xD8, 0x18, 0x65,
0x7D, 0xBD, 0xEC, 0xD2, 0x3F, 0x00, 0xC1, 0xF1, 0x8C, 0xBD, 0xEE, 0x01, 0xEB, 0x27, 0xF5, 0xDA,
0x34, 0xAE, 0x15, 0x0E, 0x49, 0xF1, 0x54, 0x9F, 0xD3, 0xCD, 0xBC, 0x9F, 0x11, 0x55, 0x5C, 0xFF,
0xEA, 0xF9, 0x9A, 0x3A, 0xB3, 0xA3, 0x2B, 0xC2, 0x1C, 0xE2, 0x0B, 0x37, 0xFB, 0x78, 0x27, 0x8E,
0xB0, 0xE0, 0xE6, 0x6C, 0xA1, 0x29, 0x32, 0x6F, 0xE4, 0x07, 0xD3, 0x09, 0xF6, 0x71, 0xA8, 0x8B,
0xD6, 0x96, 0x8E, 0xB7, 0x3D, 0xA2, 0x3E, 0x40, 0xD8, 0x13, 0x69, 0x7E, 0xA1, 0xE9, 0xD2, 0x55,
0xFB, 0x22, 0xBB, 0x1A, 0xBE, 0x53, 0xC5, 0xCE, 0x9B, 0x9C, 0x04, 0x2E, 0xE5, 0x45, 0x72, 0x8A,
0x80, 0x87, 0x8A, 0xFE, 0xF6, 0x52, 0xC2, 0x6E, 0x4E, 0x0E, 0x62, 0x8B, 0x86, 0xFC, 0x9F, 0x23,
0x11, 0x44, 0x19, 0xDF, 0x8A, 0xDF, 0x4A, 0x01, 0x17, 0xA8, 0x37, 0xAB, 0xA3, 0x7B, 0xA4, 0x0D,
0x1E, 0xD8, 0x92, 0xE9, 0x86, 0x3D, 0x22, 0x79, 0xB6, 0x3E, 0xAB, 0x97, 0xF7, 0x8E, 0x32, 0x12,
0xDA, 0x4E, 0x8B, 0x3F, 0x21, 0x80, 0x62, 0x1F, 0x30, 0x16, 0x2B, 0x9E, 0x08, 0xBB, 0xE1, 0x7B,
0x32, 0xC6, 0x01, 0x8E, 0x8C, 0x04, 0x22, 0xCF, 0xDA, 0x2A, 0xF5, 0xD9, 0x9C, 0xE5, 0x48, 0x5B,
0xFD, 0x6F, 0xDE, 0x72, 0xB0, 0xFF, 0x6D, 0x53, 0x46, 0x4F, 0x19, 0xDF, 0x1B, 0x3D, 0x11, 0xEB,
0xFB, 0x78, 0xFD, 0x9E, 0xC0, 0x41, 0x58, 0xF6, 0xD7, 0xE0, 0xF4, 0xAE, 0xD7, 0xEE, 0x38, 0xCF,
0xC9, 0x02, 0x53, 0x53, 0x72, 0xDE, 0xE1, 0xF5, 0x0D, 0x91, 0x72, 0xA3, 0x57, 0xB5, 0x8C, 0xD3,
0x5C, 0x84, 0x57, 0x52, 0xA3, 0x61, 0x3A, 0xFB, 0x55, 0x22, 0x13, 0x0F, 0x5F, 0x20, 0x72, 0xDC,
0xD6, 0x6C, 0x33, 0x32, 0xB8, 0x66, 0x6B, 0x7D, 0x5F, 0x84, 0x91, 0x04, 0x23, 0x75, 0x5D, 0xA1,
0xB9, 0xDC, 0xD6, 0x44, 0x33, 0xC7, 0xD0, 0x18, 0x7E, 0x3C, 0x6F, 0x3F, 0x5D, 0x7F, 0xE0, 0xCF,
0xD0, 0x88, 0xBE, 0xF1, 0x87, 0x65, 0x65, 0xDA, 0xCC, 0xD2, 0x75, 0x5F, 0x8F, 0xF7, 0xB3, 0x08,
0x68, 0xF7, 0xDE, 0xFE, 0xE2, 0x5F, 0x95, 0xA2, 0x92, 0xF6, 0x41, 0xA7, 0x45, 0xF6, 0x34, 0x20,
0xE5, 0x5F, 0x46, 0x31, 0xDD, 0xD5, 0xDA, 0xB1, 0x5E, 0xB6, 0x06, 0x34, 0xD9, 0x22, 0xF3, 0x95,
0xC3, 0xD1, 0xBC, 0xCF, 0xAB, 0x83, 0x6E, 0x5D, 0x38, 0x3A, 0xC8, 0xBD, 0xE8, 0x11, 0xAF, 0xC9,
0x01, 0x0C, 0x20, 0x7B, 0x18, 0xFB, 0x38, 0xBC, 0xFD, 0xE7, 0xCE, 0x96, 0xA2, 0x50, 0xF4, 0x4D,
0x93, 0x22, 0x93, 0x5B, 0x4E, 0x93, 0xF2, 0x93, 0xC6, 0xBA, 0x45, 0xE2, 0x08, 0xF1, 0xAA, 0x0B,
0x06, 0x35, 0x84, 0x64, 0x0C, 0x38, 0x1E, 0x9C, 0xE8, 0x68, 0x79, 0x93, 0x11, 0x7D, 0xAB, 0x17,
0x1A, 0x44, 0x24, 0xD8, 0xB5, 0xDB, 0xE0, 0x0F, 0x9C, 0x51, 0x99, 0x0A, 0x08, 0xDA, 0x90, 0x71,
0xA5, 0x12, 0xAF, 0x12, 0xF3, 0x3C, 0xBC, 0x8E, 0x17, 0x27, 0x11, 0x16, 0xF8, 0x22, 0x40, 0xFD,
0xBC, 0x2B, 0xBB, 0x78, 0x25, 0xA7, 0x04, 0xF5, 0x00, 0x00, 0x00, 0x00
};
|
But I have other considerations...
BTW my mcu is PIC 18f4520
If I compile code like this:
| Code: |
void main()
{
rom char data[] = {
0x03, 0x00, 0x00, 0xFE, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x56, 0x34, 0x12,
..............
};
while(TRUE)
{
//TODO: User Code
}
}
|
RAM utilisation is 61% //takes too much RAM :/
ROM utilisation is 3%
Then I tried other options:
| Code: |
//FIRST code
void main()
{
rom int16 data[] = {
0x0300,0x00fe,0x0000,0x0000,0x0000,0x0000,0x7856,0x3412,
..............
};
while(TRUE)
{
//TODO: User Code
}
}
|
but in this case
RAM utilisation is still 61% //takes to much RAM, :/
ROM utilisation is still 3% //and there is no difference betewwn char and int16 - flash is 16 bits? :/
So I tried with #rom directive
| Code: |
//SECOND code
void main()
{
#rom char 0x1000 = {
0x03,0x00,0x00,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x78,0x56,0x34,0x12,
......
};
while(TRUE)
{
//TODO: User Code
}
}
|
RAM utilisation is 0% //looks better because of RAM utilisation
ROM utilisation is 3%
| Code: |
//THIRD code
void main()
{
#rom int16 0x1000 = {
0x0300,0x00fe,0x0000,0x0000,0x0000,0x0000,0x7856,0x3412,
......
};
while(TRUE)
{
//TODO: User Code
}
}
|
RAM utilisation is still 0%
ROM utilisation is still 3% //as I remember from PICKIT2 software flash is "FFFF" 16 bits so I tried to "compres" char data to int16 but it does not take 50% rom efest as I assume. :(
So I have 3 more questions:
1) Why there is no difference (FLASH utilisation) between char table like 0x01, 0x02, 0x03x 0x04 and int16 table like 0x0102, 0x0304? I thought that flash is 16 bits? Do CCS care about flash utilisation and during compilations "pack" it?
2) How can determinie #rom char/int address during compilation useing compiler directives.
Let say to check:
a) max flash size
b) check if there is no OSCALC (some PICs have sutch data at the end),
c) know that my table is 940 in this case
d) #define rom_address = max_flash-table_space-pic_end_data.
Is it possible to do so?
3) If I want to send this #rom 0x1000 table via I2c or SPI I should read it as:
a) pointer to table:
| Code: |
char/int16 *table_pointer;
table_pointer= 0x1000;
|
b) or read as program memory
| Code: |
READ_PROGRAM_MEMORY (address, dataptr, count );
|
|
|
|
Ttelmah
Joined: 11 Mar 2010
Posts: 19496
|
|
| Posted: Tue Apr 30, 2019 7:00 am |
|
|
Look at the .lst file.
It is 'silly' that things declared with #rom don't get listed as ROM usage,
but it has always been the case. However they do show in the .lst.
At the end of the file, after the fuses it shows 'ROM data'. |
|
|
silelis
Joined: 12 Jun 2007
Posts: 68
Location: Poland, podlaskie district
|
|
| Posted: Mon May 06, 2019 6:41 am |
|
|
If someone need it, here is a simple C program (for PC/ MAC/ other desktop) that converts bin to array.
Do the same as WinHEX.
| Code: |
#include <stdio.h>
#include <assert.h>
int main(int argc, char** argv) {
assert(argc == 2);
char* fn = argv[1];
FILE* f = fopen(fn, "rb");
printf("char a[] = {\n");
unsigned long n = 0;
while(!feof(f)) {
unsigned char c;
if(fread(&c, 1, 1, f) == 0) break;
printf("0x%.2X,", (int)c);
++n;
if(n % 16 == 0) printf("\n");
}
fclose(f);
printf("\b};\n");
}
|
|
|
|
silelis
Joined: 12 Jun 2007
Posts: 68
Location: Poland, podlaskie district
|
|
| Posted: Thu May 23, 2019 6:30 am |
|
|
I have modified program so now it is writing to ".c" file directly. If Someone needs.
| Code: |
#include <cassert>
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <sstream>
#include <iomanip>
#include <string>
using namespace std;
string intToHexString(int);
int main(int argc, char** argv) {
assert(argc == 2);
string inputFileName = argv[1];
string readString;
fstream fileInput;
fileInput.open(inputFileName.c_str(), fstream::in | fstream::binary);
cout<<"Hex2char_array v0.1."<<endl<<"by SileliS 2019"<<endl<<endl;
if (!fileInput.is_open())
{
cout<<endl<<"Unable to open file: "<<inputFileName<<endl;
cout<<"Please check whether file exists and you have read/write privilege.";
exit(-1);
}
unsigned long n = 0;
while(!fileInput.eof())
{
char c;
fileInput.read(&c, 1);
if(fileInput.fail()==1) break;
readString = readString + intToHexString( (int) (unsigned char) c ) + ",";
++n;
if(n % 16 == 0) readString=readString+"\n";
}
fileInput.close();
readString.resize (readString.size () - 1);
readString = readString + "};\n";
stringstream ss;
ss <<n;
string final_string;
final_string = "char a[" + ss.str() + "] = {\n"+ readString;
string newFileName = inputFileName.c_str();
newFileName=newFileName+".c";
fstream fileOutput;
fileOutput.open(newFileName.c_str(), fstream::out);
if (!fileOutput.is_open())
{
cout<<endl<<"Unable to open file: "<<newFileName<<endl;
cout<<"Please check whether file exists and you have read/write privilege.";
exit(-1);
}
cout<<final_string;
fileOutput<<final_string;
fileOutput.close();
}
string intToHexString(int intValue) {
string hexStr;
/// integer value to hex-string
std::stringstream sstream;
sstream << "0x"
<< std::setfill ('0') << std::setw(2)
<< std::hex << (int)intValue;
hexStr= sstream.str();
sstream.clear(); //clears out the stream-string
return hexStr;
}
|
|
|
|
Ttelmah
Joined: 11 Mar 2010
Posts: 19496
|
|
| Posted: Thu May 23, 2019 10:41 am |
|
|
As a comment (bit late), it is actually possible to embed the binary file
using #IMPORT. You use the RAW option, and it can return you a 'const'
which contains where the data has been stored.
So something like:
#IMPORT(FILE=DABDAT.bin, RAW, LOCATION=where_stored, SIZE=2)
will generate a constant called 'where_stored', which contains the location
where 'DABDAT.bin' has been placed in the ROM. |
|
|
silelis
Joined: 12 Jun 2007
Posts: 68
Location: Poland, podlaskie district
|
|
| Posted: Thu May 23, 2019 12:17 pm |
|
|
| Great news. :-) |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
Powered by phpBB © 2001, 2005 phpBB Group
|
FAQ 
Search
Register
Profile 
Log in to check your private messages 
Log in
