stm32+ucosII+usart串口的接收，重在分析过程

*********************************************************************************************************
*                                             INCLUDE FILES
*********************************************************************************************************
*/
#include <includes.h>
#include  <m2sxxx.h>
#include  <mss_gpio.h>
#include <mss_uart.h>
#include <mss_pdma.h>
#include <cpu.h>
/*
*********************************************************************************************************
*                                              任务优先级定义
*********************************************************************************************************
*/
#define TaskStack 100                                                 //各个任务的堆栈大小

#define  APP_CFG_TASK_LEDon_PRIO                   3                  //灯亮任务的优先级
#define  APP_CFG_TASK_OrderDo_PRIO                 5                  //执行计算机发来命令的任务
#define  APP_CFG_TASK_Datameasure_PRIO             7                  //对采样数据进行量化统计特征值任务
#define  APP_CFG_TASK_Datatransfer_PRIO             9                 //将打包数据上传计算机任务

#define SRAM1_ADDR 0x30000000                                         //sin数据地址
#define SRAM2_ADDR 0x3FFF0000                                        // 步长地址
#define SRAM3_ADDR 0x50000000                                       //高斯噪声采样数据ram1
#define SRAM4_ADDR 0x50000400                                      //高斯噪声采样数据ram2
/*
*********************************************************************************************************
*                                         任务堆栈
*********************************************************************************************************
*/
static  OS_STK          AppTaskStartStk[APP_CFG_TASK_START_STK_SIZE];
static  OS_STK          AppTaskLEDonStk[TaskStack];
static  OS_STK          APPTaskOrderDoStk[TaskStack];
static  OS_STK          APPTaskDatameasureStk[TaskStack];
/*
*********************************************************************************************************
*                                         函数声明
*********************************************************************************************************
*/
void  App_TaskStart   (void  *p_arg);
void  App_TaskLEDon  (void  *p_arg);
void  APPTaskOrderDo  (void  *p_arg);
void  APPTaskDatameasure  (void  *p_arg);

int            number(uint8_t data);
int            package(float data, uint8_t addressH);
void           bsp_GPIO0_IRQHandler(void);
void           bsp_GPIO3_IRQHandler(void);
void           bsp_uart0_rx_handler( mss_uart_instance_t * this_uart );
void           bsp_APPTaskDatatransfer_handler (void);
/*
*********************************************************************************************************
*                                        信号量
*********************************************************************************************************
*/

OS_EVENT *Datafull;
OS_EVENT *DataTranRdy;
OS_EVENT *OrderDo;
/*
*********************************************************************************************************
*                                        全局变量
*********************************************************************************************************
*/
uint32_t *sram_addr1=(uint32_t *)SRAM1_ADDR;
uint32_t *sram_addr2=(uint32_t *)SRAM2_ADDR;
uint32_t *sram_addr3=(uint32_t *)SRAM3_ADDR;
uint32_t *sram_addr4=(uint32_t *)SRAM4_ADDR;

uint32_t staticdata1[256];
uint32_t staticdata2[256];                                     //统计表
uint16_t lianghua[256];
uint32_t *staticdata;                                          //确定用于统计的统计表首地址
uint32_t *bagpoint;                                            //确定用于量化的统计表首地址
uint8_t bag[100][258];
uint16_t bag_lengthe=0;
uint8_t image_0ne[5][4]={{' ',' ',' ',' '},{' ',' ',' ','|'},{' ',' ',' ',' '},{' ',' ',' ','|'},{' ',' ',' ',' '}};
     uint8_t image_two[5][4]={{' ','-','-',' '},{' ',' ',' ','|'},{' ','-','-',' '},{'|',' ',' ',' '},{' ','-','-',' '}};
     uint8_t image_three[5][4]={{' ','-','-',' '},{' ',' ',' ','|'},{' ','-','-',' '},{' ',' ',' ','|'},{' ','-','-',' '}};
     uint8_t image_four[5][4]={{' ',' ',' ',' '},{'|',' ',' ','|'},{' ','-','-',' '},{' ',' ',' ','|'},{' ',' ',' ',' '}};
     uint8_t image_five[5][4]={{' ','-','-',' '},{'|',' ',' ',' '},{' ','-','-',' '},{' ',' ',' ','|'},{' ','-','-',' '}};
     uint8_t image_six[5][4]={{' ','-','-',' '},{'|',' ',' ',' '},{' ','-','-',' '},{'|',' ',' ','|'},{' ','-','-',' '}};
     uint8_t image_severn[5][4]={{' ','-','-',' '},{' ',' ',' ','|'},{' ',' ',' ',' '},{' ',' ',' ','|'},{' ',' ',' ',' '}};
     uint8_t image_eight[5][4]={{' ','-','-',' '},{'|',' ',' ','|'},{' ','-','-',' '},{'|',' ',' ','|'},{' ','-','-',' '}};
     uint8_t image_night[5][4]={{' ','-','-',' '},{'|',' ',' ','|'},{' ','-','-',' '},{' ',' ',' ','|'},{' ','-','-',' '}};
     uint8_t image_A[5][4]={{' ','-','-',' '},{'|',' ',' ','|'},{' ','-','-',' '},{'|',' ',' ','|'},{' ',' ',' ',' '}};
     uint8_t image_zero[5][4]={{' ','-','-',' '},{'|',' ',' ','|'},{' ',' ',' ',' '},{'|',' ',' ','|'},{' ','-','-',' '}};
     uint8_t image_equal[5][4]={{' ',' ',' ',' '},{' ',' ',' ',' '},{' ','-','-',' '},{' ',' ',' ',' '},{' ','-','-',' '}};
     uint8_t image_bai[5][4]={{' ',' ',' ',' '},{' ','0',' ','/'},{' ',' ','/',' '},{' ','/',' ','0'},{' ',' ',' ',' '}};
     uint8_t image_seg[5][4]={{' ','-','-','-'},{'/',' ',' ',' '},{' ','/','-','|'},{'|',' ',' ','|'},{'-','-','-','|'}};
     uint8_t rx_buff[1];
     uint8_t recieve0[16];
     uint8_t recieve0_headata='$';
     uint8_t recieve0_flag[2];
     uint8_t recieve0_follow=0;
     uint8_t recieve0_lengthe=0;
     uint8_t recieve0_endata[2]={0x0d,0x0a};
     uint16_t datacomplete_flag=0;
    float oneS,twoS,threeS;
    uint8_t *q;
    uint32_t cos21[1024]={  0x000,0x002,0x003,0x005,0x006,0x008,0x009,0x00B,0x00D,0x00E,0x010,0x011,0x013,0x014,0x016,0x018,0x019,0x01B,0x01C };
/*
*********************************************************************************************************
*                                                apply()
*
* Description : This is the standard entry point for C code.  It is assumed that your code will call
*               main() once you have performed all necessary initialization.
*
* Argument(s) : none
*
* Return(s)   : none
*
* Caller(s)   : Startup Code.
*
* Note(s)     : none.
*********************************************************************************************************
*/

    int number(uint8_t data)
    {
        switch(data)
        {
          case 0:q=&image_zero[0][0];break;
          case 1:q=&image_0ne[0][0];break;
          case 2:q=&image_two[0][0];break;
          case 3:q=&image_three[0][0];break;
          case 4:q=&image_four[0][0];break;
          case 5:q=&image_five[0][0];break;
          case 6:q=&image_six[0][0];break;
          case 7:q=&image_severn[0][0];break;
          case 8:q=&image_eight[0][0];break;
          case 9:q=&image_night[0][0];break;
        }
        return 0;
    }
    int package(float data, uint8_t addressH)    //打包数组中一个数据，按照格式
    {
         uint8_t a[10];
         uint8_t i,m,n;
         uint16_t data_change;

         data_change=( uint16_t)(data*1000);
           i=0;
           if(data_change==0)
               a[0]=0;
           else{
           while(data_change){
           a[i]=data_change%10;
           data_change=data_change/10;
           i++;
           }
           }
           if(i==0){
               number(a[0]);
             for(m=0;m<5;m++)
                      for(n=0;n<4;n++)
                          bag[addressH+m][190+n]=*(q++);     //one
           }
           if(i==1)
              {
               number(0);
               for(m=0;m<5;m++)
                  for(n=0;n<4;n++)
                     bag[addressH+m][190+n]=*(q++);     //one
               bag[addressH+4][194]='*';              //*
               number(a[0]);
                     for(m=0;m<5;m++)
                        for(n=0;n<4;n++)
                             bag[addressH+m][195+n]=*(q++);     //某个值
                     for(m=0;m<5;m++)
                        for(n=0;n<4;n++)
                            bag[addressH+m][199+n]=image_bai[m][n];     //%
              }
           else{
                   number(a[2]);
                  for(m=0;m<5;m++)
                     for(n=0;n<4;n++)
                        bag[addressH+m][185+n]=*(q++);     //某个值
                  number(a[1]);
                  for(m=0;m<5;m++)
                      for(n=0;n<4;n++)
                        bag[addressH+m][190+n]=*(q++);     //某个值

                  bag[addressH+4][194]='*';              //*
                  number(a[0]);
                   for(m=0;m<5;m++)
                     for(n=0;n<4;n++)
                        bag[addressH+m][195+n]=*(q++);     //某个值
                   for(m=0;m<5;m++)
                     for(n=0;n<4;n++)
                        bag[addressH+m][199+n]=image_bai[m][n];     //%
             }

      return 0;
    }
void GPIO0_IRQHandler(void)
     {
        uint16_t i;
        uint32_t *sram_addr;
        uint32_t temp;
         CPU_SR_ALLOC();
         CPU_CRITICAL_ENTER();                                       /* Tell the OS that we are starting an ISR              */
         OSIntEnter();
         CPU_CRITICAL_EXIT();
        MSS_GPIO_clear_irq(MSS_GPIO_0);
        sram_addr=sram_addr3;
        for(i=0;i<1024;i++)
        {
            temp=*(sram_addr + i);
            staticdata[temp]++;
        }
        datacomplete_flag++;
        if(datacomplete_flag==1024)   //数据是否达到1024*1024
        {
            datacomplete_flag=0;
            OSSemPost(Datafull);
        }
        OSIntExit();                                                /* Tell the OS that we are leaving the ISR              */
     }
void GPIO3_IRQHandler(void)
     {
        uint16_t i;
        uint32_t *sram_addr;
        uint32_t temp;
         CPU_SR_ALLOC();
          CPU_CRITICAL_ENTER();                                       /* Tell the OS that we are starting an ISR              */
          OSIntEnter();
         CPU_CRITICAL_EXIT();
         sram_addr=sram_addr4;

            for(i=0;i<1024;i++)
            {
                temp=*(sram_addr + i);
                staticdata[temp]++;
            }
                datacomplete_flag++;
        MSS_GPIO_clear_irq(MSS_GPIO_3);
        if(datacomplete_flag==1024)   //数据是否达到1024*1024
            {
                datacomplete_flag=0;
                OSSemPost(Datafull);
            }
        OSIntExit();                                                /* Tell the OS that we are leaving the ISR              */
     }

void bsp_uart0_rx_handler( mss_uart_instance_t * this_uart )
    {
     MSS_UART_get_rx( this_uart, &rx_buff[0],1);
     if(rx_buff[0]==recieve0_headata)
          {
            recieve0_flag[0]=1;
            recieve0_lengthe=0;
            recieve0_follow=0;
          }
      if(recieve0_flag[0]==1)
          {
            recieve0[recieve0_follow++]=rx_buff[0];
             if(rx_buff[0]==recieve0_endata[0])
               recieve0_flag[1]=1;
             if(recieve0_flag[1]==1&&rx_buff[0]==recieve0_endata[1])
            {
              recieve0_flag[0]=0;
              recieve0_lengthe=recieve0_follow;
              recieve0_follow=0;
              OSSemPost(OrderDo);
            }
          }
    }
    void  bsp_APPTaskDatatransfer_handler (void)
    {
        PDMA_clear_irq(PDMA_CHANNEL_0);
        OSSemPost(DataTranRdy);
    }
    /*
    *********************************************************************************************************
    *                                                main()
    *
    * Description : This is the standard entry point for C code.  It is assumed that your code will call
    *               main() once you have performed all necessary initialization.
    *
    * Argument(s) : none
    *
    * Return(s)   : none
    *
    * Caller(s)   : Startup Code.
    *
    * Note(s)     : none.
    *********************************************************************************************************
    */
int  main (void)
{
    CPU_Init();                                                 /* Initialize the uC/CPU services                           */

    CPU_IntDis();

    OSInit();                                                   /* Initialize "uC/OS-II, The Real-Time Kernel"              */

    OSTaskCreate(App_TaskStart,                              /* Create the start task                                    */
                 (void *)0,
                 (OS_STK *)&AppTaskStartStk[APP_CFG_TASK_START_STK_SIZE - 1],
                 APP_CFG_TASK_START_PRIO
                 );
    OSStart();

    return (0);
}


/*
*********************************************************************************************************
*                                          STARTUP TASK
*
* Description : This is an example of a startup task.  As mentioned in the book's text, you MUST
*               initialize the ticker only once multitasking has started.
*
* Arguments   : p_arg   is the argument passed to 'AppTaskStart()' by 'OSTaskCreate()'.
*
* Returns     : none
*
* Notes       : 1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
*                  used.  The compiler should not generate any code for this statement.
*********************************************************************************************************
*/
void  App_TaskStart (void *p_arg)
{
    CPU_INT32U  cnt;
    CPU_INT32U  systick_clk;
    uint16_t m;

    (void)p_arg;
    systick_clk = BSP_CPU_ClkFreqGet();                         /* Get the System Tick Timer frequency                  */
    cnt         = (systick_clk / OS_TICKS_PER_SEC);             /* Calculate the number of SysTick counts               */
    OS_CPU_SysTickInit(cnt);                                    /* Call the Generic OS Systick initialization           */
    Mem_Init();                                                 /* Initialize memory management module                  */
    Math_Init();                                                 /* Initialize mathematical module                       */
    Datafull=OSSemCreate(0);
    OrderDo=OSSemCreate(0);
    staticdata=staticdata1;
    PDMA_init();
    for(m=0;m<256;m++)
    {
        staticdata1[m]=0;
        staticdata2[m]=0;
    }
    MSS_GPIO_init();
       MSS_GPIO_config( MSS_GPIO_1 , MSS_GPIO_OUTPUT_MODE );  //测试GPIO中断中运行时间
       MSS_GPIO_config( MSS_GPIO_4 , MSS_GPIO_OUTPUT_MODE );  //测试GPIO中断中运行时间
       MSS_GPIO_config( MSS_GPIO_5 , MSS_GPIO_OUTPUT_MODE );
       MSS_GPIO_config( MSS_GPIO_6 , MSS_GPIO_OUTPUT_MODE );
       MSS_GPIO_config( MSS_GPIO_7 , MSS_GPIO_OUTPUT_MODE );
       for(m = 0; m< 1024; m++)
       {
                *(sram_addr1 + m) =cos21[m];
       }
       MSS_GPIO_set_output( MSS_GPIO_4, 0);    //写完后拉低
    MSS_GPIO_config(MSS_GPIO_0 , MSS_GPIO_INPUT_MODE | MSS_GPIO_IRQ_EDGE_NEGATIVE); //GPIO_0 下降沿触发
    MSS_GPIO_config(MSS_GPIO_3 , MSS_GPIO_INPUT_MODE | MSS_GPIO_IRQ_EDGE_NEGATIVE); //GPIO_0 下降沿触发

    MSS_UART_init(&g_mss_uart0,
                          MSS_UART_115200_BAUD,
                          MSS_UART_DATA_8_BITS | MSS_UART_NO_PARITY
                                               | MSS_UART_ONE_STOP_BIT);                           //串口初始化
    MSS_UART_set_rx_handler( &g_mss_uart0, bsp_uart0_rx_handler,MSS_UART_FIFO_SINGLE_BYTE );
    PDMA_configure(PDMA_CHANNEL_0,
                           PDMA_TO_UART_0,
                           PDMA_BYTE_TRANSFER | PDMA_LOW_PRIORITY
                                              | PDMA_INC_SRC_ONE_BYTE
                                              | PDMA_NO_INC,0);
       PDMA_set_irq_handler(PDMA_CHANNEL_0,bsp_APPTaskDatatransfer_handler);

    OSTaskCreate(App_TaskLEDon,(void *)0,(OS_STK *)&AppTaskLEDonStk[APP_CFG_TASK_START_STK_SIZE - 1],APP_CFG_TASK_LEDon_PRIO);
    OSTaskCreate(APPTaskOrderDo,(void *)0,(OS_STK *)&APPTaskOrderDoStk[TaskStack-1],APP_CFG_TASK_OrderDo_PRIO);
    OSTaskCreate(APPTaskDatameasure,(void *)0,(OS_STK *)&APPTaskDatameasureStk[TaskStack-1],APP_CFG_TASK_Datameasure_PRIO);

    PDMA_enable_irq(PDMA_CHANNEL_0);
    MSS_GPIO_enable_irq(MSS_GPIO_0);
    MSS_GPIO_enable_irq(MSS_GPIO_3);
    MSS_GPIO_set_output( MSS_GPIO_1, 0);
    while (DEF_TRUE) {                                          /* Look for button presses                              */
        OSTimeDlyHMSM(0,0,2,0);
        MSS_GPIO_set_output( MSS_GPIO_1, 0);
    }
}

/*
*********************************************************************************************************
*                                          AppTaskCreate()
*
* Description : Create application tasks.
*
* Argument(s) : none
*
* Return(s)   : none
*
* Caller(s)   : AppTaskStart()
*
* Note(s)     : none.
*********************************************************************************************************
*/




void  App_TaskLEDon  (void  *p_arg)
{
    while(1){
    MSS_GPIO_set_output( MSS_GPIO_1, 1);
    OSTimeDlyHMSM(0,0,3,0);
    }
}
 void APPTaskDatameasure  (void  *p_arg)
{
    uint8_t err,n;
    uint16_t m;
    uint32_t total_number=1048576;
    float avg;
    float S;
    float oneS_flag1,twoS_flag1,threeS_flag1;
    float oneS_flag2,twoS_flag2,threeS_flag2;
    uint32_t maxstaticdata=0;
    CPU_SR_ALLOC();
    DataTranRdy=OSSemCreate(1);
    while(1)
    {
        OSSemPend(Datafull,0,&err);

        CPU_CRITICAL_ENTER();
        if(staticdata==staticdata1)
        {
            staticdata=staticdata2;
            bagpoint=staticdata1;
        }
         else
         {
             staticdata=staticdata1;
             bagpoint=staticdata2;
         }                                 // 切换a，b表
        CPU_CRITICAL_EXIT();

        avg=0;
        S=0;
        oneS=0;
        twoS=0;
        threeS=0;
        for(m=0;m<128;m++)
        {
            avg=avg+m*bagpoint[m];
        }
         for(m=128;m<256;m++)
         {
             avg=avg-(256-m)*bagpoint[m];
         }
        avg=avg/total_number;                            //求平均值
         for(m=0;m<128;m++)
         {
             S=S+(m-avg)*(m-avg)*bagpoint[m];
         }
         for(m=128;m<256;m++)
         {
             S=S+(m-256-avg)*(m-256-avg)*bagpoint[m];
         }
         S=sqrt(S/(total_number-1));                      //求标准差
         oneS_flag1=avg+S;
         oneS_flag2=avg-S;
         twoS_flag1=avg+2*S;
         twoS_flag2=avg-2*S;
         threeS_flag1=avg+3*S;
         threeS_flag2=avg-3*S;
         for(m=0;m<128;m++)
         {
             if(m<oneS_flag1)
                oneS=oneS+bagpoint[m];
             if(m<twoS_flag1)
                 twoS=twoS+bagpoint[m];
             if(m<threeS_flag1)
                 threeS=threeS+bagpoint[m];
          }
          for(m=128;m<256;m++)
          {
             if(oneS_flag2<(m-256))
                oneS=oneS+bagpoint[m];
             if(twoS_flag2<(m-256))
                 twoS=twoS+bagpoint[m];
             if(threeS_flag2<(m-256))
                 threeS=threeS+bagpoint[m];
          }
         oneS=oneS/total_number;
         twoS=twoS/total_number;
         threeS=threeS/total_number;                    //  统计结束
         if(threeS==1)
          threeS=0.9999;
         maxstaticdata=0;
        for(m=0;m<256;m++)
        {
            if(bagpoint[m]>maxstaticdata)
            maxstaticdata=bagpoint[m];
        }                               //求解最大值
        n=0;
        for(m=128;m<256;m++)
        {
            lianghua[n++]=bagpoint[m]*99/maxstaticdata;
        }
        for(m=0;m<128;m++)
        {
            lianghua[n++]=bagpoint[m]*99/maxstaticdata;
        }                                                             //量化
        for(m=0;m<256;m++)
                 {
                     bagpoint[m]=0;
                 }                                 //表清零待备用

        OSSemPend(DataTranRdy,0,&err);

        for(m=0;m<256;m++)
             for(n=0;n<100;n++)
             {
               if(n==lianghua[m])
               bag[99-n][m]='*';
                  if(n<lianghua[m])
               bag[99-n][m]='|';
               if(n>lianghua[m])
               bag[99-n][m]=' ';              //数据打包

              }
            for(n=0;n<100;n++)
                 bag[n][256]=0x0d;             //数据打包
            for(n=0;n<100;n++)
                 bag[n][257]=0x0a;           //数据打包
            package(oneS,6);
            package(twoS,12);
            package(threeS,18);
            PDMA_start(PDMA_CHANNEL_0,
                          (uint32_t)bag,
                          PDMA_UART0_TX_REGISTER,
                          25800);

    }
}
void  APPTaskOrderDo  (void  *p_arg)
{
    uint8_t err;
    uint16_t m;
    uint32_t i;
    uint32_t buchang=0;
    CPU_SR_ALLOC();
    while(1)
    {
        OSSemPend(OrderDo,0,&err);
        if(recieve0_lengthe>3)
              {
                  if(recieve0_lengthe==4&&(recieve0[recieve0_lengthe-3]>57||recieve0[recieve0_lengthe-3]<48))
                      switch(recieve0[1]){
                      case 'A':
                     {
                       CPU_CRITICAL_ENTER();
                       MSS_GPIO_set_output( MSS_GPIO_5, 0);
                       MSS_GPIO_set_output( MSS_GPIO_6, 1);
                       datacomplete_flag=0;
                       staticdata=staticdata1;
                       bagpoint=staticdata1;
                       for(m=0;m<256;m++)
                         {
                           staticdata1[m]=0;
                           staticdata2[m]=0;
                         }                                 //表清零待备用
                       CPU_CRITICAL_EXIT();
                       break;
                      }
                      case'B':
                      {
                        CPU_CRITICAL_ENTER();
                        MSS_GPIO_set_output( MSS_GPIO_5, 1);
                        MSS_GPIO_set_output( MSS_GPIO_6, 0);
                        datacomplete_flag=0;
                        staticdata=staticdata1;
                         bagpoint=staticdata1;
                        for(m=0;m<256;m++)
                          {
                            staticdata1[m]=0;
                           staticdata2[m]=0;
                          }                                 //表清零待备用
                        CPU_CRITICAL_EXIT();
                        break;
                      }
                      case'C':
                       {
                         CPU_CRITICAL_ENTER();
                         MSS_GPIO_set_output( MSS_GPIO_5, 1);
                         MSS_GPIO_set_output( MSS_GPIO_6, 1);
                         datacomplete_flag=0;
                         datacomplete_flag=0;
                         staticdata=staticdata1;
                         bagpoint=staticdata1;
                         for(m=0;m<256;m++)
                         {
                           staticdata1[m]=0;
                            staticdata2[m]=0;
                         }                                 //表清零待备用
                         CPU_CRITICAL_EXIT();
                         break;
                       }
                      case'D':
                      {
                         CPU_CRITICAL_ENTER();
                         datacomplete_flag=0;
                         staticdata=staticdata1;
                        bagpoint=staticdata1;
                         for(m=0;m<256;m++)
                            {
                              staticdata1[m]=0;
                              staticdata2[m]=0;
                             }                                 //表清零待备用
                        MSS_GPIO_set_output( MSS_GPIO_7, 0);         //慢速
                       CPU_CRITICAL_EXIT();
                       break;
                      }
                      case'E':
                      {
                        CPU_CRITICAL_ENTER();
                        MSS_GPIO_set_output( MSS_GPIO_7, 1);        //快速
                        CPU_CRITICAL_EXIT();
                        break;
                      }
                  }

                      else
                      {
                        while(recieve0_lengthe-3)
                        {
                          if(recieve0[recieve0_lengthe-3]>57||recieve0[recieve0_lengthe-3]<48)
                              break;
                          buchang= buchang+(recieve0[recieve0_lengthe-3]-48)*i;
                          i=i*10;
                          recieve0_lengthe--;
                        }
                       *sram_addr2=buchang;
                      }
        }
   }
}