Something wrong with barcode (Code 128) font not scanning

Question

It was easy to generate a 3 of 9 barcode using Font()

Font f = new Font("Free 3 of 9", 80);
this.Font = f;

Label l = new Label();
l.Text = "*STACKOVERFLOW*";
l.Size = new System.Drawing.Size(800, 600);
this.Controls.Add(l);

this.Size = new Size(800, 600);

Its working. I see the barcode and Im able to scan it. Now I would like to use something else, like Code 128 For that I need to install the Font (done) and just change

Font f = new Font("Free 3 of 9", 80); to Font f = new Font("Code 128", 80);

After that I see a barcode on my window. The problem is that Im not able to scan that. And I think thats because I dont use the right start and stop tag for the barcode. As I understood there have to be always a start/stop char or whatever. For 3 of 9 ist the * for Code 128 im not sure. On wiki there is Start Code A so I tried

Font f = new Font("<Start Code A>test<Stop>", 80);, Font f = new Font("<Start Code A>test<Stop Code A>", 80); and so on... Im not able to scan the output. Because the scanner cannot find the start and stop char. Any ideas? Thank you

Answer 1

Code 128 can be represented with a font totally fine. It's trickier than 3 of 9 though because you have to include a checksum character at the end which needs to be dynamically computed based on the content of the barcode. There are also 3 different versions which each have a different start char.

In other words the barcode needs to be laid out like:

[start char][barcode][checksum][stop char]

The benefit of code128 is that it is much more concise than 3 of 9.

This page helped me work out the algorithm to compute my checksums.

A very general overview of the algorithm is:

1. Each character of the barcode gets a specific value assigned to it depending on what the character is and where it is located in the barcode.

2. All of the values in 1) above are added together.

3. Get the modulus 103 value of the total in 2) above.

4. In most cases, the checksum char will be the ASCII code for: (modulus value plus 32) as determined in 3) above.

There were some nuances, I ended up needing to create this algorithm in javascript of all things (no questions). For my own future reference and to show some of the nuances this is what it looked like:

/*
 * This is the variable part of my barcode, I append this to a 
 * static prefix later, but I need to perform logic to compute the 
 * checksum for this variable. There is logic earlier that enforces 
 * this variable as a 9 character string containing only digits.   
 */ 
var formIncrement = // a 9 char "digit" string variable

/*
 * Dynamically compute the total checksum value (before modulus) 
 * for the variable part of my barcode, I will need to get a modulus 
 * from this total when I am done. If you need a variable number of 
 * characters in your barcodes or if they are not all digits 
 * obviously something different would have to be done here.  
 */ 
var incrementCS = ((parseInt(formIncrement.charAt(0)) + 16) * 7) +
                  ((parseInt(formIncrement.charAt(1)) + 16) * 8) +
                  ((parseInt(formIncrement.charAt(2)) + 16) * 9) +
                  ((parseInt(formIncrement.charAt(3)) + 16) * 10) +
                  ((parseInt(formIncrement.charAt(4)) + 16) * 11) +
                  ((parseInt(formIncrement.charAt(5)) + 16) * 12) +
                  ((parseInt(formIncrement.charAt(6)) + 16) * 13) +
                  ((parseInt(formIncrement.charAt(7)) + 16) * 14) + 
                  ((parseInt(formIncrement.charAt(8)) + 16) * 15);

/*
 * 452 is the total checksum for my barcodes static prefix (600001), 
 * so it doesn't need to be computed dynamically, I just add it to 
 * the variable checksum total determined above and then get the 
 * modulus of that sum:  
 */ 
var checksum = (452 + incrementCS) % 103


var barcode = "š600001" + formIncrement

/*
 * The 0 and the 95 - 102 cases had to be defined explicitly because 
 * their checksum figures do not line up with the javascript char 
 * codes for some reason (see the code 128 definition table in the 
 * linked page) otherwise we simply need to get the charCode of the 
 * checksum + 32. I also tack on the stop char here. 
 */ 
switch (checksum) {
    case 0 :
    barcode += "€œ";
    break;
    case 95 :
    barcode += "‘œ";
    break;
    case 96 :
    barcode += "’œ";
    break;
    case 97 :
    barcode += "“œ";
    break;
    case 98 :
    barcode += "”œ";
    break;
    case 99 :
    barcode += "•œ";
    break;
    case 100 :
    barcode += "–œ";
    break;
    case 101 :
    barcode += "—œ";
    break;
    case 102 :
    barcode += "˜œ";
    break;
    default :
    barcode += String.fromCharCode(checksum + 32) + "œ";
}

return barcode;

You may notice that my start and stop chars in my example (š, œ) don't seem to match up with the ones shown on the linked page. If I remember I think it was because I had some non-standard code128 font and these chars translated to the correct ones.

EDIT

I checked back in my documentation. It looks like I got the font from right here. With that font specifically and using the algorithm above, I just made a code128b barcode for test which came out to štestwœ, it scanned fine. Your checksum algorithm seems to be working fine because we both have w but it looks like your start and stop codes are off if you are getting: ÌtestwÎ.

I made a point to look for the same barcode font that I am using because I have a feeling that different brands of code128 fonts may implement different characters to represent the start and stop barcodes.

Answer 2

Looking at Wikipedia page for Barcode128, I think you should use ASCII codes 208-210 to delimit a block, according to Bar Code Widths paragraph and table.

Answer 3

Specification

Wikipedia's Code 128 page explains the specification as follows:

A Code 128 barcode has seven sections:

1. Quiet zone
2. Start symbol
3. Encoded data
4. Check symbol (mandatory)
5. Stop symbol
6. Final bar (often considered part of the stop symbol)
7. Quiet zone

The check symbol is calculated from a weighted sum (modulo 103) of all the symbols.

Data encoding

The font will handle the required zones and lines, in addition to the data we need to supply the start and stop symbols as well as a check symbol.

The section Check digit calculation explains that the checksum is calculated by summing the start code 'value' to the products of each symbol's 'value' multiplied by its position in the barcode string. The sum of the products is then reduced modulo 103. Since the start code value in this case is 103, of which modulo 103 is 0, it can be ignored and we only have to tally up the data symbols.

Using the Free barcode fonts @ dobsonsw which is a Code 128B, or Code set B, font which supports 95 characters, ASCII characters 32 through 127. To display the check symbol there are 9 additional overflow characters that are out of sequence which need to be accounted for.

As @egerardus worked out this particular font uses non standard start (353) and stop (339) symbols and a different range of overflow characters (8216, 8217, 8220, 8221, 8226, 8211, 8212, 0732, 8364).

Implementation

The following is a working C# implementation of the barcode data encoding.

private string BarcodeEncode(string value)
{
    int[] overChars = { 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8364 };
    char[] valueChars = value.ToCharArray();
    int[] checksumVals = new int[value.Length];

    for (int n = 0; n < valueChars.Length; n++)
    {
        checksumVals[n] = (((byte)valueChars[n]) - 32) * (n + 1);
    }

    int checksum = checksumVals.Sum() % 103;
    char check = (char)(checksum + 33);
    if (checksum > 93)
        check = (char)overChars[checksum - 94];

    string start = ((char)353).ToString();
    string stop = ((char)339).ToString();

    return start + value + check.ToString() + stop;
}

Followed by the equivalent JavaScript implementation.

function barcodeEncode(value) {
    var overChars = [8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8364];
    var checksum = [...value]
            .map((i, n) => (i.charCodeAt(0) - 32) * ++n)
            .reduce((a, b) => a + b, 0) % 103;
    return String.fromCharCode(353) + value
        + (checksum < 94
            ? String.fromCharCode(checksum + 33)
            : String.fromCharCode(overChars[checksum - 94]))
        + String.fromCharCode(339);
}

nJoy!