Mam do zrealizowania transmisję half-duplex na uarcie przez moduł HC-12. Kombinowałem aby zrobić coś na kształt semafora binarnego, lecz niestety nie za bardzo mi to wychodzi. Korzystam z lekko zmodyfikowanej biblioteki obsługi portu szeregowego naskrobanej przy okazji czytania BB. Same funkcje obsługi semafora wyglądają następująco:
[syntax=c]#if USART_HALF_DUPLEX == 1
volatile semaphore_t semaphore_indicator;// Wskaźnik zajętości zasobów 0 - zasoby wolne, 1 - zasoby zajęte
uint8_t USART_semaphore_check()// Sprawdzenie dostępności zasobów
{
if(!semaphore_indicator.state)
return semaphore_indicator.state;// Zasoby wolne
else
return semaphore_indicator.user;// Zasoby zajęte przez Rx lub Tx
}
uint8_t USART_semaphore_take()// Pobranie semafora - możliwość nadawania
{
if(!semaphore_indicator.state)
return ++semaphore_indicator.state;
else
return 0;
}
uint8_t USART_semaphore_give()// Zwolnienie semafora - możliwość odbierania
{
if(semaphore_indicator.state)
return semaphore_indicator.state--;
else
return 0;
}
#endif[/syntax]
Dalej jest to wykorzystywane w funkcji do transmitowania znaku i w jego przerwaniu:
[syntax=c]// Definicja funkcji wysyłania jednego znaku
void USART_TxData_char(unsigned char data)
{
uint8_t tmp_head;
ATOMIC_BLOCK( ATOMIC_RESTORESTATE ) {
tmp_head = (UART_TxHead + 1) & UART_TX_BUF_MASK;
}
// Pętla oczekuje jeżeli brak miejsca w buforze cyklicznym na kolejne znaki
while ( tmp_head == UART_TxTail ){}
UART_TxBuf[tmp_head] = data;
UART_TxHead = tmp_head;
// Inicjalizujemy przerwanie występujące, gdy bufor jest pusty, dzięki
// czemu w dalszej części wysyłaniem danych zajmie się już procedura
// obsługi przerwania
#if USART_HALF_DUPLEX == 0
UCSRB |= (1<<UDRIE);
#endif
#if USART_HALF_DUPLEX == 1
if(USART_semaphore_check() == 0)
{
USART_semaphore_take();
semaphore_indicator.user = 1;
UCSRB |= (1<<UDRIE);
}[/syntax]
[syntax=c]// definiujemy procedurę obsługi przerwania nadawczego, pobierającą dane z bufora cyklicznego
ISR( USART_UDRE_vect) {
// sprawdzamy czy indeksy są różne
if ( UART_TxHead != UART_TxTail ) {
// obliczamy i zapamiętujemy nowy indeks ogona węża (może się zrównać z głową)
UART_TxTail = (UART_TxTail + 1) & UART_TX_BUF_MASK;
// zwracamy bajt pobrany z bufora jako rezultat funkcji
UDR = UART_TxBuf[UART_TxTail];
} else {
// zerujemy flagę przerwania występującego gdy bufor pusty
UCSRB &= ~(1<<UDRIE);
#if USART_HALF_DUPLEX == 1
if(USART_semaphore_check() == 1)
{
USART_semaphore_give();
semaphore_indicator.user = 0;
}
#endif
}
}[/syntax]
Pobieranie semafora przez nadawcę realizuję zewnętrznie przez wywoływanie z interpretera poleceń następujących funkcji:
[syntax=c]void semgive( void ) // Zwolnienie semafora
{
USART_semaphore_give();
semaphore_indicator.user = 0;
}
void semtake( void ) // Pobranie semafora
{
USART_semaphore_take();
semaphore_indicator.user = -1;
}[/syntax]
Mimo to gdy odpalam interpreter poleceń to rozpoznaje tylko jedną komendę a dalej już nie działa. Lepiej to zobrazuje filmik, ponieważ ciężko mi to opisać
iframe
Na filmie widać, że po semtake można wprowadzić semgive i oddaje semafor i wszystko wraca do normy, działają polecenia fwd i rwd oraz stop. po wprowadzeniu komendy semtake i fwd widać, że diody gasną, a już po wprowadzaniu kolejnych poleceń nic się nie dzieje.
Czy to będzie problem z semaforem czy może z interpreterem poleceń? Interpreter jest "gotowy" od Pascala Stanga.
Statystyki: Napisane przez PrzemRS — 29 sie 2015, o 20:46
]]>