我写的程序怎么只有在复位的时候主机才能收到数据啊。

只看该作者 · 2014-7-22 13:14

我写的程序怎么只有在复位的时候主机才能收到数据啊，我的是从机。怎么查错误

只看该作者 · 2014-7-22 14:55

先看一下你从机能收到主机的信号吗

只看该作者 · 2014-7-22 15:26

南宫云明发表于 2014-7-22 14:55
先看一下你从机能收到主机的信号吗

能，也是就能接收到一帧数据，后来发的就收不到了，怎么回事

只看该作者 · 2014-7-22 15:52

冰冷的游客发表于 2014-7-22 15:26
能，也是就能接收到一帧数据，后来发的就收不到了，怎么回事

后来收不到的时候，你能确定主机已经发出来了吗，如果发出来了，你没收到，说明你接收程序有问题。看一下接收程序，或者接收之后处理的代码有什么问题

只看该作者 · 2014-7-22 15:54

通信的程序调试的时候先保证一方没问题，再调试另外一方，否则都不知道是哪个单片机出问题

只看该作者 · 2014-7-22 15:55

南宫云明发表于 2014-7-22 15:52
后来收不到的时候，你能确定主机已经发出来了吗，如果发出来了，你没收到，说明你接收程序有问题。看一下 ...

那行，我先看看这部分，搞不定再来问，谢谢了

只看该作者 · 2014-7-22 16:21

是不是收到一次后，再也走不到这块程序了，
逻辑错误，或者中断配的有问题

只看该作者 · 2014-7-22 17:05

后学发表于 2014-7-22 16:21
是不是收到一次后，再也走不到这块程序了，
逻辑错误，或者中断配的有问题 ...

我要是仿真从机的话，能收到第一帧数据然后我给主机回个数据，后面主机回的数据就收不到了。我要是仿真主机的话，只有复位一下从机才能收到从机发的数据，而且主机也给从机回数据，这时仿真从机就能收到这帧数据。数据收发是“应答式”的

只看该作者 · 2014-7-22 17:07

南宫云明发表于 2014-7-22 15:54
通信的程序调试的时候先保证一方没问题，再调试另外一方，否则都不知道是哪个单片机出问题 ...

对啊，主机不是我弄的，我就搞个从机，那边代码太多看不明白

1万 · 2014-7-22 17:18

说不下没有
while(1)
{
...
}

只看该作者 · 2014-7-23 08:17

这个问题嘛，需要进行两个方面的查寻，首先确定是不是能发出数据，然后再确定是不是能正确的接收数据，至于怎么去测，自己想想吧，我也不知道具体情况……

1万 · 2014-7-23 08:30

主机是什么，电脑？
楼主上程序吧，猜问题比较困难...

只看该作者 · 2014-7-23 10:37

ningling_21 发表于 2014-7-23 08:30
主机是什么，电脑？
楼主上程序吧，猜问题比较困难...

程序比较长，贴那一段啊

只看该作者 · 2014-7-23 10:41

就贴发送和接收的吧，其他配置的以及其他子函数不用
接收中断
可能是你程序逻辑上的错误

1万 · 2014-7-23 10:46

冰冷的游客发表于 2014-7-23 10:37
程序比较长，贴那一段啊

发送的部分，和接收的中断部分就可以了...

只看该作者 · 2014-7-23 10:47

ningling_21 发表于 2014-7-23 08:30
主机是什么，电脑？
楼主上程序吧，猜问题比较困难...

void USCI_A0_Init(void)
{
  AD421_OutCrrent(4000);
  A5191_RST_L;
  Delayus(10);
  A5191_RST_H;

  P3SEL |= BIT4 + BIT5;
  UCA0CTL1 |= UCSWRST;
  UCA0CTL0 |=UCPEN;
  UCA0CTL1 |= UCSSEL_1;       //ACLK
  UCA0BR0 = 0x1B;                      //32768/1200 =27.3
  UCA0BR1 = 0x00;                      //
  UCA0MCTL = UCBRS1+UCBRS0;             // Modulation UCBRSx =3
  UCA0CTL1 &= ~UCSWRST;
  IFG2 &=~(UCA0RXIFG+UCA0TXIFG);
  IE2 |= UCA0TXIE + UCA0RXIE;
  USCIA0_RX_EN;


  S_HartData.C_MayRxHead = 0;
  S_HartData.C_RxHead = 0;
  S_HartData.C_RxOK = 0;
  S_HartData.C_TxOK = 0;
  S_HartData.I_RxCtr = 0;
  S_HartData.I_RxTotalCtr = 0;
  S_HartData.C_ModbusRxCtr = 0;
  S_HartData.I_TxCtr = 0;
  S_HartData.I_TxTotalCtr = 0;
}
//发送数据
void USCIA0_Send(char *p_data,unsigned int i_length,unsigned int i_time)
{
unsigned  int i_ctr = 0;

S_Assist.C_CircutBusyFlag = 1;
USCIA0_TX_EN;
Delayms(1);
S_HartData.I_RxCtr = 0;
S_HartData.I_RxTotalCtr = 0;
S_HartData.C_RxOK = 0;
S_HartData.I_TxCtr = 0;
S_HartData.C_TxOK = 0;
S_HartData.I_TxTotalCtr = i_length+4;
memset(&S_HartData.C_TxBuf[0],0xFF,4);
memcpy(&S_HartData.C_TxBuf[4],p_data,i_length);
UCA0TXBUF =  S_HartData.C_TxBuf[0];
do
{
   Delayms(1);
      i_ctr++;
}while(!S_HartData.C_RxOK && i_ctr<=i_time);
S_Assist.C_CircutBusyFlag = 0;
}

#pragma vector=USCIAB0TX_VECTOR
__interrupt void USCI0TX_ISR(void)
{


   if(S_HartData.I_TxCtr >= S_HartData.I_TxTotalCtr)
   {
      S_HartData.I_TxCtr = 0;
      S_HartData.I_TxTotalCtr = 0;
      S_HartData.C_ModbusTxCtr = 0;
      S_HartData.C_TxOK = 1;

      Delayms(1);
      USCIA0_RX_EN;

   }
   else
   {
      S_HartData.I_TxCtr++;
      UCA0TXBUF = S_HartData.C_TxBuf[S_HartData.I_TxCtr];
   }

}

unsigned char C_Rx_FF_Ctr = 0;
unsigned char C_Rx_Total_Ctr = 0;

//--接收中断函数----
#pragma vector=USCIAB0RX_VECTOR
__interrupt void USCI0RX_ISR(void)
{

         S_HartData.C_ModbusRxCtr = 0;
         if(S_HartData.C_MayRxHead)
         {
            S_HartData.C_MayRxHead = 0;
            S_HartData.C_RxHead = 1;
            S_HartData.I_RxCtr = 0;
         }
         if(S_HartData.C_RxHead)
         {
            S_HartData.C_RxBuf[S_HartData.I_RxCtr++] = UCA0RXBUF;
            if(S_HartData.I_RxCtr >= MAX_USCI_RX_CTR)
            {
                  S_HartData.I_RxCtr = 0;
            }
         }



} //这是中断接收发送

//定时器初始化
void timerInit(void)
{

  TA0CTL = TASSEL_2 + MC_1 + TACLR;  //SMCLK,CONTMODE,自由运行，产生各种中断
  TA0CCTL0 = CCIE;
  TACCR0 = 33 - 1;
}

unsigned long L_Test = 0;

#pragma vector=TIMER0_A0_VECTOR
__interrupt void Timer_A0(void)
{
// TACCR0 += 32;

  TA0R = 0;
L_Test++;

if(S_HartData.C_TxOK == 1)
{
      if(++S_HartData.C_ModbusTxCtr >= 6)
      {
         USCIA0_RX_EN;
         S_HartData.C_TxOK = 0;
      }
}
if(++S_HartData.C_ModbusRxCtr >= 12)
{
      if(S_HartData.C_RxHead == 1)
      {
         S_HartData.C_RxHead = 0;
         S_HartData.I_RxTotalCtr = S_HartData.I_RxCtr;
         S_HartData.C_RxOK = 1;
      }
      S_HartData.C_MayRxHead = 1;
      S_HartData.C_ModbusRxCtr = 0;
}
}//定时器的

typedef struct {
unsigned char C_MayRxHead;                //是否可以接收下一帧数据
unsigned char C_RxHead;                   //是否接收到数据头
unsigned char C_RxOK;                      //是否接收完一帧
unsigned char C_ModbusRxCtr;             //距离接收最后一个字节的时间
unsigned int  I_RxCtr;                   //接收计数器
unsigned int  I_RxTotalCtr;                //总接收字节数
char C_RxBuf[MAX_USCI_RX_CTR];             //接收Buf

unsigned char C_TxOK;                      //是否发送完一帧
unsigned char C_ModbusTxCtr;             //距离发送最后一个字节的时间
unsigned int I_TxCtr;                   //发送计数器
unsigned int I_TxTotalCtr;                //总发送字节数
char C_TxBuf[MAX_USCI_TX_CTR];             //发送Buf
}USCI_Struct;//结构体
帮看看把大神