• Source: SREC (file format)

Motorola S-record is a file format, created by Motorola in the mid-1970s, that conveys binary information as hex values in ASCII text form. This file format may also be known as SRECORD, SREC, S19, S28, S37. It is commonly used for programming flash memory in microcontrollers, EPROMs, EEPROMs, and other types of programmable logic devices. In a typical application, a compiler or assembler converts a program's source code (such as C or assembly language) to machine code and outputs it into a HEX file. The HEX file is then imported by a programmer to "burn" the machine code into non-volatile memory, or is transferred to the target system for loading and execution.




Overview






= History

=
The S-record format was created in the mid-1970s for the Motorola 6800 processor. Software development tools for that and other embedded processors would make executable code and data in the S-record format. PROM programmers would then read the S-record format and "burn" the data into the PROMs or EPROMs used in the embedded system.




= Other hex formats

=
There are other ASCII encoding with a similar purpose. BPNF, BHLF, and B10F were early binary formats, but they are neither compact nor flexible. Hexadecimal formats are more compact because they represent 4 bits rather than 1 bit per character. Many, such as S-record, are more flexible because they include address information so they can specify just a portion of a PROM. Intel HEX format was often used with Intel processors. TekHex is another hex format that can include a symbol table for debugging.




Format






= Record structure

=

An SREC format file consists of a series of ASCII text records. The records have the following structure from left to right:

Record start - each record begins with an uppercase letter "S" character (ASCII 0x53) which stands for "Start-of-Record".
Record type - single numeric digit "0" to "9" character (ASCII 0x30 to 0x39), defining the type of record. See table below.
Byte count - two hex digits ("00" to "FF"), indicating the number of bytes (hex digit pairs) that follow in the rest of the record (address + data + checksum). This field has a minimum value of 3 (2 for 16-bit address field plus 1 checksum byte), and a maximum value of 255 (0xFF). "00" / "01" / "02" are illegal values.
Address - four / six / eight hex digits as determined by the record type. The address bytes are arranged in big-endian format.
Data - a sequence of 2n hex digits, for n bytes of the data. For S1/S2/S3 records, a maximum of 32 bytes per record is typical since it will fit on an 80 character wide terminal screen, though 16 bytes would be easier to visually decode each byte at a specific address.
Checksum - two hex digits, the least significant byte of ones' complement of the sum of the values represented by the two hex digit pairs for the Byte Count, Address and Data fields. In the C programming language, the sum is converted into the checksum by: 0xFF - (sum & 0xFF)




= Text line terminators

=
SREC records are separated by one or more ASCII line termination characters so that each record appears alone on a text line. This enhances legibility by visually delimiting the records and it also provides padding between records that can be used to improve machine parsing efficiency.
Programs that create HEX records typically use line termination characters that conform to the conventions of their operating systems. For example, Linux programs use a single LF character (line feed, 0x0A as ASCII character value) character to terminate lines, whereas Windows programs use a CR character (carriage return, 0x0D as ASCII character value) followed by a LF character.




= Record types

=
The following table describes 10 possible S-records. S4 is reserved and not currently defined. S6 was originally reserved but was later redefined.




= Record order

=
Although some Unix documentation states "the order of S-records within a file is of no significance and no particular order may be assumed", in practice most software has ordered the SREC records. The typical record order starts with a (sometimes optional) S0 header record, continues with a sequence of one or more S1/S2/S3 data records, may have one optional S5/S6 count record, and ends with one appropriate S7/S8/S9 termination record.

S19-style 16-bit address records
S0
S1 (one or more records)
S5 (optional record)
S9
S28-style 24-bit address records
S0
S2 (one or more records)
S5 (optional record)
S8
S37-style 32-bit address records
S0
S3 (one or more records)
S5 (optional record)
S7




= Limitations

=



Record length

A manual page from historic Unix O/S documentation states: "An S-record file consists of a sequence of specially formatted ASCII character strings. An S-record will be less than or equal to 78 bytes in length". The manual page further limits the number of characters in the Data field to 64 (or 32 data bytes). A record with an 8-hex-character address and 64 data characters would be 78 (2 + 2 + 8 + 64 + 2) characters long (this count ignores possible end-of-line or string termination characters), and fits on an 80-character wide teleprinter. A note at the bottom of the manual page states, "This manual page is the only place that a 78-byte limit on total record length or 64-byte limit on data length is documented. These values shouldn't be trusted for the general case".
If the 78 byte historical limit is ignored, the maximum length of an S-record would be 514 characters. Assuming a Byte Count of 0xFF (255), it would be 2 for Record Type field + 2 for Byte Count field + (2 * 255) for Address / Data / Checksum fields. Additional buffer space may be required to hold up to two control characters (carriage return and/or line feed), and/or a NUL (0x00) string terminator for C/C++ programming languages. Using long line lengths has problems: "The Motorola S-record format definition permits up to 255 bytes of payload, or lines of 514 characters, plus the line termination. All EPROM programmers should have sufficiently large line buffers to cope with records this big. Few do."



Data field

The minimum amount of data for S0/S1/S2/S3 records is zero.
Some historical documentation recommends a maximum of 32 bytes of data (64 hex characters) in this field (maybe because 32 is the largest power of 2 of data that would fit on an 80 column wide teleprinter / computer terminal / punched card).
If the 32 byte historical limit is ignored, then the maximum amount of data varies depending on the size of the address field (4 / 6 / 8). The maximum number of bytes of data is calculated by 255 (maximum for Byte Count field) minus (1 byte for Checksum field) minus (number of bytes in the Address field), thus the maximum amount of data for each record type is: 252 data bytes (504 hex characters) for S0 & S1 records, 251 data bytes (502 hex characters) for S2 records, 250 data bytes (500 hex characters) for S3 records.



Comments

Other than ASCII-to-hex converted comments in S0 header records, the SREC file format doesn't officially support human-readable ASCII comments, though some software ignores all lines that don't start with "S" and/or ignores all text after the Checksum field (thus trailing text is sometimes used (incompatibly) for comments). For example, the CCS PIC compiler supports placing a ";" comment line at the top or bottom of an Intel HEX file, and its manuals states "some programmers (MPLAB in particular) do not like comments at the top of the hex file", which is why the compiler has the option of placing the comment at the bottom of the hex file.




Examples


Color legend
Record type
Byte count
Address
Data
Checksum




= Checksum calculation

=
The following example record:

S1137AF00A0A0D0000000000000000000000000061

is decoded to show how the checksum value is calculated. The following example uses a dollar sign ($) to indicate a hexadecimal value (a Motorola convention):

Add: Add each byte $13 + $7A + $F0 + $0A + $0A + $0D + $00 + ... + $00 = $019E sum.
Mask: Discard the most significant byte ($01) of the sum and retain the least significant byte (LSB), which is $9E.
Complement: Compute the ones' complement of the LSB, which is $61.
In the C programming language, the sum is converted into the checksum by: 0xFF - (sum & 0xFF)




= 16-bit memory address

=
S00F000068656C6C6F202020202000003C
S11F00007C0802A6900100049421FFF07C6C1B787C8C23783C6000003863000026
S11F001C4BFFFFE5398000007D83637880010014382100107C0803A64E800020E9
S111003848656C6C6F20776F726C642E0A0042
S5030003F9
S9030000FC




See also


Binary-to-text encoding, a survey and comparison of encoding algorithms
Intel hex format
MOS Technology file format
Tektronix hex format
Texas Instruments TI-TXT (TI Text)




References






Further reading


"2.8. Microprocessor Formats 2.8.1. Input Requirements: Motorola Exorciser Format. Select Code 82". Operator Guide To Serial I/O Capabilities of Data I/O Programmers - Translation Format Package (PDF). Revision C. Data I/O Corporation. October 1980. pp. 2–9. 055-1901. Archived (PDF) from the original on 2020-03-01. Retrieved 2020-03-01.
M1468705EVM Evaluation Module User's Manual (1 ed.). Motorola Inc. December 1983. M1468705EVM/Dl. Retrieved 2020-03-01. [1][2]
Translation File Formats. Data I/O Corporation. 1987-09-03. Archived from the original on 2020-03-01. Retrieved 2020-03-01. [3] (56 pages)
Feichtinger, Herwig (1987). "1.8.5. Lochstreifen-Datenformate: Das Motorola-S-Format" [1.8.5. Paper tape data formats]. Arbeitsbuch Mikrocomputer [Microcomputer work book] (in German) (2 ed.). Munich, Germany: Franzis-Verlag GmbH. pp. 240–243 [242]. ISBN 3-7723-8022-0.
"Appendix A. S Record Information". M68HC05EVM Evaluation Module User's Manual (PDF) (4 ed.). Motorola. 1990. p. A-1. […] For compatibility with teletypewriters, some programs may limit the number of [data] bytes to as few as 28 (56 printable characters in the S-record). […]
"How Do I Interpret Motorola S & Intel HEX Formatted Data? Motorola S-Records". Home > Hardware > … > In-circuit Test Systems > Automated Test Equipment [Discontinued] > Details. Keysight Technologies. Archived from the original on 2020-03-01. Retrieved 2020-03-01.
Beard, Brian (2016) [2007]. "Motorola S-record Format". Lucid Technologies. Archived from the original on 2020-02-28. Retrieved 2020-02-28.
Strombergson, Joachim; Walleij, Linus; Faltstrom, Patrik (October 2005). "The S Hexdump Format". IETF. RFC 4194. Archived from the original on 2020-03-01. Retrieved 2020-03-01.




External links


SRecord is a collection of tools for manipulating SREC format files.
BIN2MOT, BINARY to Motorola S-Record file converter utility.
SRecordizer is a tool for viewing, editing, and error checking S19 format files.
bincopy is a Python package for manipulating SREC format files.
kk_srec is a C library and program for reading the SREC format.

Kata Kunci Pencarian:

• Berkas objek (komputer)
• SREC (file format)
• List of file formats
• Object file
• MOS Technology file format
• S37
• EPROM
• EEPROM
• S9
• S19
• S28