S19文件解析实现代码

介绍：

为了在不同的计算机平台之间传输程序代码和数据，摩托罗拉将程序和数据文件以一种可打印的格式(ASCII格式)编码成s格式文件。s格式文件是Freescale推荐使用的标准文件传送格式。编译完成之后，Freescale CodeWarrior编译器将在bin文件夹下自动生成“*.abs.s19”文件，这个文件包含最终下载带单片机中的所有内容。

S19文件的格式定义如下：

S格式文件中的每一行称为一个S记录，每个S记录由记录类型、记录长度、存储地址、代码/数据、校验和5个部分组成。

每字节数据被编码成2个16进制字符，第一个字符代表数据的高四位，第二个字符代表数据的低4位。

5个部分具体内容如下：

记录类型

记录长度

存储地址

代码/数据

校验和

记录类型：2个字符(即1个字节)，用来描述记录的类型。记录供定义了8种类型：

S0： S格式文件的第一个记录，表示文件名(含路径)，存储地址部分没有使用，以0000置位。此记录表示记录的开始，无需下载到MCU。

S1: 地址为2字节(4个字符)的记录。

S2: 地址为3字节的记录。

S3: 地址为4字节的记录。

S5: 标记本文件的S1、S2、S3记录的个数(此记录不是一个S文件所必须的)。

S7: 地为4字节，表示程序的开始执行地址，代码/数据部分没有被使用，此行表示程序的结束，无需下载到MCU。

S8: 地为3字节，表示程序的开始执行地址，代码/数据部分没有被使用，此行表示程序的结束，无需下载到MCU。

S9: 地为2字节，表示程序的开始执行地址，代码/数据部分没有被使用，此行表示程序的结束，无需下载到MCU。

记录长度: 2个字符(即1个字节)，显示在记录中剩余的字节数。即

记录长度 =存储地址字节数 +代码/数据字节数 + 校验和字节数

存储地址: 2或3或4个字节(由记录类型决定)，用来表示代码/数据应该装载的起始地址。

代码/数据: 0-64字符(即0-32字节)，表示需要下载到MCU中的数据。

校验和:    2个字符(即1字节),校验数据，计算方法:

           校验和 =  0Xff – (记录长度 +存储地址 +代码/数据)

 (注意，为校验和不是字符的校验和，而是实际二进制数的校验和)

一个典型的S19文件如下：

S01F0000443A5C50726F6A6563745F335C62696E5C50726F6A6563742E61627371

S123C000CF2100C6055B134A800BFE4A8000FE0000C015C031000000000000000000000092

S218FE8020F2FEC013EC31270BED31180A30700434F920F10A0B

S9030000FC  

说明;

第一行：S0,表示S19文件格式开始；1F为剩余字节数；0000无用；443A5C50726F6A6563745F335C62696E5C50726F6A6563742E616273

为D:/Project_3/bin/Project_3.abs.的ASCII码；71为校验和.

第二行： S1，表示本条记录存储地址长度为2字节；23(注意为16进制)剩余字

节数，C000，表示起始地址，92表示校验和。即，本行表示将

CF2100C6055B134A800BFE4A8000FE0000C015C0310000000000000000000000依次下载到从地址C000开始的一段连续地址中。

第三行： S2，表示本条记录存储地址长度为3字节，18(16进制数)表示剩余字节数，FE8020表示起始地址，0B为校验和。

校验和的计算：以S2记录为例，

        校验和 = 0xFF – (0xFE + 0x80 + 0x20 + 0Xf2 + … + 0x0A);

实现代码：

头文件：

#ifndef CS19_H
#define CS19_H

#include 

const quint8 MAX_S19_LINE_COUNT_LENGHT = 76;
const quint8 MIN_S19_LINE_COUNT_LENGHT = 10;
const quint8 MAX_S19_LINE_LENGHT = 156;

typedef enum __tagS19ErrorCode
{
    S19_NO_ERROR = 0,
    S19_FORMAT_ERROR,
    S19_VERIFY_ERROR,
    S19_LENGHT_ERROR,
    S19_USERPAPR_EEROR,
}ES19ErrorCode;

typedef enum __tagS19Type
{
    S0 = 0,
    S1,
    S2,
    S3,
    S5,
    S7,
    S8,
    S9,
    S_MAX,
}emS19Type;

typedef struct __tagS19LineData
{
    emS19Type   type;
    quint8      count;
    quint32     address;
    quint8      data[100];
    quint8      checksum;
    quint8      datalen;
}stS19LineData;

class CS19
{
public:
    CS19();
    ES19ErrorCode getS19LineData(QByteArray bydata,stS19LineData *p);

private:
    char ConvertHexChar(char ch);
};

#endif // CS19_H

源文件：

#include "Cs19.h"

const QString S19TypeTable[8] =
{
    "S0","S1","S2","S3","S5","S7","S8","S9"
};

CS19::CS19()
{

}

char CS19::ConvertHexChar(char ch)
{
    if((ch >= '0') && (ch <= '9'))
        return (ch-0x30);
    else if((ch >= 'A') && (ch <= 'F'))
        return ((ch-'A')+10);
    else if((ch >= 'a') && (ch <= 'f'))
        return ((ch-'a')+10);
    else return (-1);
}

ES19ErrorCode CS19::getS19LineData(QByteArray bydata,stS19LineData *p)
{
    quint16 i = 0;
    quint8 cs_temp = 0;
    QString str(bydata);
    char *pcdata = bydata.data();
    quint32 linelen = str.size();

    if(linelen < MIN_S19_LINE_COUNT_LENGHT)
    {
        qDebug("S19_LENGHT_ERROR");
        return S19_LENGHT_ERROR;
    }

    //获取Type
    QString stype = str.mid(0,2);
    for(i = 0; i < S_MAX; i++)
    {
        if(stype == S19TypeTable[i])
        {
            p->type = (emS19Type)i;
            break;
        }
    }
    if(i == S_MAX) {qDebug("S19_FORMAT_ERROR");return S19_FORMAT_ERROR;}

    //获取count
    p->count = (ConvertHexChar(*(pcdata + 2)) << 4) | ConvertHexChar(*(pcdata + 3));
    cs_temp += p->count;
    if(p->count != ((linelen / 2) - 3))
    {
        qDebug("S19_FORMAT_ERROR");
        return S19_FORMAT_ERROR;
    }
    //获取address
    if(p->type == S0)//2 Bytes:0x0000填充
    {
        p->address = 0x0;
    }
    else if((p->type == S1) || (p->type == S5) || (p->type == S9))//2 Bytes
    {
        p->address = (ConvertHexChar(*(pcdata + 4)) << 12) | \
                     (ConvertHexChar(*(pcdata + 5)) << 8) | \
                     (ConvertHexChar(*(pcdata + 6)) << 4) | \
                     (ConvertHexChar(*(pcdata + 7)));

        cs_temp += (p->address >> 8) & 0x0FF;
        cs_temp += p->address & 0x0FF;

        //获取data
        for(i = 0; i < p->count - 3; i++)
        {
            p->data[i] = (ConvertHexChar(*(pcdata + 2*i + 8)) << 4) | ConvertHexChar(*(pcdata + 2*i + 9));
            cs_temp += p->data[i];
        }
        //获取checksum
        p->checksum = (ConvertHexChar(*(pcdata + 2*i + 8)) << 4) | ConvertHexChar(*(pcdata + 2*i + 9));
        if(p->checksum != (0xFF - cs_temp))
        {
            qDebug("S19_VERIFY_ERROR");
            return S19_VERIFY_ERROR;
        }
    }
    else if((p->type == S2) || (p->type == S8))//3 Bytes
    {
        p->address = (ConvertHexChar(*(pcdata + 4)) << 20) | \
                     (ConvertHexChar(*(pcdata + 5)) << 16) | \
                     (ConvertHexChar(*(pcdata + 6)) << 12) | \
                     (ConvertHexChar(*(pcdata + 7)) << 8) | \
                     (ConvertHexChar(*(pcdata + 8)) << 4) | \
                     (ConvertHexChar(*(pcdata + 9)));

        cs_temp += (p->address >> 16) & 0x0FF;
        cs_temp += (p->address >> 8) & 0x0FF;
        cs_temp += p->address & 0x0FF;

        //获取data
        for(i = 0; i < p->count - 4; i++)
        {
            p->data[i] = (ConvertHexChar(*(pcdata + 2*i + 10)) << 4) | ConvertHexChar(*(pcdata + 2*i + 11));
            cs_temp += p->data[i];
        }
        //获取checksum
        p->checksum = (ConvertHexChar(*(pcdata + 2*i + 10)) << 4) | ConvertHexChar(*(pcdata + 2*i + 11));
        if(p->checksum != (0xFF - cs_temp))
        {
            qDebug("S19_VERIFY_ERROR");
            return S19_VERIFY_ERROR;
        }
    }
    else if((p->type == S3) || (p->type == S7))//4 Bytes
    {
        p->address = (ConvertHexChar(*(pcdata + 4)) << 28) | \
                     (ConvertHexChar(*(pcdata + 5)) << 24) | \
                     (ConvertHexChar(*(pcdata + 6)) << 20) | \
                     (ConvertHexChar(*(pcdata + 7)) << 16) | \
                     (ConvertHexChar(*(pcdata + 8)) << 12) | \
                     (ConvertHexChar(*(pcdata + 9)) << 8) | \
                     (ConvertHexChar(*(pcdata + 10)) << 4) | \
                     (ConvertHexChar(*(pcdata + 11)));

        cs_temp += (p->address >> 24) & 0x0FF;
        cs_temp += (p->address >> 16) & 0x0FF;
        cs_temp += (p->address >> 8) & 0x0FF;
        cs_temp += p->address & 0x0FF;

        //获取data
        for(i = 0; i < p->count - 5; i++)
        {
            p->data[i] = (ConvertHexChar(*(pcdata + 2*i + 12)) << 4) | ConvertHexChar(*(pcdata + 2*i + 13));
            cs_temp += p->data[i];
        }
        //获取checksum
        p->checksum = (ConvertHexChar(*(pcdata + 2*i + 12)) << 4) | ConvertHexChar(*(pcdata + 2*i + 13));
        if(p->checksum != (0xFF - cs_temp))
        {
            qDebug("S19_VERIFY_ERROR");
            return S19_VERIFY_ERROR;
        }
    }
    //获取datalen
    //if(p->type == S0)       p->datalen = p->count - 3;
    if(p->type == S1)  p->datalen = p->count - 3;
    else if(p->type == S2)  p->datalen = p->count - 4;
    else if(p->type == S3)  p->datalen = p->count - 5;
    else                    p->datalen = 0;

    return S19_NO_ERROR;
}