Escravo SPI

Indica que uma transação de SPI foi concluída com o comprimento especificado.

Os dados gravados no escravo foram gravados no ponteiro indicado pelo argumento aInputBuf na chamada anterior para otPlatSpiSlavePrepareTransaction().

Quando essa função é chamada, otPlatSpiSlavePrepareTransaction() é inválido e precisa ser chamado novamente para que a próxima transação seja válida.

Observe que essa função sempre é chamada no final de uma transação, mesmo que otPlatSpiSlavePrepareTransaction() ainda não tenha sido chamada. Nesses casos, aOutputBufLen e aInputBufLen serão zero.

Esse callback pode ser chamado no contexto do ISR. O valor de retorno dessa função indica se algum processamento adicional é necessário. Se TRUE for retornado, a implementação do driver escravo da plataforma precisará invocar o callback do processo da transação (aProcessCallback definido em otPlatSpiSlaveEnable()), que, ao contrário desse callback, precisa ser chamado no mesmo contexto do SO que qualquer outro callback/API OpenThread é chamado.

Invocado após um callback completo de transação ser chamado e retornar TRUE para fazer qualquer processamento adicional necessário.

Ao contrário de otPlatSpiSlaveTransactionCompleteCallback, que pode ser chamado a partir de qualquer contexto de SO (por exemplo, ISR), esse callback PRECISA ser chamado no mesmo contexto de SO que qualquer outro callback/API do OpenThread.

Encerre e desative a interface SP-Slave.

Inicializar a interface de escravo do SPI.

Observe que o Slave do SPI não está totalmente pronto até que uma transação seja preparada usando otPlatSPISlavePrepareTransaction().

Se otPlatSPISlavePrepareTransaction() is not called before the master begins a transaction, the resulting SPI transaction will send all0xFF`, e todos os bytes recebidos forem descartados.

Prepare os dados para a próxima transação do SPI.

Os ponteiros de dados PRECISAM permanecer válidos até que o callback completo da transação seja chamado pelo driver escravo do SPI ou até a próxima chamada para otPlatSpiSlavePrepareTransaction().

Pode ser chamado mais de uma vez antes de o mestre de SPI iniciar a transação. Cada chamada bem-sucedida para essa função fará com que os valores anteriores de chamadas anteriores sejam descartados.

Não chamar essa função após uma transação concluída é o mesmo que se ela tivesse sido chamada anteriormente com os comprimentos de buffer definidos como zero e aRequestTransactionFlag definido como false.

Depois que o tempo de aOutputBufLen bytes do aOutputBuf for atingido, o pino MISO será definido como alto até que o mestre termine a transação do SPI. Esse é o equivalente funcional do preenchimento do final de aOutputBuf com 0xFF bytes até a duração da transação.

Depois que os bytes aInputBufLen do aInputBuf forem contados a partir do MOSI, todos os valores subsequentes do pino MOSI serão ignorados até que o mestre SPI conclua a transação.

Mesmo que aInputBufLen ou aOutputBufLen (ou ambos) se esgotem antes que o mestre de SPI conclua uma transação, o tamanho em andamento da transação ainda precisa ser monitorado para ser transmitido para o callback de transação concluída. Por exemplo, se aInputBufLen for igual a 10 e aOutputBufLen igual a 20, e o mestre do SPI ultrapassar 30 bytes, o valor 30 será transmitido para o callback da transação concluída.

Se um ponteiro NULL for transmitido como aOutputBuf ou aInputBuf, esse ponteiro de buffer não vai mudar do valor anterior/atual. Nesse caso, o argumento de tamanho correspondente deve ser ignorado. Por exemplo, otPlatSpiSlavePrepareTransaction(NULL, 0, aInputBuf, aInputLen, false) muda o ponteiro do buffer de entrada e seu comprimento, mas mantém o ponteiro do buffer de saída como antes.

Qualquer chamada para essa função enquanto uma transação está em andamento fará com que todos os argumentos sejam ignorados e o valor de retorno seja OT_ERROR_BUSY.