Тема может быть избита. не понимаю как оргнизовать работу UART по прерывания(+) Опции

[AlHakim]

Нашел примеры работы UART-a / которые выкладывал VAI? но у него используется только перрывание на прием. Я же хочу чтобы и на передачу и на прием работало по прерваниям

Мой код
в основной программе
Uart0PutChar(0x30); прерывание проходит
Uart0PutStr("qwe"); тут как карта ляжет, программа зацикливается
....
while(*str){
Uart0Tx.PtrWrByte = ++Uart0Tx.PtrWrByte & UART_BUFFER_MASK;
while (Uart0Tx.PtrWrByte == Uart0Tx.PtrRdByte) {} // программа зацикливается
Как я понимаю, происходит изменение указателя а в это время возникает прерывание на TX и указатель Uart0Tx.PtrRdByte принимает значение Uart0Tx.PtrWrByte

-----------------------------------------
Модуль Uart.c

Код

#pragma vector=USART0TX_VECTOR
__interrupt void irq_Uart0_Tx(void)
{
    if (Uart0Tx.PtrWrByte != Uart0Tx.PtrRdByte){
        Uart0Tx.PtrRdByte = ++Uart0Tx.PtrRdByte & UART_BUFFER_MASK;
        TXBUF0 = Uart0Tx.Buffer[Uart0Tx.PtrRdByte];
    }    //
    else{
         //
         // флаг на завершение Tx и необходимости переключится на прием
         //
//         if (EventFlags & fwRxWaitTime){
//             //bSwitchTxToRx = 1;                 // EventFlags |= fwSwitchTxToRx;
//             pRS485Tx = 0;                      // приемопередатчик на Rx
//         }

    }

#pragma vector=USART0RX_VECTOR
__interrupt void irq_Uart0_Rx(void)
{
    volatile char dummy;
    unsigned char RxData;

    if ( FE+PE+OE+BRK+RXERR ){                          // overflow or framing error -
        URCTL1 &= ~ (FE+PE+OE+BRK+RXERR);               // Clear error flags
        dummy = RXBUF0;                                 // dummy read to clear RXE flag
        }
    else{
         RxData = RXBUF0;                               // Read the received data
         if ((Uart0Rx.PtrWrByte + 1) != Uart0Rx.PtrRdByte){
            Uart0Rx.PtrWrByte = ++Uart0Rx.PtrWrByte & UART_BUFFER_MASK;
            Uart0Rx.Buffer[Uart0Rx.PtrWrByte] = RxData;
         }
    }
}

void Uart0PutChar(unsigned char TxData)
{
    Uart0Tx.PtrWrByte = ++Uart0Tx.PtrWrByte & UART_BUFFER_MASK;
    while (Uart0Tx.PtrWrByte == Uart0Tx.PtrRdByte) {
        //
        //  Сброс сторожевого таймера
        //
    }   // Wait for incomming data
    Uart0Tx.Buffer[Uart0Tx.PtrWrByte] = TxData;
    if  ((IFG1 & UTXIFG0) != UTXIFG0)           //    UART0_ENABLE_TX_INTERRUPT;
        IFG1 |= UTXIFG0;
}

void Uart0PutStr(unsigned char *str)
{
//    while(*str) Uart0PutChar(*str++);  //*s++=Tmpchar;
    while(*str){
        Uart0Tx.PtrWrByte = ++Uart0Tx.PtrWrByte & UART_BUFFER_MASK;
        while (Uart0Tx.PtrWrByte == Uart0Tx.PtrRdByte) {}   // Wait for incomming data

        Uart0Tx.Buffer[Uart0Tx.PtrWrByte] = *str++;
        if  ((IFG1 & UTXIFG0) != UTXIFG0)       //UART0_ENABLE_TX_INTERRUPT;
            IFG1 |= UTXIFG0;
    }
}

[AlHakim]

Похоже, что нет. Когда все передано прерывание передачи не запрещается и в буфер ничего не пишется. Таким образом программа постоянно после выхода из обработчика передачи снова попадает в него же.

я не утвержадю что рабочий на все 100, но повторного вхождни я впрерывание не проихслжит поскольку аппаратно в перрывание снимается бит UTXIFG0

Попробую использовать ваш код

вот еще возникла пролемка, если не сложно прокомментируйте

while(*str) Uart0PutChar(*str++); //*s++=Tmpchar;

странно передает н мой текст а часть его плюс мусор в отлачике по шагам проходит в run-time не всегда, чаще нет, видимо используемые регистры в перрывание изменяются

[Dog Pawlowa]

У меня рабочий код. Пока тут в грязь не ткнули
Пожалуйста
Линейный буфер, slave,
timer декрементируется 1мс, Service вставляется в основной цикл программы.

Код

//pc DOMP protocol
char rx_buf1[RxBufSize1];
char *rx_head1;
char *rx_tail1;
char tx_buf1[TxBufSize1];
char *tx_head1;
char *tx_tail1;
char domp_status;
char usart1_last_received;

void Uart1Configuration9600(void)
{
    U1CTL = CHAR+SWRST;            // 8-bit character and reset, 8N1
      U1TCTL = SSEL0+SSEL1;          // UCLK = SMCLK (8MHz)
      U1BR0 = 0x00;                  // 7372800/9600 - 768 or 300h
      U1BR1 = 0x03;                  //
      U1MCTL = 0x00;           
      ME2 &= ~(UTXE1 | URXE1);  // Disable USART1 TXD/RXD
       U1CTL &=~SWRST;                 // end of reset     
      rx_tail1=rx_buf1;
      rx_head1=rx_buf1;
      IE2 &= ~(URXIE1|UTXIE1);                // Disable USART1 RX and TX interrupt
}

void ClearTxBuffer1(void)
{     __disable_interrupt();    
    tx_tail1 = tx_head1 = tx_buf1;
    __enable_interrupt();
}

void ClearRxBuffer1(void)
{    rx_tail1 = rx_head1 = rx_buf1;
}

void EnableReceiver1 ( void )
{    ClearRxBuffer1();                //
  ME2|= URXE1;  //    receiver enable
  IE2|=URXIE1;        // receive interrupt enable
//    UCSR0A &= ~ ( 1 << RXC0 );        // set receiver empty bit
}    


void Uart1Configuration(void)
{ Uart1Configuration9600();
  tx_tail1 = tx_head1 = tx_buf1; // without interrupt enable
  EnableReceiver1();
}

void EnableTransmitter1 ( void )
{//    tx_tail1=tx_buf1;        // transmitt from beginning
  ME2|= UTXE1;  //    transmitter enable
    IFG2|=UTXIFG1; // set transmitter empty bit
  IE2|=UTXIE1;  //  transmitt interrupt enable
}



#pragma vector=UART1TX_VECTOR
__interrupt void USART1_transmit(void)
{     if ((domp_status==DompTransmitting) &&
     (tx_tail1<tx_head1))
        {      TXBUF1 =*tx_tail1;
            tx_tail1++;
        } else
        { IE2&=~UTXIE1;  //  transmitt interrupt disable
//      ME2&= UTXE1;  //    transmitter enable
      IFG2&=~UTXIFG1; // clear transmitter empty bit
        domp_status_timer = 2;
        domp_status = DompWaitReceiving;
    }
}


#pragma vector = UART1RX_VECTOR
__interrupt void USART1_receive(void)
{    
      usart1_last_received=U1RXBUF;
//    this two lines for Echo
//    TXBUF1 = b;
//    EnableTransmitter1();

      if (domp_status == DompWaiting)
    {    if (usart1_last_received == START_RX_CHAR)
        {    rx_head1 = rx_buf1;
            domp_status = DompReceiving;
        }
        else return;
    }
    if (domp_status == DompReceiving)
    {    *rx_head1 = usart1_last_received;
        rx_head1 ++;
        if (rx_head1 >= rx_buf1+RxBufSize1)
        domp_status=DompProcessing;
        if (usart1_last_received == END_RX_CHAR) domp_status=DompProcessing;

    }
}
/*
#pragma vector = USART0_TXC_vect
__interrupt void USART_transmit_complete(void)
{    usart_status_timer = 2;
    domp_status = UsartWaitReceiving;
}
*/

void DompService(void)
{    char b;
    switch (domp_status)

{    case DompUnconfigured:    
            Uart1Configuration();
//            SetReceiveDirection;
            ClearRxBuffer1();
            domp_status = DompWaiting;
      break;
    case DompWaiting:    
            domp_status_timer = 2000; // time for receiving
            break;
    case DompReceiving:
            if (!domp_status_timer) domp_status = DompUnconfigured;
            break;
    case DompProcessing:    
            b = MyCorrectCommand();
            if (!b)
            {    ExecuteCommandAndPrepareAnswer();
        domp_status = DompWaitTransmitting;
                domp_status_timer=5;
            }
            else     
            {    
        domp_status = DompWaitReceiving;
                domp_status_timer = 1;
            }
            break;
    case DompWaitTransmitting:    
            if     (domp_status_timer == 0)
            {    
        SetTransmitDirection;
                domp_status = DompTransmitting;
                domp_status_timer = 500;
        tx_tail1=tx_buf1;
//                EnableTransmitter1();     !!!
            }
            break;
    case DompTransmitting:    
            if (!domp_status_timer)
              {    domp_status = DompUnconfigured; }
    
            break;
    case DompWaitReceiving:
            if (domp_status_timer == 0)
            {    ClearRxBuffer1();
              SetReceiveDirection;
                domp_status = DompWaiting;//UsartReceiving;
            }
            break;
    }                        
}

char Usart1EchoTest(void)
{   char b;
    Delay(2);
    b=rtc_data[rtcSecond];
    TXBUF1=b;
    ME2|= UTXE1|URXE1;
    Delay(10);
    if (U1RXBUF==b) b=1;
    else b=0;
    domp_status=DompUnconfigured;
    return(b);
}

Жуткие следы выбора размера табуляций и портирования с АВР

Сообщение отредактировал Dog Pawlowa - Jan 8 2007, 15:44