Is There Life After HART?

4800 BPS HART:  A Proposal

by Analog Services, Inc.

    Coding

    [Click   here  to return to main document]

    The goal of the coding is to create frequent transitions and to control errors without adding too many extra bits.  Existing HART uses eleven bit times to send only 8 bits.  This makes it possible to limit same-bit string lengths to 3.  The sequence of the code words must also be considered, to prevent the creation of a long string of the same bit out of adjacent portions of two words.  The proposed set of coding rules is as follows:

        1.    Code words are transmitted most-significant-bit first.  (This is an
                arbitrary decision.  A different set of code words could also be
                created for transmission of LSB first.)

        2.    The words are divided into 4 groups, according to the first two bits
                (most significant two bits).  Words that start with 01 or 10 are sent
                as is.  Words that start with 11 are alternates for those that start
                with 00.  That is, there are two possible code words for some of
                the input bytes.  Words that begin with 00 are sent as is if the last
                bit (least significant) of the previous word was a 1.  Words that
                begin with 00 are replaced with alternates if the last bit of the previous
                word was a 0.

        3.    No word may contain a group of 4 contiguous identical bits (i.e.,
                can't be 0000 or 1111).

        4.    The last 3 bits (least significant 3 bits) of a word must not all be
                the same (i.e., can't be 000 or 111).

        5.    The words 01010101010 (decimal 682)  and 10101010101
                (decimal 1365) are reserved as preamble words.

    The coding as just described ignores error checking.  The 9th bit in existing HART that was used for error control was discarded.  We still need something equivalent to this for the proposed scheme.  Otherwise a single bit error in the code word could produce another valid code word and lead to the selection of the wrong byte at the decoder.  We would then have to rely entirely on the checksum at the end of the message for all of the error control.  And it is known that just a checksum alone is not adequate.

    Error control can be re-instated by allowing only code words with odd parity (odd number of 1 bits).  This allows the decoder to catch any odd number of bit errors, which is the same as in existing HART.  For a further discussion of errors and error control click    here  .)  With the requirement of odd parity, the acceptable number of code words is reduced, but still exceeds 256, along with alternates.

    Another consideration is to maintain a balance between the number of 1's and 0's transmitted.   Therefore, an additional rule is that words with either 5 or 7 one bits are acceptable.  Those with only 3 are eliminated.

    A final coding consideration is that the preamble be recognizeable using a minimum number of bits.   It turns out that with the exclusion of two words, 19 bits of preamble are sufficient to differentiate the preamble from normal data.  The two words that need  to be excluded are 01010101001 (decimal 681) and 10101010100 (decimal 1364).

    Applying these rules results in 82 words that begin with 00, 223 words that begin with either 01 or 10, and 96 words that begin with 11.  All 223 of those that begin with either 01 or 10 are chosen.  Among the 82 that begin with 00, 33 are chosen.  And, among the 96 that begin with 11, 33 are chosen as alternates.  The table of proposed code words is listed below.   A C program was written to generate the acceptable code words and to check the number of alternating 1's and 0's in all possible combinations of adjacent words.  The C program listing is also given below.

    From an implementation viewpoint, the coder and decoder are reasonably sized.  If implemented in ROM, the coder uses only 512 locations of 11 bits each.  (It is 512 instead of 256 because an extra bit is used from the preceding output word.)  The decoder uses 2048 locations of 9 bits each (8 bit byte + parity).

    There are 2048 possible code words that can be constructed from 11 bits, and only 256 of these are being used to represent data.  If an error occurs and the receiver encounters a word that is not one of the allowed 256, then it must indicate this to its respective microcontroller.  This is easily done by having it generate some convenient dummy byte + bad (even) parity.  Thus, 1792 of the 2048 ROM locations in the receiver would contain this dummy byte.

/*  gen10.c
    Modified to exclude 681 and 1364.
    Modified from gen9.c to locate words that, when
    combined can have some chosen number of alternating 1's and 0's.
    Modified from gen8.c so that it skips the special preamble
    characters (decimal 682 and 1365).
    Table generator.
    Stephen D. Anderson --- November 22, 1999.

*/

#define MASK 524287L
//#define MASK 131071L
//#define MASK 32767L
//#define MASK 8191L

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "dos.h"

main()
{
    unsigned long int two_word;
    unsigned long int part_two_word;
    unsigned int i;      /*  running number. */
    int good_count = 0;     /*  number of acceptable values. */
    FILE *fout;         /*   pointer to output file.  */
    int j;
    int k;
    char flag;
    int local_i;
    int sum;
    char s[15];
    char *ps;
    unsigned long int good_values[500];
    char bad_count;

    //Open output file.
    if ((fout = fopen("out.dat","w")) == 0)
    {
        printf("Can't open output file.");
        exit(0);
    }

    //  Generate all possible values.
    for (i=0; i<2048; ++i)
    {

        flag = 0;

        //  Remove preamble chars.
        local_i =i;
        if (local_i == 682) flag = 1;
        if (local_i == 1365) flag = 1;

        //  Exclude 681 and 1364.
        if (local_i == 681) flag = 1;
        if (local_i == 1364) flag = 1;

        //  Remove words with last 3 bits same.
        local_i = i;
        k = local_i & 7;
        if (k == 7) flag = 1;
        if (k == 0) flag = 1;

        //  Check combinations of 4 bits.
        local_i = i;
        for (j=0; j<8; ++j)
        {
            k = local_i & 0xf;       /*  mask off.  */
            if (k==0) {flag = 1; break; }
            if (k==0xf) {flag = 1; break; }
            local_i = local_i/2;
        }

        //  Check parity.
        local_i = i;
        k = 1;
        sum = 0;
        for (j=0; j<11; ++j)
        {
            if ((k & local_i) != 0) ++sum;
            k = 2*k;
        }
        if (sum%2 == 0) flag = 1;

        //  Throw out words that have 3 ones.
        if (sum ==3) flag = 1;

        //  Get binary version of number.
        local_i = i;
        ps = s;
        k = 0x400;
        for (j=0; j<11; ++j)
        {
            if ((k & local_i) != 0)
                *ps++ = '1';
            else
                *ps++ = '0';
            k = k/2;
        }
        *ps = 0;

        if (flag==0)
        {
            ++good_count;
            fprintf(fout, "%d    %d   %s   %d\n", good_count,i,s,sum);
//    printf("%d\n", good_count);
           good_values[good_count-1] = i;
        }
    }
    fclose(fout);

    // Try all combinations of two code words.  See if any have
    // a 19 bit section that looks like preamble.
    bad_count = 0;
    for (i=0; i<good_count-1; ++i)
    {
        for (j=0; j<good_count-1; ++j)
        {
            two_word = 2048L*good_values[i] + good_values[j];
            //  Get each 19-bit section.
            for (k=0; k<3; ++k)
            {
                part_two_word = MASK & (two_word>>k);
                if (part_two_word == 174762L)
                {
                    printf("%d %ld %d %ld\n", i,good_values[i],j,good_values[j]);
                    ++bad_count;
                    if (bad_count > 5) exit(0);
                }
            }
        }
    }
}

---

For more information on how Analog Services, Inc. can help solve your circuit/system problems, call or e-mail us today.

Contact Analog Services, Inc.

E-Mail: stevea@analogservices.com

home