Problema de lectura SPI

0

He hecho los siguientes cambios y también he seguido la secuencia como se explica, para leer la respuesta del Si4455. Como se menciona en la hoja de datos w.r.t Fig (1) a continuación, es decir, hacer que CS bajo envíe comandos de API seguidos parámetros dependiendo de la orden, una vez que esta transacción es más de hacer CS alta.

Heescritounafunciónqueenvíacomandosyleelosbytesderespuestaconloscambiosnecesarios.

unsignedcharGetResponse_CTS(unsignedcharbytecount,unsignedchar*pData){cts_flag=0;unsignedinterrcnt;errcnt=RADIO_CTS_TIMEOUT;unsignedcharcts_byte=0;unsignedcharcts_check_cmd=0x44;//CTSCommandwhile(errcnt!=0){MAP_SPICSEnable(GSPI_BASE);//EnableCSMAP_SPITransfer(GSPI_BASE,&cts_check_cmd,0,1,0);//SendCTSMAP_SPITransfer(GSPI_BASE,0,&cts_byte,1,0);//Get0xFFif(cts_byte==0xFF){if(bytecount)//Ifneedtofurtherreadresponsebytes{MAP_SPITransfer(GSPI_BASE,0,pData,bytecount,0);}MAP_SPICSDisable(GSPI_BASE);//DisableCSafterreadsbreak;}MAP_SPICSDisable(GSPI_BASE);//DisableCSaftergetting0xFFerrcnt--;}if(errcnt==0){while(1){Message("CTS Time Out \r\n");
        }
    }
    if(cts_byte == 0xFF)
    {
        cts_flag = 1;

    }
    return cts_byte;

}

//Poll CTS and return CTS response
unsigned char PollCTS()
{
    return GetResponse_CTS(0,0);
}

//Transfer a byte to Si4455 from CC3200
void SpiWriteByte(unsigned char byteToWrite)
{
    MAP_SPITransfer(GSPI_BASE,&byteToWrite,0,1,0);
}



 void SendCmds(unsigned char ByteCount, unsigned char* pData)
{
    while(!cts_flag)
    {
        PollCTS();
    }
    MAP_SPICSEnable(GSPI_BASE);
    MAP_SPITransfer(GSPI_BASE,pData,0,ByteCount,0);
    MAP_SPICSDisable(GSPI_BASE);
    cts_flag=0;
}

 //Send commands and get response for Si4455
  unsigned char SendCmdGetResp(unsigned char cmdByteCount, unsigned char *pCmdData, unsigned char respByteCount, unsigned char* pRespData)
{
    SendCmds(cmdByteCount, pCmdData);
    return GetResponse_CTS(respByteCount, pRespData);
}

La siguiente es la función principal que envía un comando GET_INT_STATUS, es decir, 0x20 seguido de 3 parámetros. Luego, SendCmdGetResp , envía el comando API 0x20 seguido de 3 parámetros. Luego hace que CS sea bajo y verifica si hay CTS, si es positivo, envía 8 bytes ficticios para leer los bytes de respuesta de Si4455. Una vez que finaliza esta transacción, el CS es retirado a un nivel alto.

   void GetIntStatus(unsigned char PH_CLR_PEND,unsigned char MODEM_CLR_PEND, unsigned char CHIP_CLR_PEND)
{
    radioCmd[0] = SI4455_CMD_ID_GET_INT_STATUS;   //0x20 command
    radioCmd[1] = PH_CLR_PEND;         //parambyte0
    radioCmd[2] = MODEM_CLR_PEND;     //parambyte1
    radioCmd[3] = CHIP_CLR_PEND;      //parambyte2

   //SI4455_CMD_ARG_COUNT_GET_INT_STATUS = 4 (send 4 bytes)
   //SI4455_CMD_REPLY_COUNT_GET_INT_STATUS = 8 (read 8 response bytes)

    SendCmdGetResp(SI4455_CMD_ARG_COUNT_GET_INT_STATUS, radioCmd, SI4455_CMD_REPLY_COUNT_GET_INT_STATUS, radioCmd);

    Si4455Cmd.GET_INT_STATUS.INT_PEND       = radioCmd[0];
    Si4455Cmd.GET_INT_STATUS.INT_STATUS     = radioCmd[1];
    Si4455Cmd.GET_INT_STATUS.PH_PEND        = radioCmd[2];
    Si4455Cmd.GET_INT_STATUS.PH_STATUS      = radioCmd[3];
    Si4455Cmd.GET_INT_STATUS.MODEM_PEND     = radioCmd[4];
    Si4455Cmd.GET_INT_STATUS.MODEM_STATUS   = radioCmd[5];
    Si4455Cmd.GET_INT_STATUS.CHIP_PEND      = radioCmd[6];
    Si4455Cmd.GET_INT_STATUS.CHIP_STATUS    = radioCmd[7];
}

Incluso después de hacer los cambios respectivos, todavía recibo los bytes de respuesta de lectura como 0xFF. Esta vez, he leído la explicación y he realizado cuidadosamente los cambios respectivos, pero con la misma respuesta. Por favor, sería de gran ayuda, si la gente puede verificar mi código y avisarme si me he perdido algo, lo he verificado y no encuentro nada malo.

pregunta PsychedGuy

1 respuesta

1

Tiene varios problemas en la estructura de su código, pero el más evidente es el uso incorrecto de la línea de selección de la interfaz SPI. Esta señal debe comenzar desde lo alto al inicio de la transacción y bajar y permanecer baja durante toda la transacción, después de lo cual debe volver a ser alta nuevamente. Su código está activando y desactivando la selección por cada ocho relojes de la transferencia.

Esto se muestra muy claramente en la hoja de datos del dispositivo ...

Observe cómo el proceso de lectura consiste en una única transacción de selección SPI en la que se envía el byte de comando y luego se sigue inmediatamente una secuencia de lecturas repetitivas de 8 bits hasta que el valor CTS cambia de 0x00 a uno con 0xFF. Inmediatamente después del valor 0xFF, la siguiente secuencia de 0 - > N valores de 8 bits se registran como el valor de respuesta de lectura. Solo después de que se recibe el byte de respuesta final, la línea de selección de SPI vuelve a ser alta nuevamente.

    
respondido por el Michael Karas

Lea otras preguntas en las etiquetas