AI 助理
备案控制台
开发者社区 龙蜥操作系统 文章 正文

zynq操作系统 ： Linux下LHB155304测试用例

2023-01-17 245
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Linux下LHB155304测试用例

前言

 第一种情况的改进和第三种情况，都可以在应用层来做

 比如我们可以设置快速读写模式fastmode，在应用层调用这个函数open时，配置寄存器屏蔽掉其他子地址的中断，直接源头上减少信号量，提升操作系统处理效率，退出时在close，恢复正常的配置，以免影响其他业务流程使用

 而高频率数据偶尔出现的读写错误，处理PL测对读写时序的修改，也可以通过多读几次数据判断筛选，大大降低错误概率，（目前没有发现过规避后的出错，但是源头上还是需要在FPGA部分更改读写时序）

 另外还有个驱动开发时需要注意的是：在接收到命令字之后，由于1553B特殊的机制，我们可以判断收发标志位，有区别的是，收到接收命令后再去做根据数据指针（芯片内部指针，不是编程创建的）做接收处理是完全没有问题的，但是如果收到的是发送命令，BC会在第一时间将对应子地址下的数据拿走，想根据收发标志去做发送处理的判断是完全来不及的，需要我们清楚的熟悉业务流程，在需要的时候提前填好数据，以便收到发送消息时可以让BC设备拿走正确的数据

1553test.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <pthread.h>
#include "rt.h"
static int fd;
unsigned int commandWord[8]={0};
void Xil_Out32(unsigned int * Addr, unsigned int Value)
{
  volatile unsigned int *LocalAddr = (volatile unsigned int *)Addr;
  *LocalAddr = Value;
}
void Delay()
{
unsigned int n=1000;
while(n--);
}
unsigned int MEM_Read(unsigned int BaseAddress,unsigned int RegOffset)             
  {
    unsigned int temp[3]= {0};
    temp[0] = Xil_In32((BaseAddress) + (RegOffset));
    Delay();
    temp[1] = Xil_In32((BaseAddress) + (RegOffset));
    Delay();
    temp[2] = Xil_In32((BaseAddress) + (RegOffset));
    if(temp[0] == temp[1])
      {
        return temp[0];
      }
    else if(temp[0] == temp[2] )
      {
        return temp[0];
      }
    else if(temp[1] == temp[2])
      {
        return temp[1];
      }
    else
      {
        return 0xFFFF;
      }
}
 unsigned int * Xil_In32(unsigned int * Addr)
{
  return *(volatile unsigned int *) Addr;
}
int rt1553open()
{
    int mem_fd = open("/dev/mem", O_RDWR | O_SYNC);
    if (mem_fd < 0) {
        printf("can not open /dev/mem \n");
        return (-1);
    }   
    printf("/dev/mem is open \n");
    rt1553B_map_base0 = mmap(NULL, 4096 * 4, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, XPAR_BRAM_0_BASEADDR);
    rt1553B_map_base1 = mmap(NULL, 4096 * 4, PROT_READ | PROT_WRITE, MAP_SHARED, mem_fd, MEM_BASEADDR);
    if (rt1553B_map_base0 == 0 || rt1553B_map_base1 == 0) { 
        printf("NULL pointer\n");
    }   
    else {
        printf("mmap successful\n");
    } 
    // Xil_Out32(rt1553B_map_base0+68,1);//fangwen mem
    close(mem_fd);
    return 0;
}
void  fastenable(void)
{
  Xil_Out32(rt1553B_map_base0 + 68, 0);
  RT_WriteReg(rt1553B_map_base1, 0x00, 0x0010);  
  Xil_Out32(rt1553B_map_base1 + 68, 1);
  MEM_Write(rt1553B_map_base1, (0x01A3) * 4, 0x4200); //子地址 3：所有消息类型使用单消息管理机制，tr产生中断
  MEM_Write(rt1553B_map_base1, (0x01A4) * 4, 0x4200); //子地址 4：所有消息类型使用单消息管理机制，tr生中断
  MEM_Write(rt1553B_map_base1, (0x01A5) * 4, 0x4200); //子地址 5：所有消息类型使用单消息管理机制，tr产生中断
  MEM_Write(rt1553B_map_base1, (0x01A6) * 4, 0x0000); //子地址 6：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A7) * 4, 0x0000); //子地址 7：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A8) * 4, 0x0000); //子地址 8：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A9) * 4, 0x0000); //子地址 9：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01AA) * 4, 0x0000); //子地址 10：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01AB) * 4, 0x0000); //子地址 11：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01AC) * 4, 0x0000); //子地址 12：所有消息类型使用单消息管理机制，不产生中断
}
void  fastdisable(void)
{
  Xil_Out32(rt1553B_map_base0 + 68, 0);
  RT_WriteReg(rt1553B_map_base1, 0x00, 0x0037);  
  Xil_Out32(rt1553B_map_base0 + 68, 1);
  MEM_Write(rt1553B_map_base1, (0x01A3) * 4, 0x0000); //子地址 3：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A4) * 4, 0x0000); //子地址 4：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A5) * 4, 0x0000); //子地址 5：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A6) * 4, 0x0000); //子地址 6：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A7) * 4, 0x0000); //子地址 7：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A8) * 4, 0x0000); //子地址 8：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01A9) * 4, 0x0000); //子地址 9：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01AA) * 4, 0x0000); //子地址 10：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01AB) * 4, 0x0000); //子地址 11：所有消息类型使用单消息管理机制，不产生中断
  MEM_Write(rt1553B_map_base1, (0x01AC) * 4, 0x0000); //子地址 12：所有消息类型使用单消息管理机制，不产生中断
}
unsigned int rt1553B_rcv()
{
  unsigned int tempVar = 0;
  unsigned int read_tmp=0;
  memset(rt1553B_BUMSG.data, 0, sizeof(rt1553B_BUMSG.data));
  if (!rt1553B_BUMSG.dataCntModeCode)
  {
    tempVar = 0x20; 
    printf("**********32*************\n");
  }    
  else
  {
    tempVar = rt1553B_BUMSG.dataCntModeCode;
    printf("**********tempVar is %d*************\n",tempVar);
  }
  Xil_Out32(rt1553B_map_base0 + 68, 1);  //fangwen mem
  for (int i = 0; i < tempVar; i++)
  {
    //read_tmp= MEM_Read(rt1553B_map_base1, (rt1553B_BUMSG.dataBlockPointer + i) * 4);
    //rt1553B_BUMSG.data[i*2]=read_tmp&0x00ff;
    //rt1553B_BUMSG.data[i*2+1]= (read_tmp&0xff00)>>8;
    rt1553B_BUMSG.data[i]= MEM_Read(rt1553B_map_base1, (rt1553B_BUMSG.dataBlockPointer + i) * 4);
  }
  //for (int i = 0; i < 64; i++)
  for (int i = 0; i < 32; i++)
  {
    printf(" rcv 32word data %d is 0x%x\r\n",i, rt1553B_BUMSG.data[i]);
  }
   memset(rt1553B_BUMSG.data, 0, sizeof(rt1553B_BUMSG.data));
  //return tempVar*2;
  return tempVar;
  } 
  unsigned int rt1553B_send(unsigned char *buf,int send_len,unsigned char subaddr)
  {
      unsigned int send_tmp=0;
      Xil_Out32(rt1553B_map_base0 + 68, 1); //fangwen mem
      usleep(10);
      printf("subaddr is %d",subaddr);
      switch (subaddr)
    {
      case BusCheckRespAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x400 + i) * 4, send_tmp);
        }
      break;
      case SelfCheckAndUpdateCtrlRespAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x440 + i) * 4, send_tmp);
        }
      break;
      case StatusCheckAndUpdateDataGroupRespAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x480 + i) * 4, send_tmp);
        }
      break;
      case UpdateBlock1Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x4C0 + i) * 4, send_tmp);
        }
      break;
      case UpdateBlock2Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x500 + i) * 4, send_tmp);
        }
      break;
      case EndecryptRespAndUpdateBlock3Addr :
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x540 + i) * 4, send_tmp);
        }
      break;
      case UpdateBlock4Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x580 + i) * 4, send_tmp);
        }
      break;
      case DdChannelSetRespAndUpdateBlock5Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x5C0 + i) * 4, send_tmp);
        }
      break;
      case UpdateBlock6Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x600 + i) * 4, send_tmp);
        }
      break;
      case UpdateBlock7Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x640 + i) * 4, send_tmp);
        }
      break;
      case UpdateBlock8Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x680 + i) * 4, send_tmp);
        }
      break;
      case TransBookRespAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x700 + i) * 4, send_tmp);
        }
      break;
      case DjChannelSetRespSysSetAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x780 + i) * 4, send_tmp);
        }
      break;
      case DxChannelSetRespAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x840 + i) * 4, send_tmp);
        }
      break;
      case ForwardDataG2Addr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x880 + i) * 4, send_tmp);
        }
      break;
      case DjChannelSetRespSelfCheckAddr:
        for (int i = 0; i < send_len; i++)
        {
          send_tmp=((unsigned int)buf[i*2])| (((unsigned int)buf[i*2+1])<<8);
          MEM_Write(rt1553B_map_base1, (0x8C0 + i) * 4, send_tmp);
        }
      break;
    default:
      break;
    }
     return 0;
  }
static void  RT_signal_func(int signum)
{
    //int command=0;
    int rcv_len;
    int status;
    // printf("before read signal\n");
    status = read(fd,&rt1553B_BUMSG,sizeof(rt1553B_BUMSG));
    // printf("read is %d\n");
    // read(fd,commandWord,sizeof(commandWord));
    printf("*********demo command is 0x%x*******************\n",rt1553B_BUMSG.commandWord);
    rt1553B_BUMSG.remoteTerminalAddr = (rt1553B_BUMSG.commandWord >> 11) & 0x1f; //远程终端地址
    rt1553B_BUMSG.tr = (rt1553B_BUMSG.commandWord >> 10) & 0x01;                 //(=0收=1发)
    rt1553B_BUMSG.subAddModeCode = (rt1553B_BUMSG.commandWord >> 5) & 0x1f;      //字地址/方式指令
    rt1553B_BUMSG.dataCntModeCode = (rt1553B_BUMSG.commandWord) & 0x1f;          //数据字指令/方式指令
    // INT = rt1553B_BUMSG.tr;
    switch (rt1553B_BUMSG.tr)
    {
    case BURX:
      rcv_len = rt1553B_rcv();
      printf("rcv length is 0x%x\r\n", rcv_len);
      break;
    case BUTX:
          printf("************INPUT  send**********************\n");
      break;
    default:
      break;
    }
}
// void data_fun(void *arg)
// {
//   int rcv_len;
//       printf("*********  command is 0x%x*******************\n",rt1553B_BUMSG.commandWord);
//       // rt1553B_BUMSG.remoteTerminalAddr = (rt1553B_BUMSG.commandWord[i] >> 11) & 0x1f; //远程终端地址
//       // rt1553B_BUMSG.tr = (rt1553B_BUMSG.commandWord[i] >> 10) & 0x01;                 //(=0收=1发)
//       // rt1553B_BUMSG.subAddModeCode = (rt1553B_BUMSG.commandWord[i] >> 5) & 0x1f;      //字地址/方式指令
//       // rt1553B_BUMSG.dataCntModeCode = (rt1553B_BUMSG.commandWord[i]) & 0x1f;          //数据字指令/方式指令
//       // // INT = rt1553B_BUMSG.tr;
//       switch (rt1553B_BUMSG.tr)
//       {
//       case BURX:
//         rcv_len = rt1553B_rcv();
//         printf("rcv length is 0x%x\r\n", rcv_len);
//         break;
//       case BUTX:
//             printf("************INPUT  send**********************\n");
//         break;
//       default:
//         break;
//       }
// }
int main(void)
{
    //int command;
    int flags = 0;
    int err;
    //pthread_t deal_data;
    rt1553open();
    // fastenable();
    fd = open("/dev/1553drv", O_RDWR);
    if(fd < 0) {
        printf("*********open fail************\n");
        return -1;
    }
    signal(SIGIO, RT_signal_func);
    fcntl(fd, F_SETOWN, getpid()); // 将当前进程的进程号告诉给内核
    flags = fcntl(fd, F_GETFD); // 获取当前的进程状态
    fcntl(fd, F_SETFL, flags | FASYNC); // 设置进程启用异步通知功能
    // err=pthread_create(&deal_data, NULL, &data_fun,NULL);
    //   if(err != 0)
    //   {
    //     printf("pthreadrx_create fail\n");
    //     return -1;
    //   }
    while(1)
    {
        sleep(1);
    }
    return 0;
}
// int main ()
// {
//   rt1553open();
//   readmemtest();
//   return 0;
// }
// int showmem()
// {
//   int Status;
//   int i;
//   Xil_Out32(rt1553B_map_base0+68,1);//fangwen mem
//   for (i = 0;i < 8;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x480+i)*4);
//     printf("addr4 %d value is 0x%x\n",i,Status);
//   }
//     for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x4C0+i)*4);
//     printf("addr5 %d value is 0x%x\n",i,Status);
//   }
//   for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x500+i)*4);
//     printf("addr6 %d value is 0x%x\n",i,Status);
//   }
//     for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x540+i)*4);
//     printf("addr7 %d value is 0x%x\n",i,Status);
//   }
//   for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x580+i)*4);
//     printf("addr8 %d value is 0x%x\n",i,Status);
//   }
//     for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x5C0+i)*4);
//     printf("addr9 %d value is 0x%x\n",i,Status);
//   }
//   for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x600+i)*4);
//     printf("addr10 %d value is 0x%x\n",i,Status);
//   }
//     for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x640+i)*4);
//     printf("addr11 %d value is 0x%x\n",i,Status);
//   }
//   for (i = 0;i <28;i++)
//   {
//     Status = RT_ReadReg(rt1553B_map_base1,(0x680+i)*4);
//     printf("addr12 %d value is 0x%x\n",i,Status);
//   }
// }
/*
int showmem()
{
  int Status;
  int i;
  Xil_Out32(rt1553B_map_base0+68,1);//fangwen mem
  for (i = 0;i < 8;i++)
  {
    int j=0;
    for(j=0;j<2;j++)
    {
      Status = RT_ReadReg(rt1553B_map_base1,(0x480+i)*4);
      if(j==2)
      {
          printf("addr4 %d value is 0x%x\n",i,Status);
      }
    }
  }
    for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x4C0+i)*4);
    printf("addr5 %d value is 0x%x\n",i,Status);
      Delay();
  }
  for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x500+i)*4);
    printf("addr6 %d value is 0x%x\n",i,Status);
      Delay();
  }
    for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x540+i)*4);
    printf("addr7 %d value is 0x%x\n",i,Status);
      Delay();
  }
  for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x580+i)*4);
    printf("addr8 %d value is 0x%x\n",i,Status);
      Delay();
  }
    for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x5C0+i)*4);
    printf("addr9 %d value is 0x%x\n",i,Status);
      Delay();
  }
  for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x600+i)*4);
    printf("addr10 %d value is 0x%x\n",i,Status);
    Delay();
  }
    for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x640+i)*4);
    printf("addr11 %d value is 0x%x\n",i,Status);
    Delay();
  }
  for (i = 0;i <28;i++)
  {
    Status = RT_ReadReg(rt1553B_map_base1,(0x680+i)*4);
    printf("addr12 %d value is 0x%x\n",i,Status);
    Delay();
  }
}
*/
/*
int readmemtest()
{
  int Status1,Status2,Status3,Status4;
  int i = 0,cnterror = 0,cntok = 0;
  Xil_Out32(rt1553B_map_base0+68,1);//fangwen mem
  sleep(1);
  for (i = 0;i < 10000000;i++)
  {
      RT_WriteReg(rt1553B_map_base1,0x1A8*4,0x4200);
      RT_WriteReg(rt1553B_map_base1,0x1A9*4,0x4100);
      RT_WriteReg(rt1553B_map_base1,0x480*4,0xf102);
      RT_WriteReg(rt1553B_map_base1,0x481*4,0xf103);
      Status1 = RT_ReadReg(rt1553B_map_base1,0x1A8*4);
      Status2 = RT_ReadReg(rt1553B_map_base1,0x1A9*4);
      Status3 = RT_ReadReg(rt1553B_map_base1,0x480*4);
      Status4 = RT_ReadReg(rt1553B_map_base1,0x481*4);
      if(Status1 != 0x4200)
      {
          cnterror++;
          printf("read error %d! error value is 0x%x,error cnt is%d\n",i,Status1,cnterror);
      }
      if(Status2 != 0x4100)
      {
          cnterror++;
          printf("read error %d! error value is 0x%x,error cnt is%d\n",i,Status2,cnterror);
      }
      if(Status2 != 0xf102)
      {
          cnterror++;
          printf("read error %d! error value is 0x%x,error cnt is%d\n",i,Status3,cnterror);
      }
      if(Status2 != 0xf103)
      {
          cnterror++;
          printf("read error %d! error value is 0x%x,error cnt is%d\n",i,Status4,cnterror);
      }
        cntok ++;
       //printf("%d read ok,value is 0x%x\n",i,Status); 
  }   
  if(cntok == 10000000)
        printf("10000000 success\n");
}
*/

rt.h

#ifndef __RT_H_
#define __RT_H_
#include <stdio.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
/* 
 *Define all register macros
 *Some commonly used judgment values
 */
#define BUINTMASK                       0x0              //reg0
#define BUCFG1                          0x1
#define BUCFG2                          0x2
#define BURST                           0x3
#define BUCMDSTACKPOINT                 0x3
#define BURTSUBADDRCTRL                 0x4
#define BUTIMETAG                       0x5
#define BUINTSTATUS                     0x6
#define BUCFG3                          0x7
#define BUCFG4                          0x8
#define BUCFG5                          0x9
#define BURTDATASTACKADDR               0xa
#define BUBCFRAMETIME                   0xb
#define BUBCTIMEREMAIN                  0xc
#define BURTLASTCMD                     0xd
#define BURTSTATUSWORD                  0xe
#define BURTBITWORD                     0xf
#define BUTSTMODE0                      0x10
#define BUTSTMODE1                      0x11
#define BUTSTMODE2                      0x12
#define BUTSTMODE3                      0x13
#define BUTSTMODE4                      0x14
#define BUTSTMODE5                      0x15
#define BUTSTMODE6                      0x16
#define BUTSTMODE7                      0x17            //reg17
#define BUMSGDATANUM                    0x20            //1553 message data size 32
#define BUCHANNELA                      0x0
#define BUCHANNELB                      0x1
#define BURX                            0x0
#define BUTX                            0x1
#define ERR1                            0x0
#define ERR3                            0x1
#define ERR                             0x2
#define OK                              0x0
#define INTMASK                         0x0
#define BUM400                          0x400           //data block 13  
#define BUM800                          0x800           //data block 37  
#define BUZERO                          0x0
//#define BUMSGDATANUM                    0x40            //1553 message data size 32 word
#define BUMSGDATANUM                    0x20
#define BUSUBADDR0                      0x0
#define BUSUBADDR31                     0x20            //1553 subaddress 31
#define BUMSGBUFSIZE                    0x40            //1553 message buffer size 64
#define BUEOMINT                        0x1             //
#define BUMSGBUFBGN                     0x0             //1553 message buffer begin 0
#define BusCheckRespAddr                      1               //subaddress
#define SelfCheckAndUpdateCtrlRespAddr        3
#define StatusCheckAndUpdateDataGroupRespAddr 4
#define UpdateBlock1Addr                      5
#define UpdateBlock2Addr                      6
#define EndecryptRespAndUpdateBlock3Addr      7
#define UpdateBlock4Addr                      8
#define DdChannelSetRespAndUpdateBlock5Addr   9
#define UpdateBlock6Addr                      10
#define UpdateBlock7Addr                      11
#define UpdateBlock8Addr                      12
#define TransBookRespAddr                     15
#define DjChannelSetRespSysSetAddr            17
#define DxChannelSetRespAddr                  21
#define ForwardDataG2Addr                     24
#define DjChannelSetRespSelfCheckAddr         26
#define XPAR_BRAM_0_BASEADDR 0x40000000                 //mem ctrl baseaddr
#define MEM_BASEADDR         0x43c00000                 //1553  baseaddr
unsigned char *rt1553B_map_base0;                               //mem ctrl baseaddr
unsigned char *rt1553B_map_base1;                               //1553  baseaddr
/* 
 *Define a structure for transmitting instructions
 */
typedef struct
    {
      unsigned int channelAB;
      unsigned int blockStatusWord;
      unsigned int timeTagWord;
      unsigned int dataBlockPointer;
      unsigned int commandWord;
      unsigned int remoteTerminalAddr;
      unsigned int tr;
      unsigned int subAddModeCode;
      unsigned int dataCntModeCode;
      //unsigned char data[BUMSGDATANUM];
      unsigned int  data[BUMSGDATANUM];
    }BUMSGIFM;
 BUMSGIFM rt1553B_BUMSG;//消息
// 
typedef struct
    {
      BUMSGIFM       buRxRPool[BUMSGBUFSIZE];
      unsigned int   buRxRPoint;
      BUMSGIFM       buRxTPool[BUMSGBUFSIZE];
      unsigned int   buRxTPoint;
    } BUBUFFER;
//A read/write operation to memory
void Xil_Out32(unsigned int * Addr, unsigned int Value);
unsigned int * Xil_In32(unsigned int * Addr);
/* 
 *To facilitate access to registers and memory, 
 *the function of pointer manipulation is conveniently peak-decorated 
*/
#define RT_WriteReg(BaseAddress, RegOffset, Data)          \
    Xil_Out32((BaseAddress) + (RegOffset), (Data))
#define RT_ReadReg(BaseAddress, RegOffset)             \
    Xil_In32((BaseAddress) + (RegOffset))
#define MEM_Write(BaseAddress, RegOffset, Data)          \
    Xil_Out32((BaseAddress) + (RegOffset), (Data))
//#define MEM_Read(BaseAddress, RegOffset)             \
 //   Xil_In32((BaseAddress) + (RegOffset))
 extern unsigned int MEM_Read(BaseAddress, RegOffset);
/*
 *Memory mapping to 1553 
 *To facilitate enablement and manipulation of registers
 *@param[in] none
 *return 0
*/
int rt1553open();
/* 
 *For the initialization configuration of registers and memory,
 *please refer to the comments for details
 *@param[in] none
 *return 0
 */
int rt1553init();
/* 
 *Print out all register values to help better determine the current state
 *@param[in] none
 *return 0
 */
int showreg(); 
/* 
 *Used to make a judgment on the receiving or sending of RT
 *In fact, the configuration is already done in the rt1553init();, 
 *and the purpose of this function is only to print the send/receive data word in the absence of BM
 *Print the data word received when the BC-RT message is received
 *RT-BC prints out the data word sent
 *@param[in] none
 *return 0
 */
unsigned int rt1553B_handle();
/* 
 *Data word reception for 1553B
 *Stores the received data word in the specified data block after the mode selection, 
 *and returns twice the received length to the protocol layer
 *@param[in] none
 *return tempVar（length）
 */
unsigned int rt1553B_rcv();
/* 
 *Data word for 1553B sending
 *The pre-set instructions are filled into the fixed data block area,
 *and the data words stored in the existing specified data block area are sent to BC 
 *at the first time when receiving the sending signal
 *@param[in] buf send buffer
 *@param[in] send_len
 *@param[in] subaddr
 *return 0
 */
unsigned int rt1553B_send(unsigned char *buf,int send_len,unsigned char subaddr);
#endif
文章标签：
龙蜥操作系统
Perl
测试技术
异构计算
Linux
芯片
关键词：
Linux测试
Linux操作系统
操作系统linux
操作系统测试
Linux zynq
快跑bug来啦
目录
相关文章
springhgui
|
2月前
|
Linux Shell
linux自动崩溃，模拟测试
该脚本创建一个 systemd 服务和定时器，在系统启动3分钟后触发崩溃。通过向 /proc/sysrq-trigger 写入 &quot;c&quot; 来实现内核崩溃，用于测试系统崩溃后的恢复机制。
springhgui
62 3
ephemerals__
|
6月前
|
存储 Linux iOS开发
【Linux】冯诺依曼体系与操作系统理解
本文深入浅出地讲解了计算机体系的两大核心概念：冯诺依曼体系结构与操作系统。冯诺依曼体系作为现代计算机的基础架构，通过中央处理器、存储器和输入输出设备协同工作，解决了硬件性能瓶颈问题。操作系统则是连接硬件与用户的桥梁，管理软硬件资源，提供运行环境。文章还详细解析了操作系统的分类、意义及管理方式，并重点阐述了系统调用的作用，为学习Linux系统编程打下坚实基础。适合希望深入了解计算机原理和技术内幕的读者。
ephemerals__
153 1
sysin
|
2月前
|
安全 Linux iOS开发
Burp Suite Professional 2025.7 (macOS, Linux, Windows) - Web 应用安全、测试和扫描
Burp Suite Professional 2025.7 (macOS, Linux, Windows) - Web 应用安全、测试和扫描
sysin
303 0
Burp Suite Professional 2025.7 (macOS, Linux, Windows) - Web 应用安全、测试和扫描
sysin
|
3月前
|
安全 Linux 网络安全
Metasploit Pro 4.22.7-2025061201 (Linux, Windows) - 专业渗透测试框架
Metasploit Pro 4.22.7-2025061201 (Linux, Windows) - 专业渗透测试框架
sysin
111 3
Metasploit Pro 4.22.7-2025061201 (Linux, Windows) - 专业渗透测试框架
sysin
|
1月前
|
SQL 安全 Linux
Metasploit Pro 4.22.8-2025073001 (Linux, Windows) - 专业渗透测试框架
Metasploit Pro 4.22.8-2025073001 (Linux, Windows) - 专业渗透测试框架
sysin
84 0
sysin
|
4月前
|
安全 Unix Linux
Metasploit Pro 4.22.7-2025052201 (Linux, Windows) - 专业渗透测试框架
Metasploit Pro 4.22.7-2025052201 (Linux, Windows) - 专业渗透测试框架
sysin
115 5
Metasploit Pro 4.22.7-2025052201 (Linux, Windows) - 专业渗透测试框架
蓝易云
|
2月前
|
监控 Linux 开发者
理解Linux操作系统内核中物理设备驱动(phy driver)的功能。
综合来看，物理设备驱动在Linux系统中的作用是至关重要的，它通过与硬件设备的紧密配合，为上层应用提供稳定可靠的通信基础设施。开发一款优秀的物理设备驱动需要开发者具备深厚的硬件知识、熟练的编程技能以及对Linux内核架构的深入理解，以确保驱动程序能在不同的硬件平台和网络条件下都能提供最优的性能。
蓝易云
126 0
sysin
|
4月前
|
安全 前端开发 Linux
Immunity CANVAS Professional 7.27 (macOS, Linux, Windows) - 渗透测试和漏洞利用平台
Immunity CANVAS Professional 7.27 (macOS, Linux, Windows) - 渗透测试和漏洞利用平台
sysin
152 3
Immunity CANVAS Professional 7.27 (macOS, Linux, Windows) - 渗透测试和漏洞利用平台
sysin
|
4月前
|
安全 测试技术 Linux
Flawnter 5.9.1 (macOS, Linux, Windows) - 应用程序安全测试软件
Flawnter 5.9.1 (macOS, Linux, Windows) - 应用程序安全测试软件
sysin
133 2
Flawnter 5.9.1 (macOS, Linux, Windows) - 应用程序安全测试软件
sysin
|
4月前
|
数据采集 安全 Linux
Metasploit Pro 4.22.7-2025051201 (Linux, Windows) - 专业渗透测试框架
Metasploit Pro 4.22.7-2025051201 (Linux, Windows) - 专业渗透测试框架
sysin
92 4
Metasploit Pro 4.22.7-2025051201 (Linux, Windows) - 专业渗透测试框架

龙蜥操作系统

热门文章

最新文章

  • 1
    Linux重置root用户密码
  • 2
    深度学习之需求预测
  • 3
    Linux进程查看与控制：掌握ps、top、kill等关键命令
  • 4
    Win11彻底卸载WSL2系统（去除导航窗格Linux图标）
  • 5
    Linux环境下Docker的卸载
  • 6
    Linux版百度网盘丨直接在服务器SSH命令行中使用百度云，轻松解决数据传输和分享难题
  • 7
    什么是接口幂等性？如何保证接口幂等性？
  • 8
    APP上架到应用商店需要哪些流程？
  • 9
    大咖来袭 操作系统开源与 AI 进化分论坛亮点剧透｜2025 云栖大会
  • 10
    保姆级教程，龙蜥操作系统安装使用一步到位
  • 1
    重磅活动推荐：第 20 届「中国 Linux 内核开发者大会」征稿开始啦
    31
  • 2
    终极预告 2025 云栖大会“操作系统开源与 AI 进化”分论坛全议程揭晓
    37
  • 3
    大咖来袭 操作系统开源与 AI 进化分论坛亮点剧透｜2025 云栖大会
    75
  • 4
    龙蜥伙伴活动推荐：Chitu First Meetup 在杭州召开，欢迎参加
    21
  • 5
    深度探讨基础软件驱动下的智驾进化之道 |《AI 进化论》第四期
    41
  • 6
    “操作系统开源与 AI 进化”分论坛全议程来啦 | 2025 云栖大会
    59
  • 7
    睿思芯科正式加入龙蜥社区，携手共建 RISC-V 服务器生态新标杆
    50
  • 8
    龙蜥Confidential MaaS解决方案如何破解MaaS “黑盒”困局|《AI 进化论》第三期
    82
  • 9
    龙蜥社区第 35 次运营委员会会议圆满结束
    57
  • 10
    备受关注的“操作系统开源与 AI 进化”分论坛来了 | 2025 云栖大会
    77

    • 相关课程

    更多
  • Linux Web服务器Nginx搭建与配置
  • Linux用户和组管理
  • 计算机基础与Linux入门
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    蛋白质语言模型 ProGen：在实验室合成由 AI 预测的蛋白质