Использование цифровых ценников в мирных целях

#define SET_SS  P1_7 = 0;
#define RESET_SS  P1_7 = 1;
#define CMD_MODE P2_2 = 0;	
#define DATA_MODE P2_2 = 1;	

static void SendCmd(uint8_t cmd)	//sets chip select
{
	SET_SS
	CMD_MODE
	spiByte(cmd);
}

static void SendData(uint8_t byte)
{
	SET_SS
	DATA_MODE
	spiByte(byte);
}


static void SendCmdWithOneByte(uint16_t vals)	//passing in one u16 is better than two params cause SDCC sucks
{
	SendCmd(vals >> 8);
	SendData(vals);
	RESET_SS
}


static void WaitWithTimeout(uint32_t timeout)
{
	uint32_t __xdata start = timerGet();
	while (timerGet() - start < timeout) 
  {
		if (!P2_1)  return;// busy		
	}
	pr("screen timeout %lu ticks\n", timerGet() - start);
	while(1);
}

#define TIMEOUT 5 


static void SSD1675_init(void)
{
  timerDelay(TIMER_TICKS_PER_SECOND / 1000);
  P2_0 = 0;  // hardware reset
  timerDelay(TIMER_TICKS_PER_SECOND / 1000);
  P2_0 = 1;
  timerDelay(TIMER_TICKS_PER_SECOND / 10);
  SendCmd(0x12);	//software reset
  RESET_SS
  timerDelay(TIMER_TICKS_PER_SECOND / 10);
	
  SendCmdWithOneByte(0x7454);  // Set Analog Block Control
  SendCmdWithOneByte(0x7e3b);  // Set Digital Block Control
	
  SendCmd(0x2b);  // Write Register for VCOM Control
  SendData(0x04);
  SendData(0x63);
  RESET_SS

  SendCmd(0x01);  // Driver Output control
  SendData((SCREEN_HEIGHT - 1) & 0xff);
  SendData((SCREEN_HEIGHT - 1) >> 8);
  SendData(0x00);
  RESET_SS
	
  SendCmdWithOneByte(0x2200 | SCREEN_CMD_CLOCK_ON | SCREEN_CMD_ANALOG_ON); //turn on clock & analog - not as in DS
  SendCmd(0x20);				//do action
  RESET_SS
  WaitWithTimeout(TIMER_TICKS_PER_SECOND / TIMEOUT);
	
  SendCmdWithOneByte(0x1103);  // Data Entry mode setting Y increment, X increment


  SendCmd(0x44);  // Set RAM X-address Start/End position
  SendData(0x00);
  SendData(SCREEN_WIDTH / 8 - 1);
  RESET_SS
	
  SendCmd(0x45);  // Set RAM Y-address Start/End position
  SendData(0x00);
  SendData(0x00);
  SendData((SCREEN_HEIGHT - 1) & 0xff);
  SendData((SCREEN_HEIGHT - 1) >> 8);
  RESET_SS

  SendCmdWithOneByte(0x3cc0);	//border will be HiZ
  SendCmdWithOneByte(0x1880);	// use internal temp sensor
  SendCmdWithOneByte(0x030f);	//VGH/VGL = ±16V	
  SendCmdWithOneByte(0x2c50);	//VCOM = -2.0V
  SendCmdWithOneByte(0x3a0c);	//frame rate 90hz - not in DS
  SendCmdWithOneByte(0x3b07);	//as above - not in DS
	
  SendCmd(0x0c);  // Booster Soft start Control again? Why?
  SendData(0x8f);
  SendData(0x8f);
  SendData(0x8f);
  SendData(0x3f);
  RESET_SS
	
  SendCmd(0x04);  // Source Driving voltage Control
  SendData(0x3c);	//VSH1 = 14V
  SendData(0xa3);	//VSH2 = 4.5V
  SendData(0x2e);  // VSL = 14V  
  RESET_SS
	
  //SendCmdWithOneByte(0x2200 | SCREEN_CMD_LOAD_LUT); // copy LUT, only black, fast, works
  SendCmdWithOneByte(0x2290); // copy LUT, only black, fast, works

  SendCmd(0x20);				//do action
  RESET_SS
  WaitWithTimeout(TIMER_TICKS_PER_SECOND / TIMEOUT);
}


static void SSD1675_setXY(uint8_t x, uint8_t y)
{
  SendCmd(0x4E);       // set RAM x address count to 0;
  SendData(x);        // (x_start); 
  RESET_SS
  SendCmd(0x4F);       // set RAM y address count to 0X127;    
  SendData(y & 0xFF); 
  SendData(y >> 8);  
  RESET_SS

}

static void SSD1675_update_screen(void)
{
  SendCmdWithOneByte(0x2200 | SCREEN_CMD_REFRESH);
  SendCmd(0x20);				//do actions
  RESET_SS
  WaitWithTimeout(TIMER_TICKS_PER_SECOND * 60UL);
}

void Code2Image(const uint8_t  * addr)
{
  __xdata uint16_t i;   
  const uint8_t  *  pointer;
  pointer = addr;   
  
  SSD1675_setXY(0, 0);
  SendCmd(0x24);  // black RAM
  RESET_SS
  i= (SCREEN_WIDTH/8)*SCREEN_HEIGHT;
  while(i--) SendData(~(*pointer++));
  RESET_SS

  SSD1675_setXY(0,0);
  SendCmd(0x26);  // red RAM
  RESET_SS   
  i= (SCREEN_WIDTH/8)*SCREEN_HEIGHT;
  while(i--) SendData(0x00);
  RESET_SS

  // ************************************************
  SSD1675_update_screen();
  // SendCmdWithOneByte(0x1003);	//shut down
}

void CmemTest(void)
{
  uint8_t i;
  const uint8_t  *  image[] ={image_00, image_01, image_02, image_03, image_04};
  for(i=0; i<4; i++)  
  {
	  Code2Image(image[i]);
	  timerDelay(TIMER_TICKS_PER_SECOND * 2);
  }	
}


void screenTest5(void)
{
  SSD1675_init();
  CmemTest();
  flashMemTest();  	
  SendCmdWithOneByte(0x1003);	//shut down
}

import sys
import os
from PIL import Image

#filename1 = "matroskin.png"

if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python3 %s [image name]" % (sys.argv[0],))
        sys.exit(-1)

    im = Image.open(sys.argv[1])
    pix = im.load()
    filename = os.path.splitext(sys.argv[1])[0]
    f = open(filename + ".h", "w+")
    f.write("// %s width=%d;\n" % (filename, im.size[0]))
    f.write("// %s heigt=%d;\n" % (filename, im.size[1]))    
    f.write("static const uint8_t %s_DATA[]={\n" % (filename.upper()))

    byte=0
    bitCounter=8
    lineCounter= 16
    for y in range(0, im.size[1]):
        for x in range(0, im.size[0]):
            byte = byte<<1
            r, g, b = pix[x, y]        
            gray = 0.299*r + 0.587*g + 0.114*b
            if (gray<127):
                byte = byte | 1
            bitCounter -= 1
            if(bitCounter==0): 
                bitCounter=8           
                f.write("0x%02x, " % byte)                 
                byte = 0
                lineCounter -= 1 
                if (lineCounter==0):
                    f.write("\n")
                    lineCounter =16

    f.write("};\n")
f.close()

__bit TxReady;
// size must be 2^n
#define BUFF_SIZE 64
__xdata uint8_t rxbuff[BUFF_SIZE];
uint8_t rxtail;
uint8_t rxhead;

void uartFlush(void)
{
  rxtail=0;
  rxhead=0;	
}

void uartInit(void)
{
	TxReady = true;
	uartFlush();
	//set up pins for UART (0.6 TxD & 0.7 RxD)
	P0FUNC |= (1 << 6) | (1 << 7);
	P0DIR &= ~(1 << 6);

	//clock it up
	CLKEN |= 0x20;
	
	//configure
	UARTBRGH = 0x00;	//config for 115200
	UARTBRGL = 0x8A;
	UARTSTA = 0x12;		//also set the "empty" bit else we wait forever for it to go up
	IEN_UART0 = 1;      // enable interrupt
}



uint8_t uartAvailable(void)
{
  return (rxhead-rxtail);
}

uint8_t uartRx(void)
{
  uint8_t newChar;
  while ((rxhead-rxtail)==0);
  newChar = rxbuff[rxtail];
  rxtail++;
  rxtail &= BUFF_SIZE-1;
  return newChar;
}


void uartTx(uint8_t val)
{
	while(!TxReady);
	TxReady = false; 
	UARTBUF = val;
}




void UART_IRQ1(void) __interrupt(0)
{
  if (UART_RXF)
  {
    UART_RXF=false;
	  rxbuff[rxhead]=UARTBUF;
    rxhead++;
    rxhead &= BUFF_SIZE-1;
  }
  else
  {
    UART_TXE=false;
	  TxReady=true;
  }
}

enum ihex_state {
    WAIT_FOR_START,
    COUNT,
    ADDRESS,
    TYPE,   
    EXT_ADDRESS, 
    DATA,
    CONTROL
};

__xdata uint8_t hexData[16];

typedef __xdata union addr_t
{
  uint32_t laddr;
  uint16_t waddr[2];
} addr_t;

addr_t Addr;

static uint8_t hex2n(uint8_t symb)
{
  uint8_t number=0;	
  if (symb < 'A') number = symb - '0';
  else number = symb  - 'A' + 10;
  return (number & 0x0F);
}


void HexParser(void)
{
  uint8_t state=WAIT_FOR_START;
  uint8_t symbol;
  uint8_t count;
  uint8_t dataCnt;  
  uint16_t address;
  uint8_t type;  
  uint8_t data;  
  uint8_t dataPointer;  
  uint8_t ks;
  uint8_t charCount;

  while(1)
  {
    symbol = uartRx();
	switch(state)
	{
	  case WAIT_FOR_START:
	    if (symbol==':') 
	    {
		  state++;
          charCount=2;
          count=0;
	  	}
        break;
	  case COUNT:
        count <<= 4;
        count += hex2n(symbol);
	    if(--charCount==0)
        {
          state++;
          ks = count;
          charCount=4;
          address =0;
        }
        break; 
      case ADDRESS:
        address <<= 4;
        address += hex2n(symbol);
	    if(--charCount==0)
        {
          state++;
          ks += (address>>8);
          ks += (address & 0x0FF);
          Addr.waddr[0] = address;
          type = 0;
          charCount=2;
        }
        break;
      case TYPE:
        type <<= 4;
        type += hex2n(symbol);
        if(--charCount==0)
        {
          ks += type;
          state++;
          if(type==4)
          {
            charCount=4;
            address=0;
          }
          else
          {
            state++;
            if(type==0)
            {
              dataPointer=0;
              data=0;
              dataCnt = count;
              charCount=2;
            }
            else
            {
              data=0;
              charCount=2;                
              state++;     // CONTROL
            }
          } 
        }
        break; 
      case EXT_ADDRESS:        
        address <<= 4;
        address += hex2n(symbol);
		if(--charCount==0)
        {
          state++;
          state++; 
          ks += address>>8;
          ks += address & 0x0FF;
          Addr.waddr[1] =address;
          charCount=2;
          data=0;
        }
        break; 
      case DATA:        
        data <<= 4;
        data += hex2n(symbol);
        if(--charCount==0)
        {
          ks += data;
          hexData[dataPointer++]=data;
          charCount=2;
          if (--dataCnt==0) state++;              
          data=0;
          charCount=2;
        }
        break; 
      case CONTROL:        
        data <<= 4;
        data += hex2n(symbol);
        if(--charCount==0)
        {        
          ks += data;
          if((type==0) && (count>0) && (ks==0))  eepromWrite(Addr.laddr, hexData, count); 
          pr("%d", ks);          
          state = WAIT_FOR_START;
        }
        break;                   
      default:
        state = WAIT_FOR_START;      
        break;
    } 
  }
}

import sys
import os
from PIL import Image

#filename1 = "matroskin.png"

#extended address line (0x04)
def ExtLine(Address):
    HexLine =":02000004%04X" % Address
    ks = 2+4+((Address>>8)&0xFF) + (Address&0xFF)
    ks = (1 + ~ks) & 0xFF
    HexLine +="%02X\n" % ks
    return HexLine
    
def DataLine(Address,  Data):    
    blockLength = len(Data)
    ks = blockLength+((Address>>8)&0xFF) + (Address&0xFF)
    HexLine =":%02X%04X00" % (blockLength, Address)
    for i in range(0, blockLength):
        HexLine +="%02X" % Data[i]
        ks += Data[i]
    ks = (1 + ~ks) & 0xFF    
    HexLine +="%02X\n" % ks        
    return HexLine

if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Usage: python3 %s image_name address_hex" % (sys.argv[0]))
        sys.exit(-1)

    im = Image.open(sys.argv[1])
    pix = im.load()
    filename = os.path.splitext(sys.argv[1])[0]
    f = open(filename + ".txt", "w+")
    
    Address = int(sys.argv[2],16)
    
    ExtAddress = Address >> 16
    #extended address
    HexLine=ExtLine(ExtAddress)
    f.write(HexLine)
    #
    #print ("ks=%02X" % ks)    
    #print ("address=%06X" % extAddress)
    #print(HexLine)
    dataCounter=0
    blockAddress=Address
    Data=[]
    byte=0   
    bitCounter=8
    for y in range(0, im.size[1]):
        for x in range(0, im.size[0]):
            byte = byte<<1
            r, g, b = pix[x, y]        
            gray = 0.299*r + 0.587*g + 0.114*b
            if (gray<127):
                byte = byte | 1
            bitCounter -= 1 
            if(bitCounter==0): 
                bitCounter=8   
                Data.append(byte)
                dataCounter += 1
                Address += 1
                newExtAddr = Address>>16
                if (newExtAddr!=ExtAddress):
                    Line = DataLine(blockAddress & 0xFFFF,  Data)
                    f.write(Line)
                    ExtAddress = Address >> 16
                    Line = ExtLine(ExtAddress)
                    f.write(Line)
                    blockAddress = Address
                    Data.clear()
                    dataCounter = 0
                    
                elif (dataCounter==16):
                    Line = DataLine(blockAddress & 0xFFFF,  Data)
                    blockAddress = Address
                    Data.clear()
                    dataCounter = 0 
                    f.write(Line)                   
                
                #f.write("%02X" % byte)                 
                byte = 0
    #tail?
    if (dataCounter!=0):
        Line = DataLine(blockAddress & 0xFFFF,  Data)
        f.write(Line)    
    Line =":00000001FF\n"
    f.write(Line) 
f.close()

import sys
import os
import serial
import time

SERIALPORT = "/dev/ttyUSB1"
BAUDRATE = 115200


if __name__ == "__main__":
    if len(sys.argv) != 2:
        print("Usage: python3 %s hex_file" % (sys.argv[0]))
        sys.exit(-1)
        
        
    filename = sys.argv[1]        
    f = open(filename, "r")        
    Lines = f.readlines()
    f.close()        
        
    try:        
        uart = serial.Serial(SERIALPORT, BAUDRATE)     
        uart.bytesize = serial.EIGHTBITS #number of bits per bytes
        uart.parity = serial.PARITY_NONE #set parity check: no parity
        uart.stopbits = serial.STOPBITS_ONE #number of stop bits
        uart.timeout = None          
        uart.xonxoff = False     #disable software flow control
        uart.rtscts = False     #disable hardware (RTS/CTS) flow control
        uart.dsrdtr = False       #disable hardware (DSR/DTR) flow control
        uart.writeTimeout = 0     #timeout for write    
       
        print("Connect to {}".format(uart.portstr))    
      
#    try:
#        uart.open()
   
    except serial.SerialException as e:
        print("Serial port error: ",str(e))
        exit()       
      
        
    if uart.isOpen():

        try:
            uart.flushInput() #flush input buffer, discarding all its contents
            uart.flushOutput()#flush output buffer, aborting current output

            for line in Lines:
                uart.write(str.encode(line))            
                print(line.strip())
                time.sleep(0.015)
            uart.close()

        except serial.SerialException as e:
            print("error communicating...: ", str(e))
            exit()   

    else:
        print("cannot open serial port ")

#!/usr/bin/env python3
import os
import cairosvg
from PIL import Image

for file in os.listdir('.'):
    if os.path.isfile(file) and file.endswith(".svg"):
        name = file.split('.svg')[0]
        
        cairosvg.svg2png(url=name+'.svg',write_to=name+'.png', output_height=128, output_width=128)
        img = Image.open(name+'.png')    
            
        # Transparence replace with white  
        if (img.mode=='RGBA'):            
            new_img = Image.new("RGBA", img.size, "WHITE")
            new_img.paste(img, mask=img)
            img = new_img
                       
        img = img.convert('1') # change to black and white image               
             
        if os.path.exists(name+'.bmp'): 
            os.remove(name+'.bmp')  
               
        img.save(name+'.bmp')           
        os.remove(name+'.png')