pic32mx230 spi字节数

下面这一段我为pic32mx230 SPI模块和谐设计制作了新代码，我需要发送96个字节
注册值，每3个字节启动CS将从低到高，有人能帮忙吗
告诉我们我错在哪里

 `APP_DATA appData;
  static uint8_t __attribute__ ((aligned (8))) app_spi_tx_buffer[128]  =0xD4,0x1E,
    0x00
    0xD4,0x1D,0x80,\
    0xD4,0x1C,0x09,\
    0xD4,0x1B,0x00,\
    0xD4,0x1A,0x00,\
    0xD4,0x19,0x64,\
    0xD4,0x18,0x18,\
    0xD4,0x17,0x00,\
    0xD4,0x16,0x80,\
    0xD4,0x15,0x00,\
    0xD4,0x14,0x00,\
    0xD4,0x13,0x00,\
    0xD4,0x12,0x00,\
    0xD4,0x11,0x00,\
    0xD4,0x10,0x00,\
    0xD4,0x0F,0x00,\
    0xD4,0x0E,0x80,\
    0xD4,0x0D,0xE8,\
    0xD4,0x0C,0x18,\
    0xD4,0x0B,0x00,\
    0xD4,0x0A,0x01,\
    0xD4,0x09,0xF0,\
    0xD4,0x08,0x00,\
    0xD4,0x07,0x00,\
    0xD4,0x06,0x53,\
    0xD4,0x05,0x00,\
    0xD4,0x04,0x01,\
    0xD4,0x03,0x04,\
    0xD4,0x02,0xAA,\
    0xD4,0x01,0xAA,\
    0xD4,0x00,0xAB,\
    0xD4,0x1B,0x00,\
    0xD4,0x1D,0x81};


  void Modulator_SPI_Enable ( void )
   {


  MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN); //start clock from here 
  TIME_DelayUs(1);
  MOD_SPI_CS_DESELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
  TIME_DelayUs(1);
  MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN); //start clock from here 
  TIME_DelayUs(1);
  MOD_SPI_CS_DESELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
  TIME_DelayUs(1);
  MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
  TIME_DelayUs(1);
  MOD_SPI_CS_DESELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
  TIME_DelayUs(1);
  MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
  TIME_DelayUs(1);
  MOD_SPI_CS_DESELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
  TIME_DelayUs(1);
  TIME_DelayMs(20);

  }


 /* state machine for the SPI */
    static void SPI_Task(void)
{
   unsigned char i;
  /* run the state machine here for SPI */
   switch (appData.spiStateMachine)
{
    default:
    case APP_SPI_STATE_START:
        /* set the state to 'wait' early so that the interrupt doesn't
            finish fast and write the state and then is overwritten */
        appData.spiStateMachine =  APP_SPI_STATE_WAIT;

        MOD_SPI_CS_DESELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);    //start clock from here 
        for (i=0; i<3; i++)
        {
            app_spi_tx_buffer[i];
        MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
        }
        appData.drvSPIBufferHandle = DRV_SPI_BufferAddWrite(appData.handleSPI0,
            app_spi_tx_buffer, sizeof(app_spi_tx_buffer),
            0, 0);

        if (DRV_SPI_BUFFER_HANDLE_INVALID == appData.drvSPIBufferHandle)
        {

            /* try again if we get a bad handle */
            appData.spiStateMachine =  APP_SPI_STATE_START;
        }
    break;

    case APP_SPI_STATE_WAIT:
    {
 if ( DRV_SPI_BufferStatus(appData.drvSPIBufferHandle) &    DRV_SPI_BUFFER_EVENT_COMPLETE)
        {
            appData.spiStateMachine = APP_SPI_STATE_DONE;
        }
    }
    break;

    case APP_SPI_STATE_DONE:
    break;
   }
 }

 void APP_Initialize ( void )
{
/* Place the App state machine in its initial state. */
appData.state = APP_STATE_INIT;
Modulator_SPI_Enable();
MOD_SPI_CS_DESELECT(SPI_SLAVE_2_CS_PORT_ID,SPI_SLAVE_2_CS_PORT_PIN);
TXDIS_DSELECT();
MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN); //  CS  will be low 

appData.handleSPI0 = DRV_HANDLE_INVALID;

/* TODO: Initialize your application's state machine and other
 * parameters.
 */
}


 void APP_Tasks ( void )
 {

/* Check the application's current state. */
switch ( appData.state )
  {
    /* Application's initial state. */
    case APP_STATE_INIT:
    {
        bool appInitialized = true;


        if (DRV_HANDLE_INVALID == appData.handleSPI0)
        {
            appData.handleSPI0 = DRV_SPI_Open(0, DRV_IO_INTENT_WRITE);
            appInitialized &= (DRV_HANDLE_INVALID != appData.handleSPI0);
        }

        if (appInitialized)
        {
            /* initialize the SPI state machine */
            appData.spiStateMachine = APP_SPI_STATE_START;

            appData.state = APP_STATE_SERVICE_TASKS;
        }
        break;
    }

    case APP_STATE_SERVICE_TASKS:
    {
        /* run the state machine for servicing the SPI */
        SPI_Task();

        break;
    }

    /* TODO: implement your application state machine.*/


    /* The default state should never be executed. */
    default:
    {
        /* TODO: Handle error in application's state machine. */
        break;
    }
  }
  }

`APP_DATA appData；
静态uint8_t___属性__（（对齐（8）））应用程序_spi_tx_缓冲区[128]=0xD4,0x1E，
0x00
0xD4,0x1D，0x80\
0xD4,0x1C，0x09\
0xD4,0x1B,0x00\
0xD4，0x1A，0x00\
0xD4,0x19,0x64\
0xD4,0x18,0x18\
0xD4,0x17,0x00\
0xD4,0x16,0x80\
0xD4,0x15,0x00\
0xD4,0x14,0x00\
0xD4,0x13,0x00\
0xD4,0x12,0x00\
0xD4,0x11,0x00\
0xD4,0x10,0x00\
0xD4,0x0F，0x00\
0xD4,0x0E，0x80\
0xD4,0x0D，0xE8\
0xD4,0x0C，0x18\
0xD4,0x0B，0x00\
0xD4,0x0A，0x01\
0xD4,0x09,0xF0\
0xD4,0x08,0x00\
0xD4,0x07,0x00\
0xD4,0x06,0x53\
0xD4,0x05,0x00\
0xD4,0x04,0x01\
0xD4,0x03,0x04\
0xD4,0x02,0xAA\
0xD4,0x01,0xAA\
0xD4,0x00,0xAB\
0xD4,0x1B,0x00\
0xD4,0x1D，0x81}；
无效调制器\u SPI\u启用（无效）
{
MOD_SPI_CS_SELECT（SPI_SLAVE_1_CS_PORT_ID，SPI_SLAVE_1_CS_PORT_PIN）；//从此处开始时钟
时间延迟（1）；
MOD_SPI_CS_取消选择（SPI_从机_1_CS_端口_ID，SPI_从机_1_CS_端口_PIN）；
时间延迟（1）；
MOD_SPI_CS_SELECT（SPI_SLAVE_1_CS_PORT_ID，SPI_SLAVE_1_CS_PORT_PIN）；//从此处开始时钟
时间延迟（1）；
MOD_SPI_CS_取消选择（SPI_从机_1_CS_端口_ID，SPI_从机_1_CS_端口_PIN）；
时间延迟（1）；
MOD_SPI_CS_SELECT（SPI_SLAVE_1_CS_PORT_ID，SPI_SLAVE_1_CS_PORT_PIN）；
时间延迟（1）；
MOD_SPI_CS_取消选择（SPI_从机_1_CS_端口_ID，SPI_从机_1_CS_端口_PIN）；
时间延迟（1）；
MOD_SPI_CS_SELECT（SPI_SLAVE_1_CS_PORT_ID，SPI_SLAVE_1_CS_PORT_PIN）；
时间延迟（1）；
MOD_SPI_CS_取消选择（SPI_从机_1_CS_端口_ID，SPI_从机_1_CS_端口_PIN）；
时间延迟（1）；
时间延迟毫秒（20）；
}
/*SPI的状态机*/
静态void SPI_任务（void）
{
无符号字符i；
/*在这里为SPI运行状态机*/
交换机（appData.spiStateMachine）
{
违约：
案例应用程序\u SPI\u状态\u开始：
/*提前将状态设置为“等待”，以避免中断
快速完成并写入状态，然后被覆盖*/
appData.spiStateMachine=APP\u SPI\u STATE\u WAIT；
MOD_SPI_CS_DESELECT（SPI_SLAVE_1_CS_PORT_ID，SPI_SLAVE_1_CS_PORT_PIN）；//从此处开始时钟
对于（i=0；i有时，最好的答案是最简单的：

unsigned char buff={0xD4,0x04,0x03,0x02,0x01,0x1E};
unsigned char i;
SPI1CON = 0x8020; // SPI on and SPI Master see 61106G.pdf PIC32 FRM
for(i = 0; i < 6; i++)
{
    /* CS = HIGH */
    SPI1BUF=buff[i];
    while(SPI1STATbits.SPIBUSY);
    // read the SDI line
    unsigned char x = SPI1BUF;
    /* CS = LOW */
}

unsigned char buff={0xD4,0x04,0x03,0x02,0x01,0x1E}；
无符号字符i；
SPI1CON=0x8020；//SPI on和SPI主机请参见61106G.pdf PIC32 FRM
对于（i=0；i<6；i++）
{
/*CS=高*/
SPI1BUF=浅黄色[i]；
while（SPI1STATbits.SPIBUSY）；
//阅读SDI行
无符号字符x=SPI1BUF；
/*CS=低*/
}

您需要为在原理图中连接到的SPI总线选择正确的SPIXCON

编辑：

我不会为你们做你们的项目，这里是我的例子和更多的例子代码

unsigned char buff[128]={0xD4,0x04,0x03,0x02,0x01,0x1E.....};
unsigned char i;
SPI1CON = 0x8020; // SPI on and SPI Master see 61106G.pdf PIC32 FRM
unsigned char j = 0;
for(i = 0; i < 128; i++)
{
    /* CS = HIGH */
    if (j == 0)            
        MOD_SPI_CS_DESELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
    SPI1BUF=buff[i];
    while(SPI1STATbits.SPIBUSY);
    // read the SDI line
    unsigned char x = SPI1BUF;
    if ( j == 2)
    {
       j = 0;
       MOD_SPI_CS_SELECT(SPI_SLAVE_1_CS_PORT_ID,SPI_SLAVE_1_CS_PORT_PIN);
    }
    else
       j++;
    /* CS = LOW */
}

unsigned char buff[128]={0xD4,0x04,0x03,0x02,0x01,0x1E….}；
无符号字符i；
SPI1CON=0x8020；//SPI on和SPI主机请参见61106G.pdf PIC32 FRM
无符号字符j=0；
对于（i=0；i<128；i++）
{
/*CS=高*/
如果（j==0）
MOD_SPI_CS_取消选择（SPI_从机_1_CS_端口_ID，SPI_从机_1_CS_端口_PIN）；
SPI1BUF=浅黄色[i]；
while（SPI1STATbits.SPIBUSY）；
//阅读SDI行
无符号字符x=SPI1BUF；
如果（j==2）
{
j=0；
MOD_SPI_CS_SELECT（SPI_SLAVE_1_CS_PORT_ID，SPI_SLAVE_1_CS_PORT_PIN）；
}
其他的
j++；
/*CS=低*/
}
如果您没有显示任何相关信息，我们应该如何帮助您？请参阅并遵循建议，并包括一个！旁注：您的两个宏看起来像“最大值”和“最大值”。这很混乱，不是一个好主意。我不知道是否有意这样做，但您只初始化了6字节的spi_tx_缓冲区及其大小（最大字节数）似乎是8我只能在我的DSO上获得一个字符类型0xd4如何增加字节数或值？感谢您的回复，先生，这对我来说非常有用，如果我想在发送期间添加cs引脚，将在三个字节高后低如何在我们的代码中实现实际我们想要发送3个字节一个字节是写入cmd 0xd4第二个字节是寄存器号和第三个字节是发送过程中的寄存器值3个字节CS引脚在最后一个字节后为低CS必须为高。总共有30个寄存器30+30+30=90个字节需要发送，请帮助我谢谢如果您需要添加CS，请将每个for循环视为SPI写入（实际上是这样）并在循环内容周围添加您的芯片选择。感谢您的回复，如果我们的buff大小为90字节，而我<3，它只能发送三个字节的值。我不清楚每3个字节的值是多少，cs高，然后低？我已经编辑了我的新C文件，请检查我错在哪里。谢谢