Intel Hexfile to Array

read_byte_from_file()

One bit to understand about hex files is the data is actually stored as ASCII characters.  When we open a file pointer to these ASCII characters, we can't just read the bytes, since they'd simply be an ASCII character representing the nibble read.  To make the conversion we get a character, store it as a binary nibble A, get another character and store it as binary nibble B.  We then combine nibble A and B into a single byte. 

The function takes three parameters: the file pointer, a uint8_t pointer for storing the complete byte, and the total_chars_read, which allows us to track how far we are into the file.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

DATA.C

uint8_t read_byte_from_file(FILE * file, uint8_t * char_to_put, int * total_chars_read)
{
	//Holds combined nibbles.
	uint8_t hexValue;
	//Get first nibble.
	*char_to_put = fgetc (file);
	clear_special_char(file, char_to_put, total_chars_read);
	//Put first nibble in.
	hexValue = (Ascii2Hex(*char_to_put));
	//Slide the nibble.
	hexValue = ((hexValue << 4) & 0xF0);
	//Put second nibble in.
	*char_to_put = fgetc (file);
	clear_special_char(file, char_to_put, total_chars_read);
	//Put the nibbles together.
	hexValue |= (Ascii2Hex(*char_to_put));
	//Return the byte.
	*total_chars_read += 2;

	return hexValue;
}

• 6: Declaring a 8-bit unsinged integer to hold the finished byte.
• 8: Get an ASCII character from the file pointer.
• 9: Here we call the cleaer_special_char function to remove '\n' and '\r' found in the hex file.
• 11: We then convert the ASCII character into a true binary nibble.  The result is stored in the string.  (I will cover the Ascii2Hex function below.)
• The above steps are repeated for nibble B.
• 18: We combine the string of nibbles into a byte.
• 26: We increment two ASCII characters read from the file pointer.

clear_special_char()

The clear special character function is simply meant to remove the ':', '\n', and '\r' characters from the data stream.  It simply looks through the character pulled from the data stream.  If it is not a special character, it does nothing.  If it is, it increments the character counter and discards the character.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

DATA.C

void clear_special_char(FILE * file, uint8_t * charToPut, int * totalCharsRead)
{
	//Removes CR, LF, ':'  --Bdk6's
	while (*charToPut == '\n' || *charToPut == '\r' || *charToPut ==':'){
		(*charToPut = fgetc (file));
		*totalCharsRead++;
	}
}

Ascii2Hex()

Another fairly simple function.  Here, we simply find the numeric value of the ASCII character and convert it to its binary equivalent.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

DATA.C

//Copied in from lpc21isp.c
uint8_t Ascii2Hex(uint8_t c)
{
	if (c >= '0' && c <= '9')
	{
		return (uint8_t)(c - '0');
	}
	if (c >= 'A' && c <= 'F')
	{
		return (uint8_t)(c - 'A' + 10);
	}
	if (c >= 'a' && c <= 'f')
	{
        return (uint8_t)(c - 'a' + 10);
	}

	return 0;  // this "return" will never be reached, but some compilers give a warning if it is not present
}

This function is pretty simple, if you keep in mind each character is actually an integer.  For example, the if-statements could be re-written as follows,

1
2
3
4
5
6
7
8

          if (c >= 0 && c <= 9)
             { return (uint8_t)(c - 0) }

          if (c >= 65 && c <= 70)
             { return (uint8_t)(c - 65 + 10)}

          if (c >= 97 && c <= 102)
             {return (uint8_t)(c - 97 + 10)}

You can use an ASCII reference table to determine how a character read will be interpreted.  For instance, 'D' or 'd' would be 68 or 100.  68 - 65 + 10 = 13.  We know D is hexadecimal for 13 (0 = 0, 1 = 1, 1 = 2, etc... A = 10, B, = 11, C = 12, D = 13, E = 14, F = 15).

This brings us to the main function,

read_line_from_hex_file()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

DATA.C

bool read_line_from_hex_file(FILE * file, uint8_t line_of_data[], long int * combined_address, int * bytes_this_line)
{
		int data_index = 0;
		uint8_t char_to_put;
		int total_chars_read = 0;

		//To hold file hex values.
		uint8_t byte_count;
		uint8_t datum_address1;
		uint8_t datum_address2;
		uint8_t datum_record_type;
		uint8_t datum_check_sum;

		//BYTE COUNT
		byte_count = read_byte_from_file(file, &char_to_put, &total_chars_read);

		// No need to read, if no data.
		if (byte_count == 0){return false;}

		//ADDRESS1 //Will create an 8 bit shift. --Bdk6's
		datum_address1 = read_byte_from_file(file, &char_to_put, &total_chars_read);

		//ADDRESS2
		datum_address2 = read_byte_from_file(file, &char_to_put, &total_chars_read);

		//RECORD TYPE
		datum_record_type = read_byte_from_file(file, &char_to_put, &total_chars_read);		

		// No need to read, if not data.
		if (datum_record_type != 0){return false;}

		*combined_address = ((uint16_t)datum_address1 << 8) | datum_address2;

		// DATA
		while(data_index < byte_count)
		{
			line_of_data[data_index] = read_byte_from_file(file, &char_to_put, &total_chars_read);
			data_index++;
		}			
		*bytes_this_line = data_index;

		// CHECKSUM
		datum_check_sum = read_byte_from_file(file, &char_to_put, &total_chars_read);

		return true;
}

The above code parses exactly one line of hex data from the file pointer. 

:10012000194E79234623965778239EDA3F01B2CAA7

• 17: We read the first byte of a line.  This should be the ':' character, but remember our clear_special_char() should skip this and read the next two bytes '1' and '0' (green).  The "10" is how many bytes of data (blue) found on this line.  Note, 10 is not a decimal number, it's hexadecimal.  Meaning, there should be 16 bytes of data found on this line.
• 20: We check if there was any data on this line.  If there are zero data, we return false.
• 23: Take the first byte of the data address (purple).
• 26: Take the second byte of the data address (purple).
• 29: Get the byte (red) identifying the type of information found on this line.  We are only looking for data ('00').  The other types are explained well at the ole' Wiki article: Intel HEX record types.
• 32: If the record type is not data, we don't want it.  We return false.
• 34: Combine the two 8-bit address bytes into one 16-bit address.
• 37: Let's get all the data found on this line and put it into the array we provided the function.
• 42: We have to keep track of how many bytes are on each line, to complete our address of the data.  Therefore, we pass it back to hex_file_to_array().
• 45: I read the checksum, but I don't do anything with it.  I probably should.

hex_file_line_count()

To properly parse the hexfile we need to know how many lines are found in the the file.  We can find this information several ways, but I counted the number of line start characters ':'.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

MAIN.C

int hex_file_line_count(FILE * file_to_count)
{
	int line_count = 0;
	char got_char;

	while(got_char != EOF)
	{
		got_char = fgetc(file_to_count);
		if (got_char == ':'){line_count++;}
	}
	rewind(file_to_count);
	return line_count;
}

• 8: Loops until the end-of-file character is reached.
• 10: Gets a ASCII character from the file pointer.
• 11: We check to see if the character we go was line start character ':'.
• 13: This function iterates through the entire file, but we want to start pulling data from the beginning of the file, so we rewind the file to the first character.
• 14: We return the number of lines.