URL https://opencores.org/ocsvn/System09/System09/trunk

Subversion Repositories System09

[/] [System09/] [rev_86/] [Tools/] [Mot2Hex/] [mot2hex.c] - Blame information for rev 192

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * Motorola S1 format to Intel hex format
 * Usage
 * mot2hex <file_name>
 */
 
#include <stdio.h>
#include <string.h>
 
 
int gethex( FILE *fp_in )
{
    int hex;
 
    hex = fgetc( fp_in );
    if( (hex >= '0') && (hex <= '9' ))
        hex -= '0';
    else if( (hex >= 'A') && (hex <= 'F'))
        hex = hex - 'A' + 10;
    else
        hex = -1;
    return hex;
}
 
int get2hex( FILE *fp_in )
{
    int hexhi, hexlo, byte;
 
    hexhi = gethex( fp_in );
    if( hexhi != -1 )
    {
        hexlo = gethex( fp_in );
        if( hexlo != -1 )
        {
            byte = hexhi * 16 + hexlo;
            return byte;
        }
    }
    return -1;
}
 
int get4hex( FILE *fp_in )
{
    int bytehi, bytelo, addr;
 
    bytehi = get2hex( fp_in );
    if( bytehi != -1 )
    {
        bytelo = get2hex( fp_in );
        if( bytelo != -1 )
        {
            addr = (bytehi * 256) + bytelo;
            return addr;
        }
    }
    return -1;
}
 
 
main( int argc, char *argv[] )
{
        FILE *fp_in, *fp_out;
        char fname_in[32];
        char fname_out[32];
        int byte, addr, start, i;
        int motorola_check, intel_check;
        int motorola_count, intel_count;
 
        if( argc != 2 )
        {
            printf( "\n usage: mot2hex <file_name> \n" );
            exit(0);
        }
        sprintf( fname_in, "%s.s19", argv[1] );
        fp_in = fopen( fname_in, "r" );
        if( !fp_in )
        {
            sprintf( fname_in, "%s.s1", argv[1] );
            fp_in = fopen( fname_in, "r" );
            if( !fp_in )
            {
                printf( "Can't open %s", fname_in );
                exit(0);
            }
        }
        sprintf( fname_out, "%s.hex", argv[1] );
        fp_out = fopen( fname_out, "w" );
        if( !fp_out )
        {
            printf( "Can't open %s", fname_out );
            exit(0);
        }
        byte = 0;
        addr = 0;
        start = -1;
 
        while( byte != -1 )
        {
            /*
             * Motorola 8 bit record starts with "S1"
             */
            do {
                byte = fgetc( fp_in);
            } while( (byte != 'S') && (byte != -1) );
 
            byte = fgetc( fp_in );
            if( byte == '1' )
            {
                /*
                 * get byte count from Motorola record
                 */
                motorola_count = get2hex( fp_in );
                motorola_check = motorola_count;
                /*
                 * Intel byte count is for data field only
                 * round up to even byte boundary
                 */
                intel_count = motorola_count - 3;
                intel_check = intel_count;
                /*
                 * Get two byte motorola address field
                 */
                addr = get4hex( fp_in );
                motorola_check += (addr & 0xff);
                motorola_check += (addr & 0xff00) >> 8;
                /*
                 * output intel start of record
                 * ":" <data count> <address> <record type>
                 */
                intel_check += (addr & 0xff);
                intel_check += (addr & 0xff00) >> 8;
                fprintf( fp_out, ":%02x%04x00", intel_count, addr );
                /*
                 * Input Motorola data field
                 */
                for( i=0; i<intel_count; i++ )
                {
                    byte = get2hex( fp_in );
                    motorola_check += byte;
                    /*
                     * Output Intel data field
                     */
                    intel_check += byte;
                    fprintf( fp_out, "%02x", byte );
                    /*
                     * Get the start of record from the reset vector
                     */
                    if( addr == 0xfffe )
                        start = byte * 256;
                    if( addr == 0xffff )
                        start += byte;
                    addr ++;
                }
                /*
                 * Display Motorola cehcksum for current record
                 * should be 0xff
                 */
                byte = get2hex( fp_in) & 0xff;
                motorola_check += byte;
                motorola_check &= 0xff;
                printf( " Motorola checksum = %02x   ", motorola_check );
                /*
                 * Display Intel checksum
                 */
                intel_check &= 0xff;
                intel_check = 0x100 - intel_check;
                intel_check &= 0xff;
                printf( "Intel checksum = %02x \n", intel_check );
                /*
                 * Output Intel checksum
                 */
                fprintf( fp_out, "%02x\n", intel_check);
                if( addr > 0xffff )
                   byte = -1;
             }
        }
        /*
         * output Intel trasfer address
         */
        if( start != -1 )
        {
            fprintf( fp_out, ":00%04x01", start );
        }
        /*
         * Close input and output files and exit
         */
        close( fp_in );
        close( fp_out );
}

Line No.	Rev	Author	Line
1	62	davidgb	`/*`
2			`* Motorola S1 format to Intel hex format`
3			`* Usage`
4			`* mot2hex <file_name>`
5			`*/`
6
7			`#include <stdio.h>`
8			`#include <string.h>`
9
10
11			`int gethex( FILE *fp_in )`
12			`{`
13			`int hex;`
14
15			`hex = fgetc( fp_in );`
16			`if( (hex >= '0') && (hex <= '9' ))`
17			`hex -= '0';`
18			`else if( (hex >= 'A') && (hex <= 'F'))`
19			`hex = hex - 'A' + 10;`
20			`else`
21			`hex = -1;`
22			`return hex;`
23			`}`
24
25			`int get2hex( FILE *fp_in )`
26			`{`
27			`int hexhi, hexlo, byte;`
28
29			`hexhi = gethex( fp_in );`
30			`if( hexhi != -1 )`
31			`{`
32			`hexlo = gethex( fp_in );`
33			`if( hexlo != -1 )`
34			`{`
35			`byte = hexhi * 16 + hexlo;`
36			`return byte;`
37			`}`
38			`}`
39			`return -1;`
40			`}`
41
42			`int get4hex( FILE *fp_in )`
43			`{`
44			`int bytehi, bytelo, addr;`
45
46			`bytehi = get2hex( fp_in );`
47			`if( bytehi != -1 )`
48			`{`
49			`bytelo = get2hex( fp_in );`
50			`if( bytelo != -1 )`
51			`{`
52			`addr = (bytehi * 256) + bytelo;`
53			`return addr;`
54			`}`
55			`}`
56			`return -1;`
57			`}`
58
59
60			`main( int argc, char *argv[] )`
61			`{`
62			`FILE fp_in, fp_out;`
63			`char fname_in[32];`
64			`char fname_out[32];`
65			`int byte, addr, start, i;`
66			`int motorola_check, intel_check;`
67			`int motorola_count, intel_count;`
68
69			`if( argc != 2 )`
70			`{`
71			`printf( "\n usage: mot2hex <file_name> \n" );`
72			`exit(0);`
73			`}`
74			`sprintf( fname_in, "%s.s19", argv[1] );`
75			`fp_in = fopen( fname_in, "r" );`
76			`if( !fp_in )`
77			`{`
78			`sprintf( fname_in, "%s.s1", argv[1] );`
79			`fp_in = fopen( fname_in, "r" );`
80			`if( !fp_in )`
81			`{`
82			`printf( "Can't open %s", fname_in );`
83			`exit(0);`
84			`}`
85			`}`
86			`sprintf( fname_out, "%s.hex", argv[1] );`
87			`fp_out = fopen( fname_out, "w" );`
88			`if( !fp_out )`
89			`{`
90			`printf( "Can't open %s", fname_out );`
91			`exit(0);`
92			`}`
93			`byte = 0;`
94			`addr = 0;`
95			`start = -1;`
96
97			`while( byte != -1 )`
98			`{`
99			`/*`
100			`* Motorola 8 bit record starts with "S1"`
101			`*/`
102			`do {`
103			`byte = fgetc( fp_in);`
104			`} while( (byte != 'S') && (byte != -1) );`
105
106			`byte = fgetc( fp_in );`
107			`if( byte == '1' )`
108			`{`
109			`/*`
110			`* get byte count from Motorola record`
111			`*/`
112			`motorola_count = get2hex( fp_in );`
113			`motorola_check = motorola_count;`
114			`/*`
115			`* Intel byte count is for data field only`
116			`* round up to even byte boundary`
117			`*/`
118			`intel_count = motorola_count - 3;`
119			`intel_check = intel_count;`
120			`/*`
121			`* Get two byte motorola address field`
122			`*/`
123			`addr = get4hex( fp_in );`
124			`motorola_check += (addr & 0xff);`
125			`motorola_check += (addr & 0xff00) >> 8;`
126			`/*`
127			`* output intel start of record`
128			`* ":" <data count> <address> <record type>`
129			`*/`
130			`intel_check += (addr & 0xff);`
131			`intel_check += (addr & 0xff00) >> 8;`
132			`fprintf( fp_out, ":%02x%04x00", intel_count, addr );`
133			`/*`
134			`* Input Motorola data field`
135			`*/`
136			`for( i=0; i<intel_count; i++ )`
137			`{`
138			`byte = get2hex( fp_in );`
139			`motorola_check += byte;`
140			`/*`
141			`* Output Intel data field`
142			`*/`
143			`intel_check += byte;`
144			`fprintf( fp_out, "%02x", byte );`
145			`/*`
146			`* Get the start of record from the reset vector`
147			`*/`
148			`if( addr == 0xfffe )`
149			`start = byte * 256;`
150			`if( addr == 0xffff )`
151			`start += byte;`
152			`addr ++;`
153			`}`
154			`/*`
155			`* Display Motorola cehcksum for current record`
156			`* should be 0xff`
157			`*/`
158			`byte = get2hex( fp_in) & 0xff;`
159			`motorola_check += byte;`
160			`motorola_check &= 0xff;`
161			`printf( " Motorola checksum = %02x ", motorola_check );`
162			`/*`
163			`* Display Intel checksum`
164			`*/`
165			`intel_check &= 0xff;`
166			`intel_check = 0x100 - intel_check;`
167			`intel_check &= 0xff;`
168			`printf( "Intel checksum = %02x \n", intel_check );`
169			`/*`
170			`* Output Intel checksum`
171			`*/`
172			`fprintf( fp_out, "%02x\n", intel_check);`
173			`if( addr > 0xffff )`
174			`byte = -1;`
175			`}`
176			`}`
177			`/*`
178			`* output Intel trasfer address`
179			`*/`
180			`if( start != -1 )`
181			`{`
182			`fprintf( fp_out, ":00%04x01", start );`
183			`}`
184			`/*`
185			`* Close input and output files and exit`
186			`*/`
187			`close( fp_in );`
188			`close( fp_out );`
189			`}`

Browse

Tools

Subversion Repositories System09

[/] [System09/] [rev_86/] [Tools/] [Mot2Hex/] [mot2hex.c] - Blame information for rev 192