/**************************�����������**************************************/
#include "Common.h"

uint8_t   RSB_P;
uint8_t   RX_BUF[cnRSBufLen];    //���ڽ��ջ�����
uint8_t   TX_BUF[cnRSBufLen];    //���ڷ��ͻ�����
//ACK��������
#pragma INTO_ROM
const uint8_t CommandACK[5] =
{
  cnUASTHandH,	  // ���ڽ�����Ϣͷ��λ
  cnUASTHandL,  	// ���ڽ�����Ϣͷ��λ
  2,
  comACK,   	// ACK
  (uint8_t)(2 + comACK),
};
//NCK��������
#pragma INTO_ROM
const uint8_t CommandNCK[5] =
{
  cnUASTHandH,	 // ���ڽ�����Ϣͷ��λ
  cnUASTHandL,   // ���ڽ�����Ϣͷ��λ
  2,
  comNCK,   // NACK
  (uint8_t)(2 + comNCK),
};
//---------------------------------------------------------------------------
//��д�����Ӧ��RAM�����׵�ַ��
#pragma INTO_ROM

const uint8_t *CommandRAMIF[16] 	=
{
  (uint8_t *)0,
  (uint8_t *)0,
  (uint8_t *) &CSBFrJDTB[1],	  //��Ų��ܶ� ���ٱ�
  (uint8_t *) &ZSBFrJDTB[1],    //��Ų��ܶ� ת�ٱ�
  (uint8_t *)0,//&KPuls_cs,     //��Ų��ܶ�
  (uint8_t *)0,			            //��Ų��ܶ�
  (uint8_t *) &SUIBVJDTB[0],    //��Ų��ܶ� ˮ�±�
  (uint8_t *) &YOUBVJDTB[0],    //��Ų��ܶ� ȼ�ͱ�
  (uint8_t *)0,        		      //
  (uint8_t *)0,                 //
  (uint8_t *)0,      		        //
  (uint8_t *)0,//&CSB_SS_FrHL,  //��Ų��ܶ�
  (uint8_t *)0,//&ZSB_SS_FrHL,  //��Ų��ܶ�
  (uint8_t *)0,//&SBInputV,     //��Ų��ܶ�
  (uint8_t *)0,//&YBInputV,	  	//��Ų��ܶ�
  (uint8_t *)0,//&CJINF[0]      //��Ų��ܶ�
};
/**************************************************
�򴮿ڷ���1���ֽ�����
***************************************************/
void SendByteToUART(uint8_t myByte)
{
  wdt_reset();                  //��λ���Ź���ʱ��
  while (SCI0SR1_TDRE == 0);	  //�ȴ����ͻ�������
  SCI0DRL = myByte;
}
/**************************************************
�򴮿ڷ���1���ֽ�����(���ڵ���)
***************************************************/
void SendWordToUART(uint16_t myWord)
{
  uint8_t *mP;
  mP = (uint8_t *)&myWord;
  SendByteToUART(mP[0]);
  SendByteToUART(mP[1]);
}
/**************************************************
��ROM�е�һ�����ݴӴ��ڷ��ͳ�ȥ
***************************************************/
void SendRomStrToUART(uint8_t *myROMADR, uint8_t mDataLen)
{
  uint8_t i;
  for (i = 0; i < mDataLen; i++)
  {
    SendByteToUART(myROMADR[i]); //�򴮿ڷ���1���ֽ�����
  }
}
/**************************************************
��������ACK
***************************************************/
void SendACKToSBEI(void)
{
  SendRomStrToUART((uint8_t *)CommandACK, sizeof(CommandACK)); //��������ACK
}
/**************************************************
//��ʼ�����ڽ��ճ���
***************************************************/
void InitUARTRecvP(void)
{
  cli();                        //��ֹȫ���ж�
  RSB_P = 0;
  sei();                        //��ȫ���ж�
}
/**************************************************
���ڽ��ճ���(��19200��������.�������ò���)
����:=1��ʾ�յ�һ֡����
***************************************************/
INT8U UARTRecvieP(void)
{
  if ((RSB_P >= 1) && (RX_BUF[0] != cnUASTHandH))
    goto UARTRciP1;

  if ((RSB_P >= 2) && (RX_BUF[1] != cnUASTHandL))
    goto UARTRciP1;

  if ((RSB_P >= 3) && (RX_BUF[2] > cnRSDatLen))
    goto UARTRciP1;

  if (RSB_P >= (RX_BUF[2] + 3))
    return 1;
  else
    return 0;
  
UARTRciP1:
  InitUARTRecvP();              //��ʼ�����ڽ��ճ���
  return 0;
}
/*****************************************************************************
 �жϴ��ڽ��ܻ������Ƿ��յ���ȷ������
 ����:=0��ʾ������ȷ,COPY���ݵ����ͻ�����,�Һ����Զ���ջ�����,�����¿�ʼ����
      =1��ʾ���ݲ���ȷ,�Һ����Զ���ջ�����,�����¿�ʼ����
      =2��ʾû���յ�����
*****************************************************************************/
INT8U RSSRecivJudge(void)
{
  INT8U i;
  INT8U mCC = 0;

  if (!UARTRecvieP())                    //�������յ�һ֡����
    return 2;                            //no

  for (i = 0; i < RX_BUF[2]; i++)
    mCC = mCC + RX_BUF[2 + i];

  if (mCC == RX_BUF[RX_BUF[2] + 2])
  {
    for (i = 0; i < cnRSBufLen; i++)     //COPY���ڽ��ջ��������ݵ����ڷ��ͻ�����
      TX_BUF[i] = RX_BUF[i];

    InitUARTRecvP();                     //��ʼ�����򿪴��ڽ��ճ���
    return 0;
  }
  else
  {
    InitUARTRecvP();                    //��ʼ�����򿪴��ڽ��ճ���
    return 1;
  }
}
/***************************************************
���ݷ��ͻ���������������,���,�����ֽ�������RAM�׵�ַ
���:���ͻ���������
***************************************************/
INT8U *JSRAMADRGJLXN(void)
{
  return  TX_BUF[4] * TX_BUF[5] + (INT8U *)CommandRAMIF[TX_BUF[3] & 0x0F];
}
/***************************************************
���������������Ķ����������
���:���������ڷ��ͻ�����
***************************************************/
void ReadDataCOMPRG(void)
{
  INT8U i;
  INT8U *pRAMAdr;
  
  TX_BUF[2] = TX_BUF[2] + TX_BUF[5];
  pRAMAdr = JSRAMADRGJLXN();                //���ݷ��ͻ���������������,���,�����ֽ�������RAM�׵�ַ
  
  for (i = 0; i < TX_BUF[5]; i++)
    TX_BUF[6 + i] = *(pRAMAdr + i);
  JSCCSendDataToYQ();                       //���㷢�ͻ���������CC���������ݵ�����
}
/***************************************************
���㷢�ͻ���������CC���������ݵ�����
***************************************************/
void JSCCSendDataToYQ(void)
{
  INT8U i;
  INT8U mCC = 0;

  for (i = 0; i < TX_BUF[2]; i++)
    mCC = mCC + TX_BUF[2 + i];

  TX_BUF[TX_BUF[2] + 2] = mCC;

  for (i = 0; i < (TX_BUF[2] + 3); i++)
    SendByteToUART(TX_BUF[i]);
}
/***************************************************
����������������д���������
���:���������ڷ��ͻ�����
(ע:�����,д��,ת�ٱ�,��,ˮ��,��Ҫ���±���Ŀ��Ƕ�
***************************************************/
void WriteDataCOMPRG(void)
{
  INT8U i;
  INT8U *pRAMAdr;
  INT8U mTPE;

  pRAMAdr = JSRAMADRGJLXN();                //���ݷ��ͻ���������������,���,�����ֽ�������RAM�׵�ַ

  for (i = 0; i < TX_BUF[5]; i++)
    *(pRAMAdr + i) = TX_BUF[6 + i];

  mTPE = TX_BUF[3] & 0x0F;

  if (mTPE == 2)          //
    STEPPER_MOTOR_0_DST_STEP = *((INT16U *)(pRAMAdr + 2)); 
  if (mTPE == 3)          //
    STEPPER_MOTOR_3_DST_STEP = *((INT16U *)(pRAMAdr + 2)); 
  if (mTPE == 6)          //                         
    STEPPER_MOTOR_1_DST_STEP = *((INT16U *)(pRAMAdr + 2));   
  if (mTPE == 7)          //                           
    STEPPER_MOTOR_2_DST_STEP = *((INT16U *)(pRAMAdr + 2));   
}