#FPGA（IRDA）

news2024/10/5 13:37:58

1.IDE:Quartus II

2.设备：Cyclone II  EP2C8Q208C8N  

3.实验：IRDA（仿真接收一个来自0x57地址的数据0x22  (十进制34)）

4.时序图：

 

5.步骤

6.代码：

irda_receive.v

module irda_receive
(
input      wire               sys_clk      ,
input      wire               sys_rst_n    ,
input      wire               irda_in      ,        //irda接收端引脚输入

output     reg      [19:0]     data         ,        //数据输出
output     reg                 repeat_en             //重复使能
);

/*
 *状态
 */
parameter  IDLE          =    5'b00001     ;     //空闲
parameter  TIME_9MS      =    5'b00010     ;     //引导或者重复的9ms低电平
parameter  ARBIT         =    5'b00100     ;     //地址
parameter  DATA          =    5'b01000     ;     //数据
parameter  REPEAT        =    5'b10000     ;     //重复

/*
 *时间范围
 */
parameter  CNT_560US_MIN         =        19'd20000         ; 
parameter  CNT_560US_MAX         =        19'd35000         ; 
parameter  CNT_1_69MS_MIN        =        19'd80000         ; 
parameter  CNT_1_69MS_MAX        =        19'd90000         ; 
parameter  CNT_2_25MS_MIN        =        19'd100000        ; 
parameter  CNT_2_25MS_MAX        =        19'd125000        ; 
parameter  CNT_4_5MS_MIN         =        19'd175000        ; 
parameter  CNT_4_5MS_MAX         =        19'd275000        ; 
parameter  CNT_9MS_MIN           =        19'd400000        ; 
parameter  CNT_9MS_MAX           =        19'd490000        ; 

 
/*
 *寄存器
 */
reg      [4:0]        state                ;     //状态   
reg                   inf_in_dly1          ;     //用于电平跳转判断（下一时刻）
reg                   inf_in_dly2          ;     //用于电平跳转判断（上一时刻）
wire                  inf_in_fall          ;     //下降沿标志位
wire                  inf_in_rise          ;     //上升沿标志位

reg      [18:0]       cnt                  ;     //计数器

reg                   flag_9ms             ;     //9ms标志位
reg                   flag_4_5ms           ;     //4.5ms标志位
reg                   flag_560us           ;     //560us标志位
reg                   flag_1_69ms          ;     //1.69ms标志位
reg                   flag_2_25ms          ;     //2.25ms标志位

reg      [5:0]        cnt_data             ;     //记录接收的数据个数
reg      [31:0]       data_reg             ;     //数据记录

/*
 *状态跳转
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
     if(sys_rst_n == 1'b0)
	       state <= IDLE;
	  else  case(state)
	       IDLE    :begin 
			            if(inf_in_fall == 1'b1)      //引导信号下降沿到来
			              state <= TIME_9MS;
							else
							  state <= IDLE;
						 end
			 TIME_9MS:begin
			            if((inf_in_rise == 1'b1)&&(flag_9ms == 1'b1))      //引导信号到来后持续低电平再拉高，低电平时间达到9ms（进入接收地址码状态）
							state <= ARBIT;                                   
							else if((inf_in_rise == 1'b1)&&(flag_9ms == 1'b0)) //引导信号到来后持续低电平再拉高，低电平时间未达到9ms（恢复空闲状态）
							  state <= IDLE;
							else                                             //引导信号到来后持续低电平未检测到高电平时期（还未拉高，等待中,保持状态不变）
							  state <= TIME_9MS;
		             end	
			 ARBIT   :begin
			            if((inf_in_fall==1'b1)&&(flag_2_25ms == 1'b1))     //下降沿到来接收到重复码（高电平时间未2.25ms，则为重复码，高电平时间为4.5ms则为引导码）
							  state <= REPEAT;
							else if((inf_in_fall==1'b1)&&(flag_4_5ms == 1'b1)) 
							  state <= DATA ;
							else if((inf_in_fall==1'b1)&&(flag_4_5ms == 1'b0)&&(flag_2_25ms == 1'b0))  //下降沿到来，高电平不满足2.25ms和4.5ms  
			              state <= IDLE;
							else                                               //保持原状态
							  state <= ARBIT;
						 end
			 DATA    :begin
			            if((inf_in_rise == 1'b1) && (flag_560us == 1'b0))  //数据信号低电平不满足“0”要求
							  state <= IDLE;
						   else if((inf_in_fall == 1'b1)&&(flag_560us == 1'b0)&&(flag_1_69ms == 1'b0))  //下降沿到来，但是高电平不足560us
							  state <= IDLE;
							else if((inf_in_rise == 1'b1)&&(cnt_data == 6'd32)) //结束信号是拉高，计数到32个数据
							  state <= IDLE;
							else
							  state <= DATA;
						 end		 
			 REPEAT  :begin
			            if(inf_in_rise == 1'b1)
			              state <= IDLE;
							else
							  state <= REPEAT;
						 end
			 default :begin
			            state <= IDLE; 
						 end
		    endcase	 
end

/*
 *电平翻转记录
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
     if(sys_rst_n == 1'b0)
	    begin
		    inf_in_dly1 <= 1'b0;
			 inf_in_dly2 <= 1'b0;
		 end
	  else
	    begin
		    inf_in_dly1 <= irda_in;  //记录当前电平
			 inf_in_dly2 <= inf_in_dly1; //记录上一时刻电平
		 end
end

/*
 *下降沿上升沿标志位赋值
 */
assign inf_in_fall = ((inf_in_dly1 == 1'b0)&&(inf_in_dly2 == 1'b1)) ? 1'b1 : 1'b0;  //上一时刻高电平，当前时刻低电平（下降沿标志位拉高）
assign inf_in_rise = ((inf_in_dly1 == 1'b1)&&(inf_in_dly2 == 1'b0)) ? 1'b1 : 1'b0;  //上一时刻低电平，当前时刻高电平（上升沿标志位拉高）

/*
 *cnt控制
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
	     cnt <= 19'd0;
	 else case(state)
	     IDLE         : cnt <= 19'd0;
		  TIME_9MS     :begin
		                   if((inf_in_rise == 1'b1)&&(flag_9ms == 1'b1))
								     cnt <= 19'd0;
								 else
								     cnt <= cnt + 1'b1;
							 end
		  ARBIT        :begin
		                   if((inf_in_fall == 1'b1) && ((flag_4_5ms == 1'b1)||(flag_2_25ms == 1'b1)))         //仲裁（引导信号还是重复信号）
								     cnt <= 19'd0;
								 else
								     cnt <= cnt + 1'b1;
							 end
		  DATA         :begin
		                   if((inf_in_rise == 1'b1)&&(flag_560us == 1'b1))
								     cnt <= 19'd0;
								 else if((inf_in_fall == 1'b1)&&((flag_560us == 1'b1)||(flag_1_69ms == 1'b1)))      // 0/1
								     cnt <= 19'd0;
								 else
								     cnt <= cnt + 1'b1; 
							 end
	     default      : cnt <= 19'd0;
	 endcase
end

/*
 *时间标志位控制
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
        flag_9ms <= 1'b0;
	 else if((state == TIME_9MS)&&(cnt >= CNT_9MS_MIN)&&(cnt <= CNT_9MS_MAX))
	     flag_9ms <= 1'b1;
	 else
	     flag_9ms <= 1'b0;
end

always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
        flag_4_5ms <= 1'b0;
	 else if((state == ARBIT)&&(cnt >= CNT_4_5MS_MIN)&&(cnt <= CNT_4_5MS_MAX))
	     flag_4_5ms <= 1'b1;
	 else
	     flag_4_5ms <= 1'b0;
end

always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
        flag_560us <= 1'b0;
	 else if((state == DATA)&&(cnt >= CNT_560US_MIN)&&(cnt <= CNT_560US_MAX))
	     flag_560us <= 1'b1;
	 else
	     flag_560us <= 1'b0;
end

always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
        flag_1_69ms <= 1'b0;
	 else if((state == DATA)&&(cnt >= CNT_1_69MS_MIN)&&(cnt <= CNT_1_69MS_MAX))
	     flag_1_69ms <= 1'b1;
	 else
	     flag_1_69ms <= 1'b0;
end

always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
        flag_2_25ms <= 1'b0;
	 else if((state == ARBIT)&&(cnt >= CNT_2_25MS_MIN)&&(cnt <= CNT_2_25MS_MAX))
	     flag_2_25ms <= 1'b1;
	 else
	     flag_2_25ms <= 1'b0;
end

/*
 *接收数据计数
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
	     cnt_data <= 6'd0;
	 else if((inf_in_rise == 1'b1)&&(cnt_data == 6'd32))
	     cnt_data <= 6'd0;
	 else if((inf_in_fall == 1'b1)&&(state == DATA))
	     cnt_data <= cnt_data + 1'b1;
	 else
	     cnt_data <= cnt_data;
end

/*
 *接收的数据
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
	     data_reg <= 32'b0;
	 else if((state == DATA)&&(inf_in_fall == 1'b1)&&(flag_560us == 1'b1))
	     data_reg[cnt_data] <= 1'b0;
	 else if((state == DATA)&&(inf_in_fall == 1'b1)&&(flag_1_69ms == 1'b1))
	     data_reg[cnt_data] <= 1'b1;
	 else
	     data_reg <= data_reg;
end

/*
 *数据倒排（LSB）
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
	     data <= 20'b0;
	 else if((cnt_data == 6'd32)&&(~data_reg[23:16] == data_reg[31:24])&&(~data_reg[15:8] == data_reg[7:0]))
	     data <= {12'b0,data_reg[23:16]};
	 else
	     data <= data;
end

/*
 *重复信号使能控制
 */
always @ (posedge sys_clk or negedge sys_rst_n) begin
    if(sys_rst_n == 1'b0)
	    repeat_en <= 1'b0;
	 else if((state ==REPEAT)&&(~data_reg[23:16] == data_reg[31:24]))
	    repeat_en <= 1'b1;
	 else
	    repeat_en <= 1'b0;
end

endmodule

 仿真代码:

`timescale 1ns/1ns
module tb_irda_receive();

reg        sys_clk             ;
reg        sys_rst_n           ;
reg        inf_in             ;
       
wire       [19:0]   data       ;
wire                repeat_en  ;

initial begin
           sys_clk = 1'b1;
			  sys_rst_n = 1'b0;
			  inf_in <= 1'b1;
			  #30
			  sys_rst_n <= 1'b1;
		     #1000
//引导码    
           inf_in <= 1'b0;
			  #9000_000
			  inf_in <= 1'b1;
			  #4500_000
//地址码（8'h57     0101_0111         1110_1010）
           inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
//地址反码(1110_1010     0001_0101)
           inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
//数据码(8'h22  0010_0010   0100_0100)
           inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
         
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
         
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000             //逻辑0
//数据反码(0100_0100   1011_1011)
           inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #560_000            //逻辑0
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
			  
			  inf_in <= 1'b0;
			  #560_000
			  inf_in <= 1'b1;     
			  #1690_000            //逻辑1
//结束位
           inf_in <= 1'b0;
			  #560_000
//高电平保持			  
			  inf_in <= 1'b1;
			  #4200_0000
//重复码
           inf_in <= 1'b0;
			  #9000_000
			  inf_in <= 1'b1;
			  #2250_000			
//结束位
           inf_in <= 1'b0;
			  #560_000
           inf_in <= 1'b1;			  
			end
			  
always #10 sys_clk = ~ sys_clk;

/*
 *实例化
 */
irda_receive irda_receive_inst
(
.sys_clk            (sys_clk  )    ,
.sys_rst_n          (sys_rst_n)    ,
.irda_in            (inf_in  )    ,        //irda接收端引脚输入
                              
.data               (data     )    ,        //数据输出
.repeat_en          (repeat_en)             //重复使能
);
	  
endmodule

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1469215.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

记一次生产jvm oom问题

记一次生产jvm oom问题

前言 jvm添加以下参数&#xff0c;发生OOM时自动导出内存溢出文件 -XX:HeapDumpOnOutOfMemoryError -XX:HeapDumpPath/opt 内存分析工具&#xff1a; MAT, 下载地址&#xff1a;Eclipse Memory Analyzer Open Source Project | The Eclipse Foundation&#xff0c; 注意工具地址…
阅读更多...
Uncertainty-Aware Mean Teacher（UA-MT）

Uncertainty-Aware Mean Teacher（UA-MT）

Uncertainty-Aware Mean Teacher 0 FQA:1 UA-MT1.1 Introduction:1.2 semi-supervised segmentation1.3 Uncertainty-Aware Mean Teacher Framework 参考&#xff1a; 0 FQA: Q1: 不确定感知是什么意思&#xff1f;不确定信息是啥&#xff1f;Q2&#xff1a;这篇文章的精妙的点…
阅读更多...
AI绘画工具有哪些？

AI绘画工具有哪些？

AI绘画工具是利用人工智能技术来辅助或生成艺术作品的工具。这些工具可以分为两类&#xff1a;一类是生成艺术作品的工具&#xff0c;另一类是辅助艺术创作的工具。本文将介绍一些主流的AI绘画工具&#xff0c;并分析它们的特点和适用场景。 1. DALL-E DALL-E 是由 OpenAI 开发…
阅读更多...
并发编程（5）共享模型之不可变

并发编程（5）共享模型之不可变

7 共享模型之不可变 本章内容 不可变类的使用不可变类设计无状态类设计 7.1 日期转换的问题 问题提出 下面的代码在运行时&#xff0c;由于 SimpleDateFormat 不是线程安全的, 有很大几率出现 java.lang.NumberFormatException 或者出现不正确的日期解析结果&#xff0c;…
阅读更多...
Java+SpringBoot，打造极致申报体验

Java+SpringBoot，打造极致申报体验

✍✍计算机编程指导师 ⭐⭐个人介绍&#xff1a;自己非常喜欢研究技术问题&#xff01;专业做Java、Python、微信小程序、安卓、大数据、爬虫、Golang、大屏等实战项目。 ⛽⛽实战项目&#xff1a;有源码或者技术上的问题欢迎在评论区一起讨论交流&#xff01; ⚡⚡ Java实战 |…
阅读更多...
web安全学习笔记【16】——信息打点（6）

web安全学习笔记【16】——信息打点（6）

信息打点-语言框架&开发组件&FastJson&Shiro&Log4j&SpringBoot等[1] #知识点&#xff1a; 1、业务资产-应用类型分类 2、Web单域名获取-接口查询 3、Web子域名获取-解析枚举 4、Web架构资产-平台指纹识别 ------------------------------------ 1、开源-C…
阅读更多...
东方博宜 1519. 求1~n中每个数的因子有哪些？

东方博宜 1519. 求1~n中每个数的因子有哪些？

东方博宜 1519. 求1~n中每个数的因子有哪些&#xff1f; #include<iostream> using namespace std; int main() {int n ;cin >> n ;for(int i 1 ; i < n ; i){int a[1000] ;int k 0 ;for(int j 1 ; j < i ; j){if(i%j0){a[k] j ;k ;} }cout << i …
阅读更多...
Golang Redis：构建高效和可扩展的应用程序

Golang Redis：构建高效和可扩展的应用程序

利用Redis的闪电般的数据存储和Golang的无缝集成解锁协同效应 在当前的应用程序开发中&#xff0c;高效的数据存储和检索的必要性已经变得至关重要。Redis&#xff0c;作为一个闪电般快速的开源内存数据结构存储方案&#xff0c;为各种应用场景提供了可靠的解决方案。在这份完…
阅读更多...
从docx提取文本的Python实战代码

从docx提取文本的Python实战代码

大家好，我是爱编程的喵喵。双985硕士毕业，现担任全栈工程师一职，热衷于将数据思维应用到工作与生活中。从事机器学习以及相关的前后端开发工作。曾在阿里云、科大讯飞、CCF等比赛获得多次Top名次。现为CSDN博客专家、人工智能领域优质创作者。喜欢通过博客创作的方式对所学的…
阅读更多...
限流算法

限流算法

下面对常见的限流算法进行讨论。目前&#xff0c;常用的限流算法主要有三种&#xff1a;计数器法、滑动窗口算法、漏桶算法和令牌桶算法。下面分别介绍其原理。 1. 计数器法 计数器法是通过计数对到来的请求进行选择性处理。如系统限制一秒内最多有X个请求&#xff0c;则在该…
阅读更多...
opengles 顶点坐标变换常用的矩阵(九)

opengles 顶点坐标变换常用的矩阵(九)

文章目录 前言一、opengles 常用的模型矩阵1. 单位矩阵2. 缩放矩阵3. 位移矩阵4. 旋转矩阵二、第三方矩阵数学库1. glm1.1 ubuntu 上安装 glm 库1.2 glm 使用实例1.2.1 生成一个沿Y轴旋转45度的4x4旋转矩阵, 代码实例如下1.2.2 生成一个将物体移到到Z轴正方向坐标为5处的4x4 vi…
阅读更多...
黑马JavaWeb开发跟学(一)Web前端开发HTML、CSS基础

黑马JavaWeb开发跟学(一)Web前端开发HTML、CSS基础

黑马JavaWeb开发一.Web前端开发HTML、CSS基础 引子、Web开发介绍传统路线本课程全新路线本课程适用人群课程收获一、什么是web开发二、网站的工作流程三、网站的开发模式四、网站的开发技术 前端开发基础一、前端开发二、HTML & CSS2.1 HTML快速入门2.1.1 操作第一步第二步…
阅读更多...
数据存储-文件存储

数据存储-文件存储

一、CSV文件存储 csv是python的标准库 列表数据写入csv文件 import csvheader [班级, 姓名, 性别, 手机号, QQ] # 二维数组 rows [[学习一班, 大娃, 男, a130111111122, 987456123],[学习二班, 二娃, 女, a130111111123, 987456155],[学习三班, 三娃, 男, a130111111124, …
阅读更多...
qt波位图

qt波位图

1&#xff0c;QPainter 绘制&#xff0c;先绘制这一堆蓝色的东西, 2&#xff0c;在用定时器&#xff1a;QTimer&#xff0c;配合绘制棕色的圆。用到取余&#xff0c;取整 #pragma once#include <QWidget> #include <QPaintEvent>#include <QTimer>QT_BEGIN_…
阅读更多...
基于Docker和Springboot两种方式安装与部署Camunda流程引擎

基于Docker和Springboot两种方式安装与部署Camunda流程引擎

文章目录 前言1、Docker安装1.1、拉取Camunda BPM镜像1.2、编写docker启动camunda容器脚本1.3、docker启动脚本1.4、访问验证 2、SpringBoot启动2.1、下载地址2.2、创建SpringBoot项目并配置基础信息2.3、下载SpringBoot项目并在idea中打开2.4、pom修改2.5、application.yml配置…
阅读更多...
神经网络系列---感知机(Neuron)

神经网络系列---感知机(Neuron)

文章目录 感知机(Neuron)感知机(Neuron)的决策函数可以表示为&#xff1a;感知机(Neuron)的学习算法主要包括以下步骤&#xff1a;感知机可以实现逻辑运算中的AND、OR、NOT和异或(XOR)运算。 感知机(Neuron) 感知机(Neuron)是一种简单而有效的二分类算法&#xff0c;用于将输入…
阅读更多...
pclpy Ransac平面分割算法输出的索引从点云中提取点云的子集

pclpy Ransac平面分割算法输出的索引从点云中提取点云的子集

pclpy Ransac平面分割算法输出的索引从点云中提取点云的子集 一、算法原理二、代码三、结果1.sor统计滤波2.Ransac内点分割平面3.Ransac外点分割平面 四、相关数据 一、算法原理 1、Ransac介绍 RANSAC(RAndom SAmple Consensus,随机采样一致)算法是从一组含有“外点”(outlier…
阅读更多...
第6.3章：StarRocks查询加速——Bucket Shuffle Join

第6.3章：StarRocks查询加速——Bucket Shuffle Join

目录 一、StarRocks数据划分 1.1 分区 1.2 分桶 二、Bucket Shuffle Join实现原理 2.1 Bucket Shuffle Join概述 2.2 Bucket Shuffle Join工作原理 2.3 Bucket Shuffle Join规划规则 三、应用案例 注&#xff1a;本篇文章阐述的是StarRocks-3.2版本的Bucket Shuffle Jo…
阅读更多...
计网 - 深入理解HTTPS：加密技术的背后

计网 - 深入理解HTTPS：加密技术的背后

文章目录 Pre发展历史Http VS HttpsHTTPS 解决了 HTTP 的哪些问题HTTPS是如何解决上述三个风险的混合加密摘要算法 数字签名数字证书 Pre PKI - 数字签名与数字证书 PKI - 借助Nginx 实现Https 服务端单向认证、服务端客户端双向认证 发展历史 HTTP&#xff08;超文本传输协…
阅读更多...
DAY30--learning English

DAY30--learning English

一、积累 1.budget 2.fabulous 3.strait 4.jut 5.grater 6.fillet 7.fin 8.decay 9.cartilage 10.gill 11.convex 12.concave 13.tender 14.trim 15.workload 16.knuckle 17.crevice 18.skew 19.membrane 20.delicate 二、练习 1.牛津原译 Budget /ˈbʌdʒɪt/ 1.[ CU]the…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023