hms800.c

LP830 无线识别卡 读写程序demo

    }
    *address_ptr++ = MSG_TERM;
    *address_ptr++ = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(build_buf, (data_size * 2) + 6);
}
  
// ****************************************************************************
// Non-Contiguous Read/Write Configuration Command 
// Input:        Time out value of some type.  It is sent in the command packet.
//               Pointer to two buffers, that go in the read/write command.
//               Number of bytes in each buffer.
// Return:       NONE.
// Side effects: A packet is queued to be sent.
void NCConfTx(WORD timeout, BYTE *read_buf, WORD read_size, BYTE *write_buf,
              WORD write_size) 
{
    BYTE *tx_buf;
    WORD buf_size, ii;
    
    buf_size = read_size * 2 + write_size * 2 + 10; 
    tx_buf = build_buf;
    ClearBuf(tx_buf, buf_size);   // initialize buffer.

    *tx_buf++ = MSG_BEGIN;
    *tx_buf++ = CONF_NONCO;
    *tx_buf++ = (BYTE)(timeout / 256);
    *tx_buf++ = (BYTE)(timeout % 256);
    for(ii =0; ii < read_size; ii++)
    { 
        *tx_buf++ = *read_buf++;    // The address WORD
        *tx_buf++ = *read_buf++;    // has two bytes.
    }
    *tx_buf++ = 0xff;
    *tx_buf++ = 0xf0;
    for(ii = 0; ii < write_size; ii++) 
    { 
        *tx_buf++ = *write_buf++;   // The address WORD
        *tx_buf++ = *write_buf++;   // has two bytes.
    }
    *tx_buf++ = 0xff;
    *tx_buf++ = 0xf1;
    *tx_buf++ = MSG_TERM;
    *tx_buf++ = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(build_buf, buf_size);
}

// ****************************************************************************
// Transmit the Fill Command 
// Input:        Begin fill at what address in the tag?
//               How many bytes to fill with the data byte.
//               Antenna timeout time.
//               The data to be filled in the tag.
// Return:       None.
// Side effects: None.
void FillTx(WORD start_add, WORD data_size, WORD timeout, BYTE data)
{
    BYTE tx_buf[12];
    BYTE *data_ptr;
    WORD buf_size;
    
    data_ptr = tx_buf;
    buf_size = 12;

    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = FILL_TAG;
    *data_ptr++ = (BYTE)(start_add / 256);
    *data_ptr++ = (BYTE)(start_add % 256);
    *data_ptr++ = (BYTE)(data_size / 256);
    *data_ptr++ = (BYTE)(data_size % 256);
    *data_ptr++ = (BYTE)(timeout / 256);
    *data_ptr++ = (BYTE)(timeout % 256);
    *data_ptr++ = 0x00;
    *data_ptr++ = data;
    *data_ptr++ = MSG_TERM;
    *data_ptr = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, buf_size);
}  
 
// ****************************************************************************
// Transmit the Block Read Command 
// Input:        Begin reading at this start address in the tag.
//               Number of bytes to be read from tag.
//               Antenna timeout time.
// Return:       None.
// Side effects: None.
void BLReadTx(WORD start_add, WORD data_size, WORD timeout)
{
    BYTE tx_buf[10];
    BYTE *data_ptr;
    WORD buf_size;

    data_ptr = tx_buf;
    buf_size = 10;

    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = BLK_READ;
    *data_ptr++ = (BYTE)(start_add / 256);
    *data_ptr++ = (BYTE)(start_add % 256);
    *data_ptr++ = (BYTE)(data_size / 256);
    *data_ptr++ = (BYTE)(data_size % 256);
    *data_ptr++ = (BYTE)(timeout / 256);
    *data_ptr++ = (BYTE)(timeout % 256);
    *data_ptr++ = MSG_TERM;
    *data_ptr = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, buf_size);
}   

// ****************************************************************************
// Transmit Enter Colntinual Block Read mode Command 
// Input:        Begin read tag address.
//               Number of bytes to read from tag.
// Return:       None.
// Side effects: None.
void ContReadTx(WORD start_add, WORD data_size)
{
    BYTE tx_buf[8];
    BYTE *data_ptr;
    WORD buf_size;

    data_ptr = tx_buf;
    buf_size = 8;

    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = CON_READ_MODE;
    *data_ptr++ = (BYTE)(start_add / 256);
    *data_ptr++ = (BYTE)(start_add % 256);
    *data_ptr++ = (BYTE)(data_size / 256);
    *data_ptr++ = (BYTE)(data_size % 256);
    *data_ptr++ = MSG_TERM;
    *data_ptr = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, buf_size);
}

// ****************************************************************************
// Transmit Enter Continuous Block Read mode Command 
// Input:        Begin read tag address.
//               Number of bytes to read from tag.
// Return:       None.
// Side effects: None.
void ContinuousTx(WORD start_add, WORD data_size, BYTE Idelay)
{
    BYTE tx_buf[CONT_READ_CMDSIZE];
    BYTE *data_ptr;

    data_ptr = tx_buf;

    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = CONT_READ;
    *data_ptr++ = (BYTE)(start_add / 256);
    *data_ptr++ = (BYTE)(start_add % 256);
    *data_ptr++ = (BYTE)(data_size / 256);
    *data_ptr++ = (BYTE)(data_size % 256);
    *data_ptr++ = 0;    // Leading zero for Delay Between Identical Decodes.
    *data_ptr++ = Idelay;
    *data_ptr++ = MSG_TERM;
    *data_ptr = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, CONT_READ_CMDSIZE);
}

// ****************************************************************************
// Transmit a proteced mode Block Write Command 
// Input:        Begin write at this start address in the tag.
//               Number of bytes to be written from tag.
//               Antenna timeout time.
//               Pointer to the bytes to be written.
// Return:       None.
// Side effects: None.
void pro_BLWriteTx(WORD start_add, WORD data_size, WORD timeout, BYTE *data_buf)
{   // Preform a normal block write.
    do_BLWrite(start_add, data_size, timeout, data_buf, PRO_BL_WRITE);
}

// ****************************************************************************
// Transmit a COM2 read Command 
// Input:        Number of bytes to be written from tag.
//               command timeout time.
// Return:       None.
// Side effects: None.
void COM2_inpx_Tx(BYTE data_size, WORD timeout)
{
    BYTE tx_buf[COM_READX_SIZE];
    BYTE *data_ptr;

    data_ptr = tx_buf;
    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = COM2_READX;
    *data_ptr++ = 0;  // Leading zero of the lenght field.
    *data_ptr++ = data_size;
    *data_ptr++ = (BYTE)(timeout / 256);
    *data_ptr++ = (BYTE)(timeout % 256);
    *data_ptr++ = MSG_TERM;
    *data_ptr   = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, COM_READX_SIZE);
}

// ****************************************************************************
// Transmit a COM2 read line Command 
// Input:        Number of bytes to be written from tag.
//               Terminator byte value, for the end of the read.
//               command timeout time.
// Return:       None.
// Side effects: None.
void COM2_inpline_Tx(BYTE max_data_size, BYTE *terminator, WORD timeout)
{
    BYTE tx_buf[COM_READLN_SIZE];
    BYTE *data_ptr;

    data_ptr = tx_buf;
    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = COM2_READ_TERM;
    *data_ptr++ = 0;  // Leading zero of the lenght field.
    *data_ptr++ = max_data_size;
    *data_ptr++ = *terminator++;  // Leading zero of the terminator field.
    *data_ptr++ = *terminator;
    *data_ptr++ = (BYTE)(timeout / 256);
    *data_ptr++ = (BYTE)(timeout % 256);
    *data_ptr++ = MSG_TERM;
    *data_ptr   = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, COM_READLN_SIZE);
}

// ****************************************************************************
// Transmit a COM2 Write Command 
// Input:        Number of bytes to be written from tag.
//               Antenna timeout time.
//               Pointer to the bytes to be written.
// Return:       None.
// Side effects: None.
void write_com2tx(WORD data_size, BYTE *data_buf)
{
    BYTE *tx_buf;
    WORD ii;

    //allocate buffer and initialize them
    tx_buf = build_buf;
    ClearBuf(tx_buf, data_size*2 + 10);

    *tx_buf++ = MSG_BEGIN;
    *tx_buf++ = COM2_WRITE;
    tx_buf++;  // Leading zero of the lenght.
    *tx_buf++ = (BYTE)(data_size & 0xFF);
    for(ii = 0; ii < data_size; ii++) 
    {
        tx_buf++;
        *tx_buf++ = *data_buf++;
    }
    *tx_buf++ = MSG_TERM;
    *tx_buf = MSG_TERM;
   
#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(build_buf, (data_size * 2) + 6);
}

// ****************************************************************************
// Transmit Clear COM2 receive buffer Command 
// Input:        None.
// Return:       None.
// Side effects: None.
void COM2clearTx(void)
{
    BYTE tx_buf[6];
    BYTE *data_ptr;
    WORD buf_size;

    data_ptr = tx_buf;
    buf_size = 4;

    *data_ptr++ = MSG_BEGIN;
    *data_ptr++ = COM2_CLEAR;
    *data_ptr++ = MSG_TERM;
    *data_ptr = MSG_TERM;

#if ANTARES
    com_buf_clr();              // Clear out Anyares COM receive buffer.
#endif    
    SendStream(tx_buf, buf_size);
}

// ****************************************************************************
// Transmit a normal Block Write Command 
// Input:        Begin write at this start address in the tag.
//               Number of bytes to be written from tag.
//               Antenna timeout time.