1055 lines
26 KiB
PHP
1055 lines
26 KiB
PHP
;===============================================================================
|
|
; U S E R - D E F I N E D Q R C O D E C O N S T A N T S
|
|
;===============================================================================
|
|
|
|
IFNCONST QR_VERSION
|
|
QR_VERSION = 2 ; 1..3, QR code size (21, 25, 29)
|
|
ENDIF
|
|
IFNCONST QR_LEVEL
|
|
QR_LEVEL = 0 ; 0..4, error correction levels L, M, Q, H
|
|
ENDIF
|
|
IFNCONST QR_SINGLE_MASK
|
|
QR_SINGLE_MASK = 0 ; 0|1, use only 1 of the 8 mask pattern
|
|
ENDIF
|
|
IFNCONST QR_PADDING
|
|
QR_PADDING = 1 ; 0|1, add padding bytes add the end of test message text
|
|
ENDIF
|
|
IFNCONST QR_GENERATE
|
|
QR_GENERATE = 0 ; 0|1, generate Reed-Solomon ECC generator polynomial on-the-fly
|
|
ENDIF
|
|
|
|
|
|
;===============================================================================
|
|
; C A L C U L A T E D Q R C O D E C O N S T A N T S
|
|
;===============================================================================
|
|
|
|
; Do NOT change the following constants!
|
|
|
|
IFNCONST QR_OVERLAP
|
|
QR_OVERLAP = 0
|
|
ENDIF
|
|
IFNCONST QR_SINGLE_MASK
|
|
QR_SINGLE_MASK = 0
|
|
ENDIF
|
|
IFNCONST QR_DIRECT_DRAW
|
|
QR_DIRECT_DRAW = 0
|
|
ENDIF
|
|
|
|
IF QR_VERSION = 1 ; 21x21 QR code
|
|
IF QR_LEVEL = 0
|
|
QR_DEGREE = 7 ; for version 1, level L QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 1
|
|
QR_DEGREE = 10 ; for version 1, level M QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 2
|
|
QR_DEGREE = 13 ; for version 1, level Q QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 3
|
|
QR_DEGREE = 17 ; for version 1, level H QR codes
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF QR_VERSION = 2 ; 25x25 QR code
|
|
IF QR_LEVEL = 0
|
|
QR_DEGREE = 10 ; for version 2, level L QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 1
|
|
QR_DEGREE = 16 ; for version 2, level M QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 2
|
|
QR_DEGREE = 22 ; for version 2, level Q QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 3
|
|
QR_DEGREE = 28 ; for version 2, level H QR codes
|
|
ENDIF
|
|
ENDIF
|
|
|
|
IF QR_VERSION = 3 ; 29x29 QR code
|
|
IF QR_LEVEL = 0
|
|
QR_DEGREE = 15 ; for version 3, level L QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 1
|
|
QR_DEGREE = 26 ; for version 3, level M QR codes
|
|
ENDIF
|
|
IF QR_LEVEL = 2 || QR_LEVEL = 3
|
|
ECHO ""
|
|
ECHO "ERROR: Version 3, Level", [QR_LEVEL]d, "not supported"
|
|
ERR
|
|
ENDIF
|
|
ENDIF
|
|
|
|
QR_SIZE = 17 + QR_VERSION * 4
|
|
|
|
; Calculate capacity based on version
|
|
_QR_VAL SET (QR_VERSION * 16 + 128) * QR_VERSION + 64
|
|
IF QR_VERSION >= 2
|
|
_QR_NUM_ALIGN = QR_VERSION / 7 + 2
|
|
_QR_VAL SET _QR_VAL - ((25 * _QR_NUM_ALIGN - 10) * _QR_NUM_ALIGN - 55)
|
|
IF QR_VERSION >= 7
|
|
_QR_VAL SET _QR_VAL - 36
|
|
ENDIF
|
|
ENDIF
|
|
QR_CAPACITY = _QR_VAL / 8
|
|
|
|
QR_MAX_DATA = QR_CAPACITY - QR_DEGREE
|
|
|
|
QR_MODE = %0100 ; byte mode
|
|
QR_POLY = $11d ; GF(2^8) is based on 9 bit polynomial
|
|
; x^8 + x^4 + x^3 + x^2 + 1 = 0x11d
|
|
QR_FORMATS = 15 ; 15 type information bits
|
|
|
|
QR_MAX_MSG = QR_MAX_DATA - 2
|
|
QR_TOTAL = QR_MAX_DATA + QR_DEGREE ; e.g. 44
|
|
|
|
|
|
;===============================================================================
|
|
; V A R I A B L E S
|
|
;===============================================================================
|
|
|
|
qrRemainder = qrData ; (QR_DEGREE = e.g. 16 bytes)
|
|
qrMsgData = qrData + QR_DEGREE ; (QR_MAX_DATA = e.g. 28 bytes)
|
|
qrMsgIdx = qrTmpVars + 3
|
|
|
|
|
|
;===============================================================================
|
|
; Q R C O D E M A C R O S
|
|
;===============================================================================
|
|
|
|
; The following code has been partially converted from the C code of the
|
|
; QR code generator found at https://github.com/nayuki/QR-Code-generator
|
|
|
|
;-----------------------------------------------------------
|
|
; Returns the product of the two given field elements modulo GF(2^8/0x11D).
|
|
; All inputs are valid.
|
|
MAC _RS_MULT
|
|
;-----------------------------------------------------------
|
|
; Russian peasant multiplication (x * y)
|
|
; Input: A = x, Y = y
|
|
; Result: A
|
|
.x = qrTmpVars
|
|
.y = qrTmpVars+1
|
|
|
|
sta .x
|
|
sty .y
|
|
; uint8_t z = 0;
|
|
lda #0
|
|
; for (int i = 7; i >= 0; i--) {
|
|
ldy #7
|
|
.loopI
|
|
; z = (uint8_t)((z << 1) ^ ((z >> 7) * 0x11D));
|
|
asl
|
|
bcc .skipEorPoly
|
|
eor #<QR_POLY
|
|
.skipEorPoly
|
|
; z ^= ((y >> i) & 1) * x;
|
|
asl .y
|
|
bcc .skipEorX
|
|
eor .x
|
|
.skipEorX
|
|
; }
|
|
dey
|
|
bpl .loopI
|
|
ENDM
|
|
|
|
IF QR_GENERATE
|
|
; Computes a Reed-Solomon ECC generator polynomial for degree 16, storing in result[0 : 16-1].
|
|
; This is implemented as a lookup table too (Generator)
|
|
;-----------------------------------------------------------
|
|
MAC _RS_DIVISOR
|
|
;-----------------------------------------------------------
|
|
; E.g. g(x)=(x+1)(x+?)(x+?^2)(x+?^3)...(x+?^15)
|
|
; = x^16+3Bx^15+0Dx^14+68x^13+BDx^12+44x^11+d1x^10+1e^x9+08x^8
|
|
; +A3x^7+41x^6+29x^5+E5x^4+62x^3+32x^2+24x+3B
|
|
.root = qrTmpVars+2
|
|
.i = qrTmpVars+3
|
|
|
|
; memset(qrGenerator, 1, 16);
|
|
ldx #QR_DEGREE-1
|
|
stx .i
|
|
ldy #0
|
|
.loopClear
|
|
sty qrGenerator,x
|
|
dex
|
|
bne .loopClear
|
|
; qrGenerator[0] = 1; // Start off with the monomial x^0
|
|
iny
|
|
sty qrGenerator
|
|
; uint8_t root = 1;
|
|
sty .root
|
|
; for (int i = 0; i < degree; i++) {
|
|
.loopI
|
|
; // Multiply the current product by (x - r^i)
|
|
; for (int j = degree-1; j >= 0; j--) {
|
|
ldx #QR_DEGREE-1
|
|
.loopJ
|
|
; qrGenerator[j] = reedSolomonMultiply(qrGenerator[j], root);
|
|
lda qrGenerator,x
|
|
ldy .root
|
|
jsr RSMult
|
|
; if (j)
|
|
dex
|
|
bmi .skipEor
|
|
; qrGenerator[j] ^= qrGenerator[j - 1];
|
|
eor qrGenerator,x
|
|
.skipEor
|
|
sta qrGenerator+1,x
|
|
txa
|
|
bpl .loopJ
|
|
; root = reedSolomonMultiply(root, 0x02);
|
|
lda .root
|
|
ldy #$02
|
|
jsr RSMult
|
|
sta .root
|
|
dec .i
|
|
bpl .loopI
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
RSMult SUBROUTINE
|
|
_RS_MULT
|
|
rts
|
|
;-----------------------------------------------------------
|
|
ENDIF ; /QR_GENERATE
|
|
|
|
;-----------------------------------------------------------
|
|
MAC _RS_REMAINDER
|
|
;-----------------------------------------------------------
|
|
.i = qrTmpVars+2
|
|
.factor = qrTmpVars+3
|
|
|
|
; memset(result, 0, 16); // done in START_TEXT
|
|
; for (int i = dataLen-1; i >= 0; i--) { // Polynomial division
|
|
ldx #QR_MAX_DATA-1
|
|
.loopI
|
|
stx .i
|
|
; uint8_t factor = qrMsgData[i] ^ qrRemainder[degree - 1];
|
|
lda qrMsgData,x
|
|
eor qrRemainder + QR_DEGREE - 1
|
|
sta .factor
|
|
; memmove(&qrRemainder[1], &qrRemainder[0], (size_t)(16 - 1) * sizeof(qrRemainder[0]));
|
|
ldx #QR_DEGREE-1
|
|
.loopMove
|
|
lda qrRemainder-1,x
|
|
sta qrRemainder,x
|
|
dex
|
|
bne .loopMove
|
|
; qrRemainder[0] = 0;
|
|
lda #0
|
|
sta qrRemainder
|
|
; for (int j = 16-1; j >= 0; j--)
|
|
ldx #QR_DEGREE-1
|
|
.loopJ
|
|
; qrRemainder[j] ^= reedSolomonMultiply(generator[j], factor);
|
|
ldy .factor
|
|
IF QR_GENERATE
|
|
lda qrGenerator,x
|
|
jsr RSMult
|
|
ELSE
|
|
lda Generator,x
|
|
_RS_MULT
|
|
ENDIF
|
|
eor qrRemainder,x
|
|
sta qrRemainder,x
|
|
; }
|
|
dex
|
|
bpl .loopJ
|
|
; }
|
|
ldx .i
|
|
dex
|
|
bpl .loopI
|
|
ENDM
|
|
|
|
IF QR_DIRECT_DRAW = 0
|
|
;-----------------------------------------------------------
|
|
MAC _BLACK_FUNC
|
|
;-----------------------------------------------------------
|
|
; Blacks all function/alignment and timing pattern areas
|
|
|
|
; assume bitmap is clear, only draw the pattern
|
|
ldy #4+2 ; pattern + timing lines
|
|
.loopPattern
|
|
lda #$ff ; fill pattern
|
|
jsr DrawPattern
|
|
bpl .loopPattern
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
BlackFunc SUBROUTINE
|
|
;-----------------------------------------------------------
|
|
_BLACK_FUNC
|
|
rts
|
|
|
|
;-----------------------------------------------------------
|
|
MAC _DRAW_FUNC
|
|
;-----------------------------------------------------------
|
|
; Draws all function/alignment and timing pattern over existing codewords
|
|
|
|
; blacken functions pattern first
|
|
jsr BlackFunc
|
|
|
|
; draw function pattern
|
|
ldy #4
|
|
.loopPattern
|
|
lda #$00 ; draw pattern
|
|
jsr DrawPattern
|
|
bne .loopPattern
|
|
|
|
; draw horizontal timing pattern
|
|
ldy #QR_SIZE-1 - 9
|
|
ldx #QR_SIZE-1 - 6
|
|
.loopTimingH
|
|
jsr InvertPixel
|
|
dey
|
|
dey
|
|
cpy #9
|
|
bcs .loopTimingH
|
|
|
|
; draw vertical timing pattern
|
|
ldy #6
|
|
ldx #QR_SIZE-1 - 9
|
|
.loopTimingV
|
|
jsr InvertPixel
|
|
dex
|
|
dex
|
|
cpx #9
|
|
bcs .loopTimingV
|
|
ENDM ;
|
|
|
|
;---------------------------------------------------------------
|
|
DrawPattern SUBROUTINE
|
|
;---------------------------------------------------------------
|
|
; Y = index, A = fill
|
|
.index = qrTmpVars
|
|
.width = qrTmpVars+1
|
|
.height = qrTmpVars+2
|
|
.offset = qrTmpVars+3
|
|
.tmpPat = qrTmpVars+4
|
|
.fill = qrTmpVars+5
|
|
|
|
sty .index
|
|
sta .fill
|
|
ldx PatternY,y
|
|
lda PatternHeight,y
|
|
sta .height
|
|
lda PatternOffset,y
|
|
tay
|
|
.loopRow
|
|
sty .offset
|
|
lda PatternStart,y
|
|
ora .fill
|
|
sta .tmpPat
|
|
ldy .index
|
|
lda PatternWidth,y
|
|
sta .width
|
|
lda PatternX,y
|
|
tay
|
|
; draw one row
|
|
.loopBit
|
|
sec ; allows for >8 black pixel
|
|
ror .tmpPat
|
|
bcc .clear
|
|
;.set
|
|
jsr CheckPixel
|
|
bne .skipInvert
|
|
.invert
|
|
jsr InvertPixel
|
|
.skipInvert
|
|
iny ; x++
|
|
dec .width
|
|
bne .loopBit
|
|
dex ; y--
|
|
ldy .offset
|
|
iny
|
|
dec .height
|
|
bne .loopRow
|
|
.exit
|
|
ldy .index
|
|
dey
|
|
rts
|
|
|
|
.clear
|
|
jsr CheckPixel
|
|
bne .invert
|
|
beq .skipInvert
|
|
ENDIF ; /QR_DIRECT_DRAW = 0
|
|
|
|
;-----------------------------------------------------------
|
|
; Draws the raw codewords (including data and ECC) onto the given QR Code. This requires the initial state of
|
|
; the QR Code to be black at function modules and white at codeword modules (including unused remainder bits).
|
|
MAC _DRAW_CODEWORDS
|
|
;-----------------------------------------------------------
|
|
; Note: This part has the maximum RAM usage
|
|
.vert = qrTmpVars+0
|
|
.j = qrTmpVars+1
|
|
.y = qrTmpVars+2
|
|
IF QR_DIRECT_DRAW
|
|
.iBit = qrTmpVars+3
|
|
.iByte = qrTmpVars+4
|
|
.right1 = qrTmpVars+5
|
|
ELSE
|
|
; must not overlap with DrawPattern space
|
|
.iBit = qrTmpVars+6
|
|
.iByte = qrTmpVars+7
|
|
.right1 = qrTmpVars+8
|
|
ENDIF
|
|
|
|
; blacken the (right) function modules in the bitmap
|
|
IF QR_OVERLAP
|
|
_BLACK_RIGHT ; returns with X = 0
|
|
ELSE
|
|
IF QR_DIRECT_DRAW
|
|
_BLACK_FUNC ; returns with X = 0
|
|
ELSE
|
|
jsr BlackFunc
|
|
ldx #0
|
|
ENDIF
|
|
ENDIF
|
|
; int i = 0; // Bit index into the data
|
|
; ldx #0
|
|
; 2600 code has data in reversed order
|
|
stx .iBit
|
|
lda #QR_TOTAL-1
|
|
sta .iByte
|
|
; // Do the funny zigzag scan
|
|
; Note: 2600 code has .right1 increased by 1
|
|
; for (int right = qrsize - 1; right >= 1; right -= 2) { // Index of right column in each column pair
|
|
ldy #QR_SIZE-1+1
|
|
.loopRight
|
|
; if (right == 6)
|
|
cpy #6+1
|
|
bne .not6
|
|
; right = 5;
|
|
dey ; skip the timing column
|
|
.not6
|
|
sty .right1
|
|
IF QR_OVERLAP
|
|
; overwrite shared data
|
|
cpy #16+1
|
|
bne .skipBlackMiddle
|
|
; blacken the middle function modules in the bitmap
|
|
_BLACK_MIDDLE
|
|
IF QR_DIRECT_DRAW = 0
|
|
ldy .right1 ; DrawPattern overwrites Y
|
|
ENDIF
|
|
.skipBlackMiddle
|
|
cpy #8+1
|
|
bne .skipBlackLeft
|
|
; blacken the left function modules in the bitmap
|
|
_BLACK_LEFT
|
|
.skipBlackLeft
|
|
ENDIF
|
|
; for (int vert = 0; vert < qrsize; vert++) { // Vertical counter
|
|
ldy #QR_SIZE-1
|
|
.loopVert
|
|
sty .vert
|
|
; bool upward = ((right + 1) & 2) != 0; // 2600 code works in reverse
|
|
lda .right1
|
|
and #$02
|
|
bne .notUp
|
|
; int y = upward ? qrsize - 1 - vert : vert; // Actual y coordinate
|
|
lda #QR_SIZE-1;+1
|
|
sec
|
|
sbc .vert
|
|
tay
|
|
.notUp
|
|
sty .y
|
|
; for (int j = 0; j < 2; j++) {
|
|
; some tricky code with .j here
|
|
ldy .right1
|
|
BIT_B
|
|
.loopJ
|
|
dey
|
|
sty .j
|
|
; int x = right - j; // Actual x coordinate
|
|
dey
|
|
; if (!getModule(qrcode, x, y) && i < dataLen * 8) {
|
|
; ldy .x
|
|
ldx .y
|
|
jsr CheckPixel
|
|
bne .skipPixel
|
|
; bool black = getBit(qrData[i >> 3], 7 - (i & 7));
|
|
ldx .iByte
|
|
lda qrData,x
|
|
ldx .iBit
|
|
and BitMask,x
|
|
beq .skipInv
|
|
; setModule(qrcode, x, y, black);
|
|
; ldy .x
|
|
ldx .y
|
|
jsr InvertPixel
|
|
ldx .iBit
|
|
.skipInv
|
|
; i++;
|
|
inx
|
|
txa
|
|
and #$07
|
|
sta .iBit
|
|
bne .skipByte
|
|
dec .iByte
|
|
bmi .exitDraw ; 2600 code exits here!
|
|
.skipByte
|
|
; }
|
|
.skipPixel
|
|
ldy .j
|
|
cpy .right1
|
|
beq .loopJ
|
|
; } // for j
|
|
ldy .vert
|
|
dey
|
|
bpl .loopVert
|
|
; } // for vert
|
|
ldy .right1
|
|
dey
|
|
dey
|
|
IF QR_OVERLAP
|
|
jmp .loopRight
|
|
ELSE
|
|
bpl .loopRight ; unconditional!
|
|
ENDIF
|
|
; } // for right
|
|
.exitDraw
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
MAC _APPLY_MASK
|
|
;-----------------------------------------------------------
|
|
IF QR_SINGLE_MASK
|
|
.y = qrTmpVars
|
|
ldx #QR_SIZE - 1
|
|
.loopY
|
|
stx .y
|
|
ldy #QR_SIZE - 1
|
|
.loopX
|
|
; 0: (x + y) % 2 == 0
|
|
tya
|
|
eor .y
|
|
lsr
|
|
bcs .skipInvert
|
|
jsr InvertPixel
|
|
.skipInvert
|
|
dey
|
|
bpl .loopX
|
|
dex
|
|
bpl .loopY
|
|
ELSE
|
|
.y = qrTmpVars
|
|
;.x = qrTmpVars+2
|
|
.xMod3 = qrTmpVars+1
|
|
.yMod3 = qrTmpVars+2
|
|
.xDiv3 = qrTmpVars+3
|
|
.tmp = qrTmpVars+4
|
|
|
|
lda #0
|
|
sta .yMod3
|
|
ldx #QR_SIZE - 1
|
|
.loopY
|
|
stx .y
|
|
lda #0
|
|
sta .xMod3
|
|
sta .xDiv3
|
|
ldy #QR_SIZE - 1
|
|
.loopX
|
|
; sty .x
|
|
lda qrPattern
|
|
bne .not0
|
|
; 0: (x + y) % 2 == 0
|
|
tya
|
|
eor .y
|
|
bpl .checkMod2
|
|
|
|
.not0
|
|
cmp #4
|
|
bne .not4
|
|
; 4: (x / 3 + y / 2) % 2 == 0
|
|
lda .y
|
|
lsr
|
|
adc .xDiv3
|
|
bpl .checkMod2
|
|
|
|
.not4
|
|
bcs .above4
|
|
|
|
lsr
|
|
bcs .not2
|
|
; 2: x % 3 == 0
|
|
lda .xMod3
|
|
beq .invert
|
|
bne .skipInvert
|
|
|
|
.not2
|
|
bne .is3
|
|
; 1: y % 2 == 0
|
|
txa
|
|
bpl .checkMod2
|
|
|
|
.is3
|
|
; 3: (x + y) % 3 == 0
|
|
lda .xMod3
|
|
; sec
|
|
sbc .yMod3
|
|
beq .invert
|
|
bne .skipInvert
|
|
|
|
.above4
|
|
cmp #6
|
|
beq .is6
|
|
bcs .is7
|
|
.is6
|
|
php
|
|
; 5: x * y % 2 + x * y % 3 == 0
|
|
; 6: (x * y % 2 + x * y % 3) % 2 == 0
|
|
lda .xMod3
|
|
beq .modEven56
|
|
lda .yMod3
|
|
beq .modEven56
|
|
clc
|
|
adc .xMod3
|
|
BIT_W
|
|
.modEven56
|
|
lda #0
|
|
sta .tmp
|
|
tya
|
|
lsr
|
|
bcc .even56
|
|
txa
|
|
lsr
|
|
bcc .even56
|
|
inc .tmp
|
|
.even56
|
|
plp
|
|
lda .tmp
|
|
bcs .checkMod2
|
|
beq .invert
|
|
bne .skipInvert
|
|
|
|
.is7
|
|
; 7: ((x + y) % 2 + x * y % 3) % 2 == 0
|
|
tya
|
|
eor .y
|
|
sta .tmp
|
|
lda .xMod3
|
|
beq .modEven7
|
|
lda .yMod3
|
|
beq .modEven7
|
|
clc
|
|
adc .xMod3
|
|
adc .tmp
|
|
sta .tmp
|
|
.modEven7
|
|
lda .tmp
|
|
.checkMod2
|
|
lsr
|
|
bcs .skipInvert
|
|
.invert
|
|
jsr InvertPixel
|
|
.skipInvert
|
|
; next X
|
|
dec .xMod3
|
|
bpl .xMod3OK
|
|
lda #2
|
|
sta .xMod3
|
|
inc .xDiv3
|
|
.xMod3OK
|
|
dey
|
|
bpl .loopX
|
|
; next Y
|
|
dec .yMod3
|
|
bpl .yMod3OK
|
|
lda #2
|
|
sta .yMod3
|
|
.yMod3OK
|
|
dex
|
|
bmi .exitLoopY
|
|
jmp .loopY
|
|
|
|
.exitLoopY
|
|
ENDIF ; !QR_SINGLE_MASK
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
MAC _DRAW_FORMAT
|
|
;-----------------------------------------------------------
|
|
IF QR_SINGLE_MASK = 0 || QR_DIRECT_DRAW = 0
|
|
.idx = qrTmpVars
|
|
|
|
ldy #QR_FORMATS-1
|
|
.loopFormat
|
|
sty .idx
|
|
cpy #8
|
|
IF QR_SINGLE_MASK
|
|
ldx #0
|
|
ELSE
|
|
ldx qrPattern
|
|
ENDIF
|
|
lda FormatLo,x
|
|
and BitMask,y
|
|
bcc .lowFormat
|
|
lda FormatHi,x
|
|
and BitMask-8,y
|
|
.lowFormat
|
|
IF QR_DIRECT_DRAW
|
|
beq .skipFormat
|
|
ELSE
|
|
bne .skipFormat
|
|
ENDIF
|
|
ldx FormatY1,y
|
|
lda FormatX1,y
|
|
tay
|
|
jsr InvertPixel
|
|
ldy .idx
|
|
ldx FormatY2,y
|
|
lda FormatX2,y
|
|
tay
|
|
jsr InvertPixel
|
|
ldy .idx
|
|
.skipFormat
|
|
dey
|
|
bpl .loopFormat
|
|
ENDIF
|
|
ENDM
|
|
|
|
; ********** The user macros start here: **********
|
|
|
|
;-----------------------------------------------------------
|
|
MAC START_MSG
|
|
;-----------------------------------------------------------
|
|
; A = message length
|
|
; add mode and length to message data
|
|
tax
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
ora #(QR_MODE << 4)
|
|
; (QR_MODE << 4) | (MSG_LEN >> 4)
|
|
sta qrMsgData + QR_MAX_DATA - 1
|
|
txa
|
|
asl
|
|
asl
|
|
asl
|
|
asl
|
|
; (MSG_LEN << 4)
|
|
sta qrMsgData + QR_MAX_DATA - 2
|
|
lda #QR_MAX_DATA - 3
|
|
sta qrMsgIdx
|
|
; clear the remaining data buffer
|
|
ldx #QR_TOTAL-3
|
|
lda #0
|
|
.loopClear
|
|
sta qrData,x
|
|
dex
|
|
bpl .loopClear
|
|
ENDM
|
|
|
|
;---------------------------------------------------------------
|
|
MAC ADD_MSG_BYTE
|
|
;---------------------------------------------------------------
|
|
; A = byte to add
|
|
ldx qrMsgIdx
|
|
pha
|
|
lsr
|
|
lsr
|
|
lsr
|
|
lsr
|
|
ora qrMsgData + 1,x
|
|
sta qrMsgData + 1,x
|
|
pla
|
|
asl
|
|
asl
|
|
asl
|
|
asl
|
|
sta qrMsgData,x
|
|
dec qrMsgIdx
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
MAC STOP_MSG
|
|
;-----------------------------------------------------------
|
|
IF QR_PADDING
|
|
.msgLen = qrTmpVars
|
|
; pad with optional filler bytes (QR code works without too)
|
|
lda #QR_MAX_MSG - 1
|
|
sec
|
|
sbc .msgLen
|
|
bcc .noPadding
|
|
tax
|
|
.loopPadding
|
|
lda #$ec ; defined by QR standard
|
|
sta qrMsgData,x
|
|
dex
|
|
bmi .noPadding
|
|
lda #$11 ; defined by QR standard
|
|
sta qrMsgData,x
|
|
dex
|
|
bpl .loopPadding
|
|
.noPadding
|
|
ENDIF
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
MAC GEN_QR_CODE
|
|
;-----------------------------------------------------------
|
|
; This is the main macro to use!
|
|
QRCodeCode
|
|
|
|
IF QR_GENERATE
|
|
; generate the Reed-Solomon ECC generator polynomial
|
|
RSDevisor
|
|
_RS_DIVISOR
|
|
ENDIF
|
|
; calculate the ECC
|
|
RSRemainder
|
|
_RS_REMAINDER
|
|
; draw the code words onto the bitmap
|
|
DrawCodes
|
|
_DRAW_CODEWORDS
|
|
; apply the pattern mask
|
|
ApplyMask
|
|
_APPLY_MASK
|
|
; blacken the function modules in the bitmap again
|
|
; and draw the function modules in the bitmap
|
|
DrawFunc
|
|
_DRAW_FUNC
|
|
; draw the format bits
|
|
DrawFormat
|
|
_DRAW_FORMAT
|
|
|
|
ECHO "QR Code encoding code:", [. - QRCodeCode]d, "bytes"
|
|
_QR_TOTAL SET _QR_TOTAL + . - QRCodeCode
|
|
ENDM
|
|
|
|
;-----------------------------------------------------------
|
|
MAC QR_CODE_DATA
|
|
;-----------------------------------------------------------
|
|
; Add this to your code's data area
|
|
QRCodeData
|
|
|
|
IF QR_DIRECT_DRAW = 0
|
|
; Function pattern parameters
|
|
PatternX ; left
|
|
.byte 6 ; left, vertical timing line
|
|
.byte 0, 0, QR_SIZE-8 ; eye pattern
|
|
.byte QR_SIZE-8, QR_SIZE-9 ; alignment pattern (right/middle part)
|
|
.byte 9 ; top, horizontal timing line
|
|
PatternY ; top
|
|
.byte QR_SIZE - 10 ; left, vertical timing line
|
|
.byte QR_SIZE-1, 7, QR_SIZE-1 ; eye pattern
|
|
.byte 8, 8 ; alignment pattern (right/middle part)
|
|
.byte QR_SIZE - 7 ; top, horizontal timing line
|
|
PatternOffset = . - 1
|
|
.byte EyeLeftTop-PatternStart ; 1
|
|
.byte EyeLeftBottom-PatternStart ; 2
|
|
.byte EyeRightTop-PatternStart ; 3
|
|
.byte AlignRightBottom-PatternStart
|
|
.byte AlignRightBottom-PatternStart
|
|
; timing lines need no pattern, always drawn filled here
|
|
PatternWidth
|
|
.byte 1 ; left, vertical timing line
|
|
.byte 9, 9, 8 ; eye pattern
|
|
.byte 4, 1 ; alignment pattern (right/middle part)
|
|
; .byte QR_SIZE - 9 - 8 ; top, horizontal timing line
|
|
PatternHeight
|
|
.byte QR_SIZE - 9 - 8 ; left, vertical timing line
|
|
.byte 9, 8, 9 ; eye pattern
|
|
.byte 5, 5 ; alignment pattern (right/middle part)
|
|
.byte 1 ; top, horizontal timing line
|
|
|
|
PatternStart
|
|
EyeRightTop
|
|
.byte %11111110
|
|
.byte %10000010
|
|
.byte %10111010
|
|
.byte %10111010
|
|
.byte %10111010
|
|
.byte %10000010
|
|
.byte %11111110
|
|
.byte %00000000
|
|
.byte %11111111
|
|
AlignRightBottom = . - 1
|
|
; .byte %1111
|
|
.byte %1000
|
|
.byte %1010
|
|
.byte %1000
|
|
.byte %1111
|
|
|
|
EyeLeftBottom
|
|
.byte %00000000
|
|
; .byte %01111111
|
|
; .byte %01000001
|
|
; .byte %01011101
|
|
; .byte %01011101
|
|
; .byte %01011101
|
|
; .byte %01000001
|
|
; .byte %01111111
|
|
EyeLeftTop
|
|
.byte %01111111
|
|
.byte %01000001
|
|
.byte %01011101
|
|
.byte %01011101
|
|
.byte %01011101
|
|
.byte %01000001
|
|
.byte %01111111
|
|
.byte %00000000
|
|
.byte %11111111
|
|
ENDIF ; /QR_DIRECT_DRAW
|
|
|
|
; Format Information Strings
|
|
IF QR_SINGLE_MASK = 0 || QR_DIRECT_DRAW = 0
|
|
IF QR_LEVEL = 0 ; L
|
|
FormatLo
|
|
.byte %11101111
|
|
.byte %11100101
|
|
.byte %11111011
|
|
.byte %11110001
|
|
.byte %11001100
|
|
.byte %11000110
|
|
.byte %11011000
|
|
.byte %11010010
|
|
FormatHi
|
|
.byte %10001000
|
|
.byte %11100110
|
|
.byte %01010100
|
|
.byte %00111010
|
|
.byte %01011110
|
|
.byte %00110000
|
|
.byte %10000010
|
|
.byte %11101100
|
|
ENDIF
|
|
IF QR_LEVEL = 1 ; M
|
|
FormatLo
|
|
.byte %10101000
|
|
.byte %10100010
|
|
.byte %10111100
|
|
.byte %10110110
|
|
.byte %10001011
|
|
.byte %10000001
|
|
.byte %10011111
|
|
.byte %10010101
|
|
FormatHi
|
|
.byte %00100100
|
|
.byte %01001010
|
|
.byte %11111000
|
|
.byte %10010110
|
|
.byte %11110010
|
|
.byte %10011100
|
|
.byte %00101110
|
|
.byte %01000000
|
|
ENDIF
|
|
IF QR_LEVEL = 2 ; Q
|
|
FormatLo
|
|
.byte %01101010
|
|
.byte %01100000
|
|
.byte %01111110
|
|
.byte %01110100
|
|
.byte %01001001
|
|
.byte %01000011
|
|
.byte %01011101
|
|
.byte %01010111
|
|
FormatHi
|
|
.byte %10111110
|
|
.byte %11010000
|
|
.byte %01100010
|
|
.byte %00001100
|
|
.byte %01101000
|
|
.byte %00000110
|
|
.byte %10110100
|
|
.byte %11011010
|
|
ENDIF
|
|
IF QR_LEVEL = 3 ; H
|
|
FormatLo
|
|
.byte %00101101
|
|
.byte %00100111
|
|
.byte %00111001
|
|
.byte %00110011
|
|
.byte %00001110
|
|
.byte %00000100
|
|
.byte %00011010
|
|
.byte %00010000
|
|
FormatHi
|
|
.byte %00010010
|
|
.byte %01111100
|
|
.byte %11001110
|
|
.byte %10100000
|
|
.byte %11000100
|
|
.byte %10101010
|
|
.byte %00011000
|
|
.byte %01110110
|
|
ENDIF
|
|
|
|
; positions of the 15 type information bits
|
|
FormatX1
|
|
.byte 0, 1, 2, 3, 4, 5, 7, 8
|
|
; ds 7, 8 ; shared
|
|
FormatX2
|
|
ds 7, 8
|
|
.byte QR_SIZE-8, QR_SIZE-7, QR_SIZE-6, QR_SIZE-5
|
|
.byte QR_SIZE-4, QR_SIZE-3, QR_SIZE-2, QR_SIZE-1
|
|
FormatY2
|
|
.byte 0, 1, 2, 3, 4, 5, 6
|
|
; ds 8, QR_SIZE-9 ; shared
|
|
FormatY1
|
|
ds 8, QR_SIZE-9
|
|
.byte QR_SIZE-8, QR_SIZE-6, QR_SIZE-5, QR_SIZE-4
|
|
.byte QR_SIZE-3, QR_SIZE-2, QR_SIZE-1
|
|
ENDIF ; /QR_SINGLE_MASK = 0 || QR_DIRECT_DRAW = 0
|
|
|
|
BitMask
|
|
.byte $80, $40, $20, $10, $8, $4, $2, $1
|
|
|
|
IF QR_GENERATE = 0
|
|
Generator ; data in reversed order!
|
|
IF QR_DEGREE = 7
|
|
.byte $75, $44, $0b, $a4, $9a, $7a, $7f
|
|
ENDIF
|
|
IF QR_DEGREE = 10
|
|
.byte $c1, $9d, $71, $5f, $5e, $c7, $6f, $9f
|
|
.byte $c2, $d8
|
|
ENDIF
|
|
IF QR_DEGREE = 13
|
|
.byte $87, $84, $53, $2b, $2e, $0d, $34, $11
|
|
.byte $b1, $11, $e3, $49, $89
|
|
ENDIF
|
|
IF QR_DEGREE = 15
|
|
.byte $1a, $86, $20, $97, $84, $8b, $69, $69
|
|
.byte $0a, $4a, $70, $a3, $6f, $c4, $1d
|
|
ENDIF
|
|
IF QR_DEGREE = 16
|
|
; Reed-Solomon ECC generator polynomial for degree 16
|
|
; g(x)=(x+1)(x+?)(x+?^2)(x+?^3)...(x+?^15)
|
|
; = x^16+3bx^15+0dx^14+68x^13+bdx^12+44x^11+d1x^10+1e^x9+08x^8
|
|
; +a3x^7+41x^6+29x^5+e5x^4+62x^3+32x^2+24x+3b
|
|
.byte $3b, $24, $32, $62, $e5, $29, $41, $a3
|
|
.byte $08, $1e, $d1, $44, $bd, $68, $0d, $3b
|
|
ENDIF
|
|
IF QR_DEGREE = 17
|
|
.byte $4f, $63, $7d, $35, $55, $86, $8f, $29
|
|
.byte $f9, $53, $c5, $16, $77, $78, $53, $42
|
|
.byte $77
|
|
ENDIF
|
|
IF QR_DEGREE = 22
|
|
.byte $f5, $91, $1a, $e6, $da, $56, $fd, $43
|
|
.byte $7b, $1d, $89, $1c, $28, $45, $bd, $13
|
|
.byte $f4, $b6, $b0, $83, $b3, $59
|
|
ENDIF
|
|
IF QR_DEGREE = 26
|
|
.byte $5e, $2b, $4d, $92, $90, $46, $44, $87
|
|
.byte $2a, $e9, $75, $d1, $28, $91, $18, $ce
|
|
.byte $38, $4d, $98, $c7, $62, $88, $04, $b7
|
|
.byte $44, $f6
|
|
ENDIF
|
|
IF QR_DEGREE = 28
|
|
.byte $c5, $3a, $4a, $b0, $93, $79, $64, $b5
|
|
.byte $7f, $e9, $77, $75, $38, $f7, $0c, $a7
|
|
.byte $29, $64, $ae, $67, $96, $d0, $fb, $12
|
|
.byte $0d, $1c, $09, $fc
|
|
ENDIF
|
|
|
|
QR_DEGREE = . - Generator ; verify data size
|
|
|
|
ENDIF ; /QR_GENERATE
|
|
|
|
ECHO "QR Code encoding data:", [. - QRCodeData]d, "bytes"
|
|
_QR_TOTAL SET _QR_TOTAL + . - QRCodeData
|
|
|
|
ENDM |