A maior rede de estudos do Brasil

Grátis
256 pág.
Descobrindo o STM32

Pré-visualização | Página 44 de 47

(None) ((None))
16.4. MANIPULADORES DE INTERRUPÇÃO
do thread. Aqui usamos Mutex. Há duas operações a se notar – take e give.
Quando o mutex é inicializado ele têm um único “token”. Take remove o to-
ken se disponível, ou bloqueia o thread que chama e põe o thread em uma
lista associada ao Mutex se nenhum token estiver disponível. Give restaura
o token. A maior diferença entre mutexes (semáforos binários) e semáforos
contáveis é que o último pode ter vários tokens.
Outro Mutex pode ser adicionado para proteger da mesma forma putchar.
Proteger getchar e putchar com mutexes impedirão “data races” (corridas
de dados), tais como a mostrada acima; no entanto, isso pode não produzir
o comportamento esperado. Suponha múltiplos threads chamando putchar
através de um procedimento putstring:
void putstring(char *s){
while (s && *s)
putchar(*s++);
}
Neste caso, a saída de dois threads escrevendo simultaneamente duas
strings pode ser intercalada!
Exercise 16.2 Multiplos Threads
Escreva um programa com dois threads que imprimem continuamente
strings para a UART1. Um terceiro thread deve piscar um dos Leds a 2Hz.
Você deve usar os parâmetros do thread para especializar uma função comum
aos threads para os dois threads que imprimem. Teste seu código usando
apenas um Mutex em um putchar. Então ache uma solução que previna a
intercalação de strings.
16.4 Manipuladores de Interrupção
O código de getchar acima tem uma grande falha – a thread que tem o
mutex continuará a rodar sobre o teste do flag até que tenha êxito. Precisamos
de um mecanismo para permitir que o thread em espera possa dormir até que
haja espaço disponível. Com periféricos como UARTs já vimos que o código
de interrupção pode lidar com as mudanças reais no status do hardware. Na
Seção 11.5, mostramos como isso pode funcionar. A questão remanescente é
como comunicar esses eventos de hardware com os manipuladores de inter-
rupção. Como mostramos anteriormente, gostaríamos de associar um par de
queues com as interfaces de transmissão e recepção da UART. Onde antes o
nosso código de putchar falhou quando a fila de transmisão estava vazia e
Revision: (None) ((None)) 237
CAPÍTULO 16. SISTEMAS OPERACIONAIS DE TEMPO-REAL
nosso código getchar falhou quando a fila de recebimento estava vazia, em
um ambiente com múltiplos threads, gostaríamos de bloquear um thread em
qualquer um destes casos e ter o manipulador de interrupção acordar o thread.
FreeRTOS fornece suas próprias primitivas de bloqueio de queues (na
verdade, semáforos e mutexes são casos especiais de queues):
xQueueHandle xQueueCreate(
unsigned portBASE_TYPE uxQueueLength ,
unsigned portBASE_TYPE uxItemSize);
Uma queue (fila) é criada com tanto um comprimento quanto um ta-
manho de dados. Os itens são enfileirados, copiando-os e não por referência
(pode-se sempre enfileirar um ponteiro, mas pense com cuidado antes de fa-
zer isso!). Os dois procedimentos de interface que necessitamos são “send” e
“receive”. Observe que cada um tem um “timeout” (“tempo de espera”), que
pode variar de 0 (não espere se a operação falhar) até portMAX_DELAY que
espera para sempre.
portBASE_TYPE xQueueSend( xQueueHandle xQueue,
const void * pvItemToQueue ,
portTickType xTicksToWait );
portBASE_TYPE xQueueReceive(xQueueHandle xQueue,
void *pvBuffer ,
portTickType xTicksToWait );
Ambas interfaces podem ser utilizadas por meio de threads, mas não
por manipuladores de interrupção, que deve usar versões especiais destas:
portBASE_TYPE xQueueSendFromISR( xQueueHandle pxQueue,
const void *pvItemToQueue ,
portBASE_TYPE *pxHigherPriorityTaskWoken);
portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue,
void *pvBuffer ,
portBASE_TYPE *pxTaskWoken);
Observe que essas “ISR” (Interrupt Service Routine) (Rotinas de Inter-
rupção do Serviço) têm um terceiro parâmetro diferente –- um flag é retornado
se uma tarefa foi “woken” (“acordada”) por uma chamada. Nesta situação, o
manipulador de interrupção deve notificar o kernel como nós em breve iremos
demonstrar.
Observação: É muito importante que os manipuladores de interrup-
ção que acessam a API do FreeRTOS tenham prioridades mais baixas (altos
238 Revision: (None) ((None))
16.4. MANIPULADORES DE INTERRUPÇÃO
números) que o valor
LIBRARY_MAX_SYSCALL_INTERRUPT_PRIORITY definido no arquivo de configu-
ração o FreeRTOS.
Nós agora construiremos uma versão com interrupção (driven) da UART
como mostrado nas Listagens16.3 e 16.4
int uart_putc(int c){
xQueueSend(UART1_TXq , &c, portMAX_DELAY);
// kick the transmitter interrupt
USART_ITConfig(USART1, USART_IT_TXE , ENABLE);
return 0;
}
int uart_getc (){
int8_t buf;
xQueueReceive(UART1_RXq , &buf, portMAX_DELAY);
return buf;
}
Listing 16.3: Interrupt Driven UART
Exercise 16.3 Multithreaded Queues
Complete a UART com interrupção (driven) com controle de fluxo
usando filas junto com um programa multi-thread que exercita tanto o envio
quanto a recepção.
Revision: (None) ((None)) 239
CAPÍTULO 16. SISTEMAS OPERACIONAIS DE TEMPO-REAL
void USART1_IRQHandler(void)
{
portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){
uint8_t data;
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
data = USART_ReceiveData(USART1) & 0xff;
if (xQueueSendFromISR(UART1_RXq , &data,
↪→&xHigherPriorityTaskWoken) != pdTRUE)
RxOverflow = 1;
}
if(USART_GetITStatus(USART1, USART_IT_TXE) != RESET) {
uint8_t data;
if (xQueueReceiveFromISR(UART1_TXq , &data,
↪→&xHigherPriorityTaskWoken) == pdTRUE){
USART_SendData(USART1, data);
}
else {
// turn off interrupt
USART_ITConfig(USART1, USART_IT_TXE , DISABLE);
}
}
// Cause a scheduling operation if necessary
portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
}
Listing 16.4: Interrupt Driven UART (Handler)
16.5 SPI
As outras interfaces de comunicação que introduzimos neste livro tam-
bém precisam ser reconsideradas em face de multi-thread. A interface I2C
é muito parecida com a interface UART na qual um semáforo pode ser adi-
cionado diretamente ao código da interface para proteger as interfaces de
leitura/escrita (apenas um semáforo é necessário). SPI é um pouco diferente
– enquanto que o protocolo I2C inclui endereçamento de dispositivos nos da-
240 Revision: (None) ((None))
16.5. SPI
dos transmitidos, SPI usa linhas de seleção separadas para cada dispositivo.
Nosso uso da interface SPI é algo como:
select();
spi_operation();
deselect();
onde marcar e desmarcar são específicos do dispositivo. Se seguimos o padrão
UART de acessar um único semáforo dentro das operações do SPI, então seria
possível ter um thread interferindo com outro. Nós temos um par de opções de
projeto. Poderíamos simplesmente fazer o semáforo para a interface SPI como
um objeto global e exigir que todos os usuários da interface primeiro requisitem
o semáforo. Isto tem a desvantagem significativa de exigir que os escritores
do código do aplicativo sejam muito familiarizados com os pressupostos de
sincronização de baixo nível para a interface e corre um risco significativo de
originar código falho. Poderíamos acrescentar o pino selecionado GPIO como
um (par) de parâmetros para a interface SPI como em:
void spiReadWrite(SPI_TypeDef* SPIx, uint8_t *buf, uint8_t * buf,
↪→int cnt,
uint16_t pin, GPIO_TypeDef* GPIOx);
Ou, poderíamos passar uma função de retorno de chamada (callback)
em que a interface SPI poderia usar para selecionar/desmarcar o dispositivo
depois de pegar o semáforo.
typedef void selectCB_t(int sel);
void spiReadWrite(SPI_TypeDef* SPIx, uint8_t *buf, uint8_t *buf,
↪→int cnt,
selectCB_t selectCB);
Esta abordagem final parece preferível, uma vez que não carrega a
interface da SPI com conhecimento detalhado de como funciona o selecionar/-
desmarcar.
A interface SPI também é usada para transferências de dados

Crie agora seu perfil grátis para visualizar sem restrições.