按键+串口发送实验

于 2024-03-12 21:21:50 发布
阅读量739 收藏 22
点赞数 18
分类专栏： zynq vivado摸鱼记录 文章标签： 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hhh123987_/article/details/136528272
版权

摸鱼记录 Day_15     ～(￣▽￣～)(～￣▽￣)～

review

        前边已经学习了：

        串口发送Vivado 串口通信(UART)------串口发送-CSDN博客

        按键基于状态机的按键消抖实现-CSDN博客

1.  今日摸鱼任务

控制四个按键[3:0]key

按下按键后：

                    使用串口发送对应的拨码开关的值到电脑

                    发送完成后对应的led闪烁

 2. design sources

key_one   基于状态机的按键消抖实现-CSDN博客

module key_one(
                 input clk , 
                 input reset_n,
                 input key,
                 output reg key_flag,
                 output reg key_state);
                 
        // nedge_key pedge_key
        reg dff_k_0 , dff_k_1 ;
        reg r_key; 
        wire  nedge_key, pedge_key;
        always@(posedge clk )    
            dff_k_0 <= key ;
        always@(posedge clk )    
            dff_k_1 <= dff_k_0 ;
        always@(posedge clk )    
            r_key <= dff_k_1 ;
            
        assign nedge_key = (r_key == 1)&&(dff_k_1 == 0);
        assign pedge_key = (r_key == 0)&&(dff_k_1 == 1);
   
        // key_now   0:IDLE   1:FILTER0   2:DOWN   3:FILTER1
        // cnt 20ms/20ns = 1000000 ;
        reg [1:0]key_now;
        reg [19:0] cnt;
        parameter cnt_N = 1000000;
        always@(posedge clk or negedge reset_n ) 
            if(!reset_n) 
                begin
                    key_now <= 0 ;
                    cnt <= 0;
                    key_flag <= 0;
                    key_state <= 1;
                end
            else 
                begin
                    key_flag <= 0;
                    case(key_now)
                        0:
                           if(!nedge_key) key_now <= 0;
                           else 
                               begin 
                                 cnt <= 0 ;
                                 key_now <= 1; 
                               end
                               
                        1:
                            if(pedge_key) key_now <= 0;
                            else if(cnt >= cnt_N - 1) 
                                begin
                                    cnt <= 0 ;
                                    key_now <= 2;
                                    key_flag <= 1;
                                    key_state <= 0;
                                end
                            else cnt <= cnt + 1'b1;
                            
                        2:
                            if(!pedge_key) key_now <= 2;
                            else
                                begin
                                    cnt <= 0 ;
                                    key_now <= 3;
                                end
                        
                        3:
                            if(nedge_key) key_now <= 2;
                            else if(cnt >= cnt_N - 1)
                                 begin
                                    cnt <= 0 ;
                                    key_now <= 0;
                                    key_flag <= 1;
                                    key_state <= 1;
                                end
                            else cnt <= cnt + 1'b1;    
                        
                    endcase
                end

endmodule

uart_txx   Vivado 串口通信(UART)原理A ------串口发送实验-CSDN博客

module uart_txx(input clk , 
                input reset_n , 
                input [7:0]data , 
                input Send_Go ,
                output  reg uart_tx_ , 
                output reg Tx_Done  );
        //默认使用波特率BAUD 115200  时钟频率 CLK_FREQ  50MHz
    parameter start_bit = 0 ;
    parameter stop_bit  = 1 ;
    parameter BAUD = 115200;
    parameter CLK_FREQ = 50_000_000;
    parameter bps_c = CLK_FREQ / BAUD ;    
    
        reg Send_en ; 
        always@(posedge clk or negedge reset_n )
        if(! reset_n) 
            Send_en <= 0 ;
        else if(Send_Go)
            Send_en <= 1 ; 
        else if((tx_flag==9)&&(counter_bps == bps_c - 1)) 
            Send_en <= 0 ;
        
      // bps
      reg [30:0] counter_bps ;        
      always@(posedge clk or negedge reset_n)
        if(! reset_n) 
            counter_bps <= 0 ;
        else if (Send_en)
            if(counter_bps == bps_c - 1)
                counter_bps <= 0 ;
            else
                counter_bps <= counter_bps + 1'b1 ;
        else
            counter_bps <= 0 ;
            
      // 发送状态
      reg [3:0] tx_flag;
      always@(posedge clk or negedge reset_n)
        if(! reset_n) 
            tx_flag <= 0 ;
        else if (!Send_en) tx_flag <= 0 ;
        else if ((tx_flag==9)&&(counter_bps == bps_c - 1))
             tx_flag <= 0 ;
        else
             if(counter_bps == bps_c - 1)
                tx_flag <= tx_flag + 1'b1 ;
                
//       Send_Go改变发送信号         
        reg [7:0]r_data;
        always@(posedge clk)
        if(Send_Go)
         r_data <= data;
        else
         r_data <= r_data;                    
         
    //  tx_flag          
       always@(*)
       if(!Send_en) 
            uart_tx_ <= 1'b1;
       else
        begin 
            case(tx_flag)
            4'b0000 : uart_tx_ <= start_bit;
            4'b0001 : uart_tx_ <= r_data[0];
            4'b0010 : uart_tx_ <= r_data[1];
            4'b0011 : uart_tx_ <= r_data[2];
            4'b0100 : uart_tx_ <= r_data[3];
            4'b0101 : uart_tx_ <= r_data[4];
            4'b0110 : uart_tx_ <= r_data[5];
            4'b0111 : uart_tx_ <= r_data[6];
            4'b1000 : uart_tx_ <= r_data[7];
            4'b1001 : uart_tx_ <= stop_bit;
            default : uart_tx_ <= uart_tx_;
            endcase
            
        end      
        
        
        always@(posedge clk )        
        Tx_Done <= (tx_flag==9)&&(counter_bps == bps_c - 1);
     
endmodule

//以上两个函数对应之前的学习笔记
开始主函数哩：
key_main

module key_main( input clk , 
                 input reset_n,
                 input [3:0]key,
                 input [7:0]data,
                 output [3:0] key_state,           //按键状态判断，可用key_one 获得
                 output reg tx_data,                //串口输出
                 output [3:0] led                     // 串口发送完成信号，可用uart_txx 获得

                 );

        //四个按键

       wire [3:0] key_flag;

                key_one   

                                key_0

                                key_1

                                key_2

                                key_3

        //对应uart_tx

        wire [3:0] tx_data_;

endmodule

一开始的想法当然很简单啦~

第一个问题：uart_txx  uart_tx_0(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(key_flag[0] ),. uart_tx_(tx_data_[0]) , . Tx_Done(led[0])  );

        用key_flag[0] 作为串口发送使能信号，key_flag[0] 在按键按下、释放都会产生脉冲信号，故在按键按下会发送两次信号

解决方法：if((key_flag[0])&&(key_state[0]==0))  Send_Go_[0] <=  1'b1 ;

                        添加使能信号 reg [3:0]Send_Go_ ; 

第二个问题：

[DRC MDRV-1] Multiple Driver Nets: Net uart_tx_3/tx_data_OBUF has multiple drivers: uart_tx_2/uart_tx__reg/Q, uart_tx_3/uart_tx__reg/Q, uart_tx_0/uart_tx__reg/Q, and uart_tx_1/uart_tx__reg/Q.
                有多个端口驱动一个网络，也就是程序中出现了相同变量的网络号。

uart_txx  uart_tx_0(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[0]) ,. uart_tx_(tx_data) ,. Tx_Done(led[0])  );     
    uart_txx  uart_tx_1(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[1]) ,. uart_tx_(tx_data) , . Tx_Done(led[1])  ); 
    uart_txx  uart_tx_2(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[2]) ,. uart_tx_(tx_data) , . Tx_Done(led[2])  ); 
    uart_txx  uart_tx_3(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[3]) ,. uart_tx_(tx_data) , . Tx_Done(led[3])  );   

解决方法：     wire [3:0] tx_data_;

                       并添加reg [3:0]Send_Go_flag ; 控制  tx_data此时的输出信号

module key_main( input clk , 
                 input reset_n,
                 input [3:0]key,
                 input [7:0]data,
                 output [3:0] key_state,
                 output reg tx_data,
                 output [3:0] led    );
    parameter cnt_num = 1000000;
    wire [3:0] key_flag;
    key_one   key_0(. clk(clk) ,  . reset_n(reset_n),. key(key[0]),
                    .  key_flag(key_flag[0]),.  key_state(key_state[0]));
                    defparam key_0.cnt_N = cnt_num;
    key_one   key_1(. clk(clk) ,  . reset_n(reset_n),. key(key[1]),
                    .  key_flag(key_flag[1]),.  key_state(key_state[1]));
                    defparam key_1.cnt_N = cnt_num;
    key_one   key_2(. clk(clk) ,  . reset_n(reset_n),. key(key[2]),
                    .  key_flag(key_flag[2]),.  key_state(key_state[2]));
                    defparam key_2.cnt_N = cnt_num;
    key_one   key_3(. clk(clk) ,  . reset_n(reset_n),. key(key[3]),
                    .  key_flag(key_flag[3]),.  key_state(key_state[3]));
                    defparam key_3.cnt_N = cnt_num;
    reg [3:0]Send_Go_ ; 
        always@(posedge clk or negedge reset_n )
        if(! reset_n)   Send_Go_ <=  4'b0000 ;
        else if((key_flag[0])&&(key_state[0]==0))  Send_Go_[0] <=  1'b1 ;
        else if((key_flag[1])&&(key_state[1]==0))  Send_Go_[1] <=  1'b1 ;
        else if((key_flag[2])&&(key_state[2]==0))  Send_Go_[2] <=  1'b1 ;
        else if((key_flag[3])&&(key_state[3]==0))  Send_Go_[3] <=  1'b1 ;
        else   Send_Go_ <=  4'b0000 ;                

    wire [3:0] tx_data_;
    uart_txx  uart_tx_0(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[0]) ,. uart_tx_(tx_data_[0]) , . Tx_Done(led[0])  );     
    uart_txx  uart_tx_1(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[1]) ,. uart_tx_(tx_data_[1]) , . Tx_Done(led[1])  ); 
    uart_txx  uart_tx_2(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[2]) ,. uart_tx_(tx_data_[2]) , . Tx_Done(led[2])  ); 
    uart_txx  uart_tx_3(. clk(clk) ,  . reset_n(reset_n), . data(data) , 
                . Send_Go(Send_Go_[3]) ,. uart_tx_(tx_data_[3]) , . Tx_Done(led[3])  );    
                
   reg [3:0]Send_Go_flag ; 
        always@(posedge clk or negedge reset_n )
        if(! reset_n)   Send_Go_flag <=  4'b0000 ;
        else if(Send_Go_[0]) Send_Go_flag[0] <=  1'b1 ;
        else if(led[0]) Send_Go_flag[0] <=  1'b0 ;  
        else if(Send_Go_[1])  Send_Go_flag[1] <=  1'b1 ;
        else if(led[1])  Send_Go_flag[1] <=  1'b0 ;
        else if(Send_Go_[2]) Send_Go_flag[2] <=  1'b1 ;
        else if(led[2]) Send_Go_flag[2] <=  1'b0 ;  
        else if(Send_Go_[3])  Send_Go_flag[3] <=  1'b1 ;
        else if(led[3])  Send_Go_flag[3] <=  1'b0 ;          
        
        
        always@(posedge clk or negedge reset_n )
        if(! reset_n)   tx_data <=  1'b1 ;  
        else if(Send_Go_flag[0]) tx_data <= tx_data_[0]; 
        else if(Send_Go_flag[1]) tx_data <= tx_data_[1]; 
        else if(Send_Go_flag[2]) tx_data <= tx_data_[2]; 
        else if(Send_Go_flag[3]) tx_data <= tx_data_[3]; 
        else  tx_data <=  1'b1 ;                                       
endmodule

3.   key_tb

`timescale 1ns / 1ns
module key_tb(   );
    reg clk ,  reset_n ;
    reg [3:0]key;
    reg [7:0]data;
    wire [3:0]key_state;
    wire tx_data;
    wire [3:0]led;
    parameter cut_time = 1000;
    key_main   key_4( . clk(clk) ,  . reset_n(reset_n),. key(key),.data(data),
                    .  key_state(key_state),
                    . tx_data(tx_data), .led(led) );
                defparam key_4.cnt_num = cut_time;
    initial clk = 1;
    always#10 clk = ~clk ;
    initial
        begin
          reset_n = 0 ;
          key = 4'b1111;
          #201;
          reset_n = 1 ;  
          key_press(2);
          $stop;  
        end
    
 reg [13:0] rand;
 task key_press;
    input[3:0]seed;
    begin
        key =  4'b1111 ;
        data = 8'b1111_0000;
        #100000;
// key[0]
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[0]=~key[0];
            end
        key = 4'b1110 ;
        #100000;
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[0]=~key[0];
            end
         key = 4'b1111 ;
         data = 8'b1100_1100;
        #100000;
 // key[1]
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[1]=~key[1];
            end
        key = 4'b1101 ;
        #100000;
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[1]=~key[1];
            end
         key = 4'b1111 ;
         data = 8'b0101_1010;
        #100000; 
// key[2]
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[2]=~key[2];
            end
        key = 4'b1011;
        #100000;
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[2]=~key[2];
            end
         key = 4'b1111 ;
         data = 8'b1100_1100;
        #100000;
// key[3]        
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[3]=~key[3];
            end
        key = 4'b0111 ;
        #100000;
        repeat(10)
            begin
                rand = {$random(seed)} % 10000;
                #rand;
                key[3]=~key[3];
            end
         key = 4'b1111 ;
         data = 8'b1100_1100;
        #100000;
    end
   
endtask
 
endmodule

4. constraint

set_property IOSTANDARD LVCMOS33 [get_ports {data[7]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[6]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[5]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[4]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {data[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {led[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {led[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {led[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {led[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key_state[3]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key_state[2]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key_state[1]}]
set_property IOSTANDARD LVCMOS33 [get_ports {key_state[0]}]
set_property IOSTANDARD LVCMOS33 [get_ports clk]
set_property IOSTANDARD LVCMOS33 [get_ports reset_n]
set_property IOSTANDARD LVCMOS33 [get_ports tx_data]
set_property PACKAGE_PIN U18 [get_ports clk]
set_property PACKAGE_PIN H18 [get_ports reset_n]
set_property PACKAGE_PIN J16 [get_ports tx_data]
set_property PACKAGE_PIN E17 [get_ports {data[7]}]
set_property PACKAGE_PIN D18 [get_ports {data[6]}]
set_property PACKAGE_PIN H15 [get_ports {data[5]}]
set_property PACKAGE_PIN F16 [get_ports {data[4]}]
set_property PACKAGE_PIN K14 [get_ports {data[0]}]
set_property PACKAGE_PIN L15 [get_ports {data[1]}]
set_property PACKAGE_PIN G14 [get_ports {data[2]}]
set_property PACKAGE_PIN J14 [get_ports {data[3]}]
set_property PACKAGE_PIN J19 [get_ports {key[3]}]
set_property PACKAGE_PIN J20 [get_ports {key[2]}]
set_property PACKAGE_PIN H16 [get_ports {key[1]}]
set_property PACKAGE_PIN H20 [get_ports {key[0]}]
set_property PACKAGE_PIN G17 [get_ports {led[0]}]
set_property PACKAGE_PIN G19 [get_ports {led[1]}]
set_property PACKAGE_PIN G20 [get_ports {led[2]}]
set_property PACKAGE_PIN G18 [get_ports {led[3]}]
set_property PACKAGE_PIN K19 [get_ports {key_state[0]}]
set_property PACKAGE_PIN J18 [get_ports {key_state[1]}]
set_property PACKAGE_PIN H17 [get_ports {key_state[2]}]
set_property PACKAGE_PIN K18 [get_ports {key_state[3]}]

                //视频没办法插入，就这样子啦~

//好啦，摸鱼结束啦～(￣▽￣～)(～￣▽￣)～

hhh123987_
关注
  • 18
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
zigbee小实验3（每按下一次按键，板子就会向串口发送一次数据）
07-20
通过按下cc2530开发板上的键来控制板子回信息。每按下一次，板子就会向串口发送一次数据，不按则不发。
[STM32F1]关于STM32F103芯片按钮机制串口发送程序
ic2121的博客
10-19 422
3、在时间中断函数中调用查询，我是放在中断函数中定时进行判断，其实就是刷新数据，我这个是10ms，其实根据自己按钮的紧急程度进行设置中断函数，比如，这个DI里面有关于急停的信号，可以设置为1ms读取一次状态，按照信号的轻重缓急进行区分对待放在不同的中断函数中进行发送。这样就能够实现按钮变化发送数据，当然这个只是我用STM32F103实现的，用的HAL库函数，咱们STM32芯片很容易程序移植，这个框架也可以用到其他STM芯片，其实更多的还是编程逻辑，希望大家多多提供好的STM32编程思想，大家多多交流！
STM32CubeMX+ADC+蓝牙串口实验
vor234的博客
07-15 2426
接触STM32单片机逐渐深入，通常从简单按键和LED控制着手，下面我们将*==凭借STM32CubeMX和keil5开发学习stm32黑色核心板，通过ADC采集和蓝牙串口打印输出实验！==*
单片机05__串口USART通信__按键控制向上位机传输字符串
qq_45821285的博客
02-25 1588
计算机与外界进行信息交换的过程称之为通信。在通信的过程中，通信双方都需要遵守的规则称之为通信协议。硬件协议：将数据以什么样的方式传输过去软件协议：将数据以什么样的顺序传输过去。
【嵌入式】——串口实验——实现芯片串口收发数据，按键中断串口发送数据，串口接收数据中断来控制LED亮/灭
qq_43748400的博客
06-12 3506
实验目的： 实现芯片串口收发数据，按键中断串口发送数据：按下按键，向串口发送数据，并通过虚拟终端显示出来； 串口接收数据中断来控制LED亮/灭：通过串口助手向MCU发送数据，“A”把LED灯点亮，“B”把LED灯熄灭。 led_key.c #include "stm32f4xx.h" #include "bitband.h" void led_init()//PD0、PD1、PD2、PD3 { GPIO_InitTypeDef d; /*使能GPIOD的时钟*/ RCC_AHB1PeriphCloc
51单片机按键通过串口发送字符串
05-15
本程序将51单片机的按键与串口发送很好的联系在一起，众所周知，如果处理不好的话可能会一次按键后，单片机不停的重复发送，且程序中应用了很好的去抖动部分，本程序在郭天祥实验板上验证过，可放心使用。
【51单片机任务】： 51单片机 按键4 控制单片机串口发送字符串到串口助手，初始化的时候led熄灭，按键4按下后单片机通过串口向上位机，发送“hello Word“字符串，同时led闪烁（任务）
嵌入式up
05-15 1181
【51单片机任务】： 51单片机 按键4 控制单片机串口发送字符串到串口助手，初始化的时候led熄灭，按键4按下后单片机通过串口向上位机，发送"hello Word"字符串，同时led闪烁（任务）
ROS2将键盘方向键控制指令通过串口发送
qq_41226644的博客
06-06 948
三、在/dev_ws/src/cpp_header/src文件夹中新建pub_serialport.cpp文件，这是串口控制函数定义文件，写入以下内容，其中 case COM3: device="/dev/pts/2";RCLCPP_INFO(this->get_logger(),"我是%s，订阅话题为：/subscribe_and_publish.",name.c_str());RCLCPP_INFO(this->get_logger(), "大家好，我是%s.", name.c_str());
STM32F103RC串口发送数据1使LED闪烁---串口助手作为主机发送数据1，单片机作为从机接收
qq_43683669的博客
05-19 1578
主要是一个函数的使用， 串口助手发送的数据1 这个是接收1 if(USART_RX_BUF[0]=='1') 主函数这样写会 接收数据1 使LED闪烁 int main(void) { u8 t; u8 len; u8 mark=0; delay_init(); //延时函数初始化 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);// 设置中断优先级分组2 uart_init(9600); //串口..
串口发送按键信息
12-11
监控mfc窗体的按键,输出相应的按键信息,包含了代码和exe文件
串口通信实验_串口通信实验_
09-30
串口通信实验
基于51单片机串口实验.docx
06-12
1）可以通过一个按键任意指定某个单片机是发送端，之后该单片机发送消 息通知另一个单片机是接收端，并且发送端在本地数码管显示“A”，接 收端显示“B”； 2）发送端依次发送 0～9 给发送端，接收端每接收一个字符...
4x4矩阵按键扫描实验 - 串口调试助手_STC15W4K58S4单片机_矩阵按键_源码
10-04
4*4矩阵编码键盘，按键按下，可发送按键值到PC机，并通过串口调试助手显示。
FPGA 按键控制串口发送
最新发布
安赫' 的博客
03-08 757
*注意：**电平信号的传输线中有一个参考电平线(一般是GND)，然后信号线上的信号值是由信号线电平和参考电平线的电压差决定。消抖时间一般为10ms，我使用的板子是ACX720，晶振为50MHZ，20ns为一周期。
MSP430按键控制串口发送数据
u010901716的专栏
06-26 4036
#include //MSP430G2553  - 使用USCI_A0,Up Mode, DCO SMCLK // //  介绍: 该程序利用USCI_A0来与计算机通信 通过接在P1.3口的按键来实现按一次发送一个数据 //  波特率9600，数据格式8N1 // //  ACLK = 32768, SMCLK = 32768  MCLK =  DCO-16M // //   
基于FPGA的串口通信，按键控制发送0~255数据
qq_56304301的博客
09-18 3105
文章目录前言本实验是基于FPGA的串口通信实验。一、实验结果二、实验步骤顶层模块串口发送模块中的累加模块波特率边沿检测实验中遇到的问题及解决办法写在最后的话 前言 本实验是基于FPGA的串口通信实验。 想要完整电路图的同学可直接可加我微信：wxid_c82ezb72s7cf22或QQ:1871478767。 一、实验结果 ①：串口发送0~255数据，通过按键来控制，按键每按下一次，就实现发送一次数据，并且数据加一。如下图所示： ②：和①大致一样，每次按键按下，数据就减一。如下图： ③：对于波特率，本次实
在串口输入input keyevent发送按键值给机器
技术交流
07-14 2360
1.adb shell进入android设备或者DEBUG串口中，执行命令input keyevent keycode即可。 例如：input keyevent 66为KEYCODE_ENTER KEYCODE和对应的数值在android源码中定义如下： /** Key code constant: Unknown key code. */ public static final int KEYCODE_UNKNOWN = 0; /** Key code constant:
158-12864lcd显示计算器键盘按键实验
05-15
158-12864液晶显示计算器是一款基于单片机控制的计算器，它采用了12864液晶屏，可以显示数字、符号和操作结果，具有高精度、可靠性和便携性等特点。本次实验旨在研究158-12864液晶显示计算器的键盘按键功能。 实验过程中，我们首先需要对计算器的各个按键进行了解和了解其作用。然后将计算器电路连接到电脑上，并利用串口通讯对计算器进行数据的接收、发送和处理。在接收到按键的信号后，我们需要对该信号进行判断，判断按下的是哪个按键，并将数字、符号或命令发送给计算器进行处理。计算器将计算结果显示在液晶屏上，供使用者查看。 通过实验，我们可以充分了解到计算器的工作原理和键盘按键的作用，熟练掌握计算器的使用方法和操作技巧，为日常生活和工作提供便利。此外，该实验还有助于培养学生的创新能力和实践能力，提高学生对计算机硬件的了解和掌握程度。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值