level4.c

EM推出的可读写卡片EM4469

  if (uart_state == UART_WAIT_ERROR_SENT) {
    uart_in_read = uart_in_write;      //dropped =async
    return result;
  }

  if (uart_state == UART_VALID) {
    result = ParseMessage();            //parse message and commit the command
    uart_in_read = ptr;
    return result;
  }
  return result;
}


// ==================================================================
// parses valid message format and checks size according to the command type

uint8_t ParseMessage(void) {

  uint8_t byte = 0;
  uint8_t ptr = uart_in_read;
  uint8_t ptr2 = 0, c;
  uint8_t temp_buffer[UART_IN_BUFFER_SIZE];
  
  //compute checksum
  byte = uart_in_buffer[ptr];

  while (ptr != uart_in_end) {
    c = uart_in_buffer[ptr++];
    if(ptr == UART_IN_BUFFER_SIZE) 
      ptr = 0;

    byte ^= c;
    temp_buffer[ptr2++] = c;    
  }

  if (byte == 0) {  //checksum ok

    byte = temp_buffer[2];

    switch(byte) {

      case 0x80 :                               //Read Tag Memory
        if (uart_read_msg_bytes != 4)
          return ERR_UART_INTERBYTE_ERR;
        read_tag_memory_word_address = temp_buffer[3];
        break;

      case 0x81 :                               //Write Tag 
        if (uart_read_msg_bytes != 8)
          return ERR_UART_INTERBYTE_ERR;
        write_tag_memory_word_address = temp_buffer[3];
        write_tag_memory_word_low = ((uint16_t)temp_buffer[5] << 8) + temp_buffer[4];
        write_tag_memory_word_hi  = ((uint16_t)temp_buffer[7] << 8) + temp_buffer[6];
        break;

      case 0x82 :                               //Login
        if (uart_read_msg_bytes != 7)
          return ERR_UART_INTERBYTE_ERR;
        write_tag_memory_login_low = temp_buffer[3];
        write_tag_memory_login_low = (write_tag_memory_login_low << 8) + temp_buffer[4];
        write_tag_memory_login_hi  = temp_buffer[5];
        write_tag_memory_login_hi  = (write_tag_memory_login_hi << 8) + temp_buffer[6];
        break;

      case 0x83 :                               //Disable
        if (uart_read_msg_bytes != 3)
          return ERR_UART_INTERBYTE_ERR;
        break;

      case 0x84 :                               //Forward link
        if (uart_read_msg_bytes != 4)
          return ERR_UART_INTERBYTE_ERR;
        write_tag_memory_forward_link = temp_buffer[3];
        break;

      case 0x85 :                               //Read Only Continuous mode
        if (uart_read_msg_bytes != 3)
          return ERR_UART_INTERBYTE_ERR;
        break;

      case 0x86 :                               //Read Only Continuous mode
        if (uart_read_msg_bytes != 3)
          return ERR_UART_INTERBYTE_ERR;
        break;

      case 0xF8 :                               //Send Capture Data
        if (uart_read_msg_bytes != 3)
          return ERR_UART_INTERBYTE_ERR;
        break;

      case 0xF9 :                               //Toggle debug mode
        if (uart_read_msg_bytes != 4)
          return ERR_UART_INTERBYTE_ERR;
        debug_mode = temp_buffer[3];
        break;

      case 0xFA :                               //Forward link pulses tuning
        if (uart_read_msg_bytes != 0xA)
          return ERR_UART_INTERBYTE_ERR;
        fwd_set_0 = temp_buffer[3];
        fwd_set_A = temp_buffer[4];
        fwd_set_B = temp_buffer[5];
        fwd_set_C = temp_buffer[6];
        fwd_set_D = temp_buffer[7];
        fwd_set_E = temp_buffer[8];
        fwd_set_F = temp_buffer[9];
        break;

      case 0xFB :                               //Reader Read Configuration
        if (uart_read_msg_bytes != 3)
          return ERR_UART_INTERBYTE_ERR;
        break;

      case 0xFC :                               //Reader Write Configuration
        if (uart_read_msg_bytes != 7)
          return ERR_UART_INTERBYTE_ERR;
        config_data_rate = temp_buffer[3] & 0x3F;
        config_encoder = ((temp_buffer[4] & 0x03) << 2) | (temp_buffer[3] >> 6);
        config_psk_carrier = (temp_buffer[4] >> 2) & 0x03;
        config_delayed = (temp_buffer[4] >> 4) & 0x03;
        config_lwr = ((temp_buffer[5] & 0x03) << 2) | (temp_buffer[4] >> 6);
        config_raw = (temp_buffer[5] >> 6) & 0x01;
        config_forward_link = (temp_buffer[5] >> 3) & 0x01;
        config_write_conf = (temp_buffer[5] >> 2) & 0x01;
        break;

      case 0xFE :                               //Switch Coil
        if (uart_read_msg_bytes != 4)
          return ERR_UART_INTERBYTE_ERR;
        switch_coil_byte = temp_buffer[3];
        break;

      case 0xFD :                               //Reader Status
        if (uart_read_msg_bytes != 3)
          return ERR_UART_INTERBYTE_ERR;
        break;

      default :                                 //Unknown command
        return ERR_UART_UNKNOWN_CMD;
    }

    //command was parsed successfully

    uart_command = byte;
    return UART_MESSAGE_OK;
  } else {   //bad checksum
    return ERR_UART_BAD_CRC;
  }
}


// ==================================================================
// send response 

void SendResponse(uint8_t ack) {

  if (ack == 0) SetLEDOff(); else SetLEDOn();

  while ( (UCSRB & (1<<UDRIE)) != 0 )            //stop message emmision until pending UART tranfer finishes
    {}

  uart_out_end = uart_out_write;
  sbi(UCSRB, UDRIE);
}

// ==================================================================
// ==================================================================
// Response and error emmision
// ==================================================================

void EmmitError(uint8_t err) {

  IncWriteOut(0x02);
  IncWriteOut(0x04);
  IncWriteOut(0);             //general error message
  IncWriteOut(err); 
  IncWriteOut(err ^ 0x04);
  IncWriteOut(0x03);
  SendResponse(0xFF);
}

// ==================================================================

void FormatResponse_AddrWord(uint8_t ack, uint8_t cmd, uint8_t address, uint16_t word_low, uint16_t word_hi) {

  IncWriteOut(0x02);
  IncWriteOut(0x09);
  IncWriteOut(cmd);
  IncWriteOut(ack);
  IncWriteOut(address);
  IncWriteOut((uint8_t)word_low);
  IncWriteOut(word_low>>8);
  IncWriteOut((uint8_t)word_hi);
  IncWriteOut(word_hi>>8);

  IncWriteOut(0x09 ^ cmd ^ ack ^ address ^ (word_low & 0xFF) ^
                         (word_low >> 8) ^ (word_hi & 0xFF) ^
                         (word_hi >> 8) );
  IncWriteOut(0x03);
  SendResponse(ack);
}

// ==================================================================

void FormatResponse_Short(uint8_t cmd, uint8_t ack) {

  IncWriteOut(0x02);
  IncWriteOut(0x04);
  IncWriteOut(cmd);
  IncWriteOut(ack);
  IncWriteOut(0x04 ^ cmd ^ ack);  
  IncWriteOut(0x03);
  SendResponse(ack);
}

// ==================================================================

void FormatResponse_Word(uint8_t ack, uint8_t cmd, uint16_t word_low, uint16_t word_hi) {

  IncWriteOut(0x02);
  IncWriteOut(0x08);
  IncWriteOut(cmd);
  IncWriteOut(ack);
  IncWriteOut((uint8_t)word_low);
  IncWriteOut(word_low>>8);
  IncWriteOut((uint8_t)word_hi);
  IncWriteOut(word_hi>>8);

  IncWriteOut(0x08 ^ cmd ^ ack ^
                         (word_low & 0xFF) ^ (word_low >> 8) ^
                         (word_hi & 0xFF) ^ (word_hi >> 8));

  IncWriteOut(0x03);
  SendResponse(ack);
}

// ==================================================================

void FormatResponse_Status(uint8_t ack) {

  IncWriteOut(0x02);
  IncWriteOut(0x08);
  IncWriteOut(0xFD);
  IncWriteOut(ack);

  IncWriteOut(READER_RELEASE);
  IncWriteOut(READER_DATE | ((READER_MONTH & 0x07) << 5));
  IncWriteOut((READER_MONTH >> 3) | (READER_YEAR << 1));

  IncWriteOut(READER_FAMILY);   //Read Only firmware
  IncWriteOut(0x08 ^ 0xFD ^ ack ^ READER_RELEASE ^ (READER_DATE | ((READER_MONTH & 0x07) << 5)) ^ ((READER_MONTH >> 3) | (READER_YEAR << 1)) ^ READER_FAMILY);

  IncWriteOut(0x03);
  SendResponse(ack);
}

// ==================================================================

void FormatResponse_AutoDefaultRead(uint8_t ack, uint8_t cmd, uint8_t type, uint32_t byte, uint32_t word) {

  uint8_t checksum = 0, i;

  IncWriteOut(0x02);
  IncWriteOut(0x0A);
  IncWriteOut(cmd);
  IncWriteOut(ack);
  IncWriteOut(type);
  IncWriteOut(byte);
  checksum = 0x0A ^ cmd ^ ack ^ type ^ byte;

  for(i=0;i<4;i++) {
    IncWriteOut(word >> 24);
    checksum ^= word >> 24;
    word <<= 8;
  }

  IncWriteOut(checksum);
  IncWriteOut(0x03);
  SendResponse(ack);
}