乐鑫科技2020数字芯片

最新推荐文章于 2022-10-06 11:22:20 发布
最新推荐文章于 2022-10-06 11:22:20 发布
阅读量942 收藏 15
点赞数 1
分类专栏： 数字IC笔试题集锦
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gemengxia/article/details/108033119
版权

摘抄至数字芯片实验室
1、设计一个序列信号发生器电路，能在CLK信号作用下周期性输出“0010110111”的序列信号
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
2、设计一个自动饮料售卖机，共有两种饮料，其中饮料A每个10分钱，饮料B每个5分钱，硬币有5分和10分两种，并考虑找零。要求用状态机实现，定义状态，画出状态转移图，并用Verilog完整描述该模块
在这里插入图片描述

module machine(
    input clk ,
    input rst_n ,
    input[2:0] button,            //button[0]   --coin_in ；button[1]   --drink_in ；button[2]-- coin_out 
    input  coin_in ,            //0  --5 fen ；1 --10 fen
    outputreg  coin_out ,       //0  --0 fen ；1 --5 fen
    input  drink_in ,           //0  --5 fen drink ；1 --10 fen drink
    outputreg drink_out       //0  --5 fen drink ；1 --10 fen drink
 
);
 
parameter[1:0]  IDLE = 2'b00 ,  S0 = 2'b01 ,  S1 = 2'b10 ,  S2 = 2'b11 ;
reg[1:0] current_state, next_state ;
 
always@(posedge clk ornegedge rst_n) begin
    if(!rst_n) begin
        current_state <= IDLE ;
    end
    elsebegin
        current_state <= next_state ;
 
    end
end
 
reg  coin_in_reg ,drink_in_reg ;
always@(posedge clk ornegedge rst_n) begin
    if(!rst_n) begin
        coin_out <= 0 ;
        drink_out <= 0 ;
 
        coin_in_reg  <= 0 ;
        drink_in_reg <= 0 ;
    end
    elsebegin
        case(current_state)
            IDLE :begin
                coin_out <= 0 ;
                drink_out <= 0 ;
                drink_in_reg <= 0 ;
                if(button[0]) begin
                    coin_in_reg <=  coin_in ;
                end
                elsebegin
                    coin_in_reg <= 0 ;
                end
            end
            S0 :begin
                coin_out <= 0 ;
                drink_out <= 0 ;
                if(button[1]) begin
                    drink_in_reg <= drink_in;
                end
                elsebegin
                    drink_in_reg <= 0 ;
  
                end
            end
            S1 :begin
                coin_out <= 0 ;
                if(coin_in_reg>= drink_in_reg) drink_out <= drink_in_reg ;
                else                            drink_out <= 1'b0 ;
            end
            S2 :begin
                drink_out <= 0 ;
                drink_in_reg <= 0 ;
                if(button[0]) begin
                    coin_in_reg <=  coin_in ;
                end
                elsebegin
                    coin_in_reg <= 0 ;
                end
                if(coin_in_reg> drink_in_reg) coin_out <= 1'b1 ;
                else                           coin_out <= 1'b0 ;
            end
        endcase
    end
end
 
always@(*) begin
    next_state = IDLE ;
    case(current_state)
        IDLE : begin
            if(button[0]) begin
                next_state = S0 ;
            end
            elsebegin
                next_state = IDLE ;
            end
        end
        S0   : begin
            if(button[1]) begin
                next_state = S1 ;
            end
        end
        S1   : begin
            if(button[2]) begin
                next_state = S2 ;
            end
        end
        S2   : begin
            if(button[0]) begin
                next_state = S0 ;
            end
        end
    endcase
end
 
endmodule

module  machine_tb;
    reg clk ;
    reg rst_n ;
    reg[2:0] button ;
    reg coin_in ;
    wire coin_out ;
    reg drink_in ;
    wire drink_out ;
 
initialbegin
    clk = 0 ;
    rst_n = 1 ;
    button = 0 ;
    coin_in = 0 ;
    drink_in = 0 ;
    #20    rst_n = 0 ;
    #20    rst_n = 1 ;
    #30
 
    @(posedge clk ) #1
    button[0] = 1 ;
    coin_in = 1 ;
    @(posedge clk ) #1
    button[0] = 0 ;
    coin_in = 0 ;
    button[1] = 1 ;
    drink_in = 0 ; 
    @(posedge clk ) #1
    button[1] = 0 ;
    drink_in = 0 ; 
    button[2] = 1 ;
 
    @(posedge clk ) #1
    button[2] = 0 ;
    button[0] = 1 ;
    coin_in = 1 ;
    @(posedge clk ) #1
    button[0] = 0 ;
    coin_in = 0 ;

    button[1] = 1 ;
    drink_in = 1 ; 
    @(posedge clk ) #1
    button[1] = 0 ;
    drink_in = 0 ; 
    button[2] = 1 ;
 
end
 
always #10 clk = ~clk;
 
machine machine(
    .clk(clk) ,
    .rst_n(rst_n)  ,
    .button(button) ,          
    .coin_in(coin_in)  ,          
    .coin_out(coin_out) ,     
    .drink_in(drink_in) ,           
    .drink_out(drink_out)    
 
);
 
endmodule

1、 用户必须按照投币-买饮料-找零的顺序依次操作

2、 每轮购买操作中，用户只能投币一次，不然会发生吞币！（哈哈~~~）

3、 投币大小不能比购买饮料的价格小
在这里插入图片描述
3、请实现对（1011001）2的序列检测功能，模块每拍并行输入2bit，且顺序为高位先输入，当检测到序列，输出一拍高电平脉冲。请用Verilog描述该模块。
相当于检测10_11_00_1X
在这里插入图片描述

module sequence_checker_2bit(
    input clk  ,
    input rst_n,
    input[1:0] sequence_in ,
    outputreg pulse_out
);
 
parameter[2:0] IDLE = 3'b000 ,S0= 3'b001,S1= 3'b010,S2= 3'b011,S3= 3'b100  ;
 
reg[2:0] current_state,next_state ;
 
reg pulse_out_reg ;
always@(posedge clk ornegedge rst_n) begin
    if(!rst_n) begin
        current_state <= 0 ;
        pulse_out <= 0 ;
    end
    elsebegin
        current_state <= next_state ;
        pulse_out <= pulse_out_reg ;
    end
end
 
always@(*) begin
    next_state = IDLE;
    case(current_state)
        IDLE : begin
           if(sequence_in == 2'b10) next_state =S0;
            pulse_out_reg = 0 ;
        end
        S0 : begin
            if(sequence_in == 2'b11) next_state =S1;
            pulse_out_reg = 0 ;
 
        end
        S1 : begin
            if(sequence_in == 2'b00) next_state =S2;
            pulse_out_reg = 0 ;
 
        end
        S2 : begin
            if(sequence_in == 2'b10 || sequence_in == 2'b11)  begin
                next_state = S3;
                pulse_out_reg = 1 ;
            end
        end
        S3 : begin
            if(sequence_in == 2'b10) next_state =S0;
            else next_state =IDLE;
            pulse_out_reg = 0 ;
 
        end
    endcase
end
 
endmodule

module  sequence_checker_2bit_tb ;
    reg clk  ;
    reg rst_n ;
    reg[1:0]  sequence_in ;
    wire pulse_out ;
 
initialbegin
    clk = 0 ;
    rst_n = 1 ;
    sequence_in = 2'b00 ;
    #20 rst_n = 0;
    #20 rst_n = 1 ;
    @(posedge clk) #1  sequence_in = 2'b10 ;
    @(posedge clk) #1  sequence_in = 2'b11 ;
    @(posedge clk) #1  sequence_in = 2'b00 ;
    @(posedge clk) #1  sequence_in = 2'b10 ;
 
    @(posedge clk) #1
    @(posedge clk) #1
 
    @(posedge clk) #1  sequence_in = 2'b10 ;
    @(posedge clk) #1  sequence_in = 2'b11 ;
    @(posedge clk) #1  sequence_in = 2'b00 ;
    @(posedge clk) #1  sequence_in = 2'b11 ;
 
end
 
always #10 clk = ~clk;
 
sequence_checker_2bitsequence_checker_2bit(
    .clk(clk) ,
    .rst_n(rst_n),
    .sequence_in(sequence_in) ,
    .pulse_out(pulse_out)
);
 
endmodule

在这里插入图片描述
4、请基于f = 100Hz的Clock设计一个数字时钟，用Verilog实现以下功能

 1、产生时、分、秒的计时

2、可通过3个按键来设置时、分、秒值

module clock(
    input clk ,
    input rst_n ,
    input hour_set,
    input[4:0] hour_set_value,
 
    input minute_set,
    input[5:0]minute_set_value ,
 
    input second_set ,
    input  [5:0]second_set_value ,
 
    output[5:0] second_out ,
    output[5:0] minute_out ,
    output[4:0] hour_out
);
 
    reg[5:0] second_reg ;
    reg[5:0] minute_reg ;
    reg[4:0] hour_reg ;
    always@(posedge clk ornegedge rst_n ) begin
        if(!rst_n) begin
            second_reg <= 0 ;
        end
        elseif(second_set)second_reg <= second_set_value ;
        elseif(second_reg == 59) second_reg<= 0;
        else second_reg<= second_reg +1 ;
    end
 
    always@(posedge clk ornegedge rst_n ) begin
        if(!rst_n) begin
            minute_reg <= 0 ;
        end
        elseif(minute_set)minute_reg <= minute_set_value ;
        elseif(minute_reg == 59 &&second_reg == 59) minute_reg <= 0;
        elseif(second_reg == 59) minute_reg<= minute_reg +1 ;
    end
 
    always@(posedge clk ornegedge rst_n ) begin
        if(!rst_n) begin
            hour_reg <= 0 ;
        end
        elseif(hour_set)hour_reg <= hour_set_value ;
        elseif(hour_reg == 23 &&minute_reg == 59 && second_reg == 59)   hour_reg <= 0;
        elseif(minute_reg == 59 &&second_reg == 59 ) hour_reg <= hour_reg +1 ;
    end   
 
assign second_out=  second_reg ;
assign minute_out=   minute_reg;
assign hour_out =   hour_reg;
endmodule


```c
module  clock_tb ;
    reg clk ;
    reg rst_n ;
    reg hour_set ;
    reg[4:0] hour_set_value;
    reg minute_set ;
    reg[5:0]minute_set_value;
    reg second_set ;
    reg[5:0]second_set_value;
 
    wire[5:0]second_out  ;
    wire[5:0]minute_out  ;
    wire[4:0] hour_out  ;
 
initialbegin
    clk = 0 ;
    rst_n = 1 ;
    hour_set = 0 ;
    hour_set_value = 0;
    minute_set = 0 ;
    minute_set_value = 0;
    second_set = 0 ;
    second_set_value = 0;
    #10 rst_n = 0 ;
    #10 rst_n = 1 ;
 
    @(posedge clk ) #1
 
        hour_set = 1 ;
        hour_set_value= 10 ;
        minute_set = 1 ;
        minute_set_value = 10 ;
        second_set= 1 ;
        second_set_value = 10 ;
    @(posedge clk ) #1
        hour_set = 0 ;
        hour_set_value= 0 ;
        minute_set = 0 ;
        minute_set_value = 0 ;
        second_set= 0 ;
        second_set_value = 0 ;
 
end
 
    always #5 clk =~clk ;
 
 clock clock(
    .clk(clk) ,
    .rst_n(rst_n) ,
    .hour_set(hour_set) ,
    .hour_set_value(hour_set_value) ,
 
    .minute_set(minute_set),
    .minute_set_value(minute_set_value) ,
 
    .second_set(second_set),
    .second_set_value(second_set_value) ,
 
    .second_out(second_out) ,
    .minute_out(minute_out) ,
    .hour_out(hour_out)
);
 
endmodule

在这里插入图片描述
5、矩阵键盘
参考文章:

https://www.cnblogs.com/yuphone/archive/2010/11/09/1783623.html
6、将一个串行执行的C语言算法转化为单拍完成的并行可综合verilog。
C语言源码如下:

unsignedcharcal_table_high_first(unsignedcharvalue)
{
    unsigned char i ;
unsigned  char checksum = value ; 
    for (i=8;i>0;--i)
    {
        if (check_sum& 0x80)
        {
            check_sum = (check_sum<<1) ^ 0x31;
        }
        else
        {
            check_sum = (check_sum << 1);
        }
    }
    return check_sum;
}

算法C语言实现：

#include<stdio.h>
int main(){
    unsignedchar cal_table_high_first(unsignedcharvalue); 
    unsignedchar data;
    for (unsignedchar i = 0; i < 16;++i)
    {
         data= cal_table_high_first(i);
         printf("value =0x%0x：check_sum=0x%0x  \n", i, data);
    }
    getchar();
}
 
 
 
unsignedchar cal_table_high_first(unsignedcharvalue)
{
    unsignedchar i;
    unsigned  char check_sum = value;
    for (i = 8; i > 0;--i)
    {
         if (check_sum &0x80)
         {
             check_sum= (check_sum << 1) ^ 0x31;
         }
         else
         {
             check_sum= (check_sum << 1);
         }
    }
    return check_sum;
}

输出结果：

value =0x0：check_sum=0x0
value =0x1：check_sum=0x31
value =0x2：check_sum=0x62
value =0x3：check_sum=0x53
value =0x4：check_sum=0xc4
value =0x5：check_sum=0xf5
value =0x6：check_sum=0xa6
value =0x7：check_sum=0x97
value =0x8：check_sum=0xb9
value =0x9：check_sum=0x88
value =0xa：check_sum=0xdb
value =0xb：check_sum=0xea
value =0xc：check_sum=0x7d
value =0xd：check_sum=0x4c
value =0xe：check_sum=0x1f
value =0xf：check_sum=0x2e

C语言作为参考模型，用于后续Verilog的功能仿真。

该算法逻辑如下：

输入一个8bit的数，首先判断最高位是否为1，如果为1则左移一位，并且和8‘b00110001异或；如果最高位不为1则左移一位。此过程执行8次。
在这里插入图片描述
根据上述结果，可以用verilog描述。

module loop1(
   input clk,
   input rst_n,
   input [7:0] check_sum,
   output reg [7:0] check_sum_o
);
//reg [7:0] check_sum_o;
always @ (posedge clk or negedge rst_n)
       if(!rst_n)
              begin
                     check_sum_o<= 8'h0;
              end
       else
              begin
                     check_sum_o[7]<= check_sum[3]^check_sum[2]^check_sum[5];
                     check_sum_o[6]<= check_sum[2]^check_sum[1]^check_sum[4]^check_sum[7];
                     check_sum_o[5]<= check_sum[1]^check_sum[7]^check_sum[0]^check_sum[3]^check_sum[6];
                     check_sum_o[4]<= check_sum[7]^check_sum[0]^check_sum[3]^check_sum[6];
                     check_sum_o[3]<= check_sum[3]^check_sum[7]^check_sum[6];
                     check_sum_o[2]<= check_sum[2]^check_sum[6]^check_sum[5];
                     check_sum_o[1]<= check_sum[1]^check_sum[5]^check_sum[4]^check_sum[7];
                     check_sum_o[0]<= check_sum[0]^check_sum[4]^check_sum[3]^check_sum[6];
              end
      
endmodule

testbench


module loop1_tb;
reg clk;
reg rst_n;
reg [7:0] check_sum;
wire [7:0] check_sum_o;
always #1 clk=~clk;
initial
begin
clk = 0;
rst_n = 0;
#10
rst_n = 1;
for (check_sum=0;check_sum<16;check_sum=check_sum+1)
       begin
       #2
        //check_sum = i;
        $display ("check_sum = %h",check_sum_o);
        if (check_sum == 15) $stop;
       end
//$stop;
end
loop1 loop1_i1(
       .clk(clk),
       .rst_n(rst_n),
       .check_sum(check_sum),
       .check_sum_o(check_sum_o)
);
endmodule

loop2.v的实现和loop1.v类似，只是代码量更少。

module loop2(
   input clk,
   input rst_n,
   input [7:0] check_sum,
   output  reg [7:0] check_sum_o
);
integer i;
//reg [7:0] check_sum_o;
reg [7:0] ccc;
always @ (posedge clk or negedge rst_n)
       if(!rst_n)
              begin
                     check_sum_o= 8'h0;
              end
       else
              begin
           ccc = check_sum;
                     for(i=0;i<8;i=i+1)
                begin
                    ccc ={ccc[6:0],1'b0}^({8{ccc[7]}} & 8'h31);
                end
           check_sum_o = ccc;
              end
      
endmodule

其实也可以将C语言函数封装成Verilog的function,然后在在单周期内进行赋值。

module loop3(
   input clk,
   input rst_n,
   input [7:0] check_sum,
   output  reg [7:0] check_sum_o
 
);
 
integer i;
 
function [7:0] cal_table_high_first;
       input[7:0] value;
       reg[7:0] ccc ;
       reg[7:0] flag ;
              begin
                                   ccc= value;
                                   for(i=0;i<8;i=i+1)
                                          begin
                                                 flag= ccc & 8'h80 ;
                                                 if(flag!= 0 ) ccc = (ccc <<1) ^ 8'h31 ;
                                                 elseccc = (ccc <<1)  ;
                                         
                                          end
                                   cal_table_high_first= ccc;
              end
 
endfunction
 
always @ (posedge clk or negedge rst_n)
       if(!rst_n)
              begin
                     check_sum_o= 8'h0;
              end
       else
              begin
                    check_sum_o<= cal_table_high_first(check_sum) ;
              end
      
endmodule

综上，loop1.v和loop2.v的主要贡献是解开了算法实现的if-else判断。至于loop3.v中,将C语言描述的功能封装成fucntion，直接单周期完成赋值的实现方式在逻辑综合后是否增加了if-else判断语句的硬件开销不在本文讨论范围内。

这和设计者施加的时序约束和综合工具算法有关

爱吃蛋挞的Dolly
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
乐鑫提前批数字IC设计岗(20.06.09).docx
09-25
文件中包含了2020年乐鑫科技的数字IC笔试题，可以用来学习借鉴。乐鑫信息科技（上海）有限公司于2008年4月29日在自贸区市场监督管理局登记成立。公司经营范围包括计算机硬件的研究、开发，计算机软件的研发等。
乐鑫科技数字芯片2020
bleauchat的博客
07-17 4207
（1）序列发生器，产生周期性的"0010110111"序列 module xlgen (clk,rst,Q); input clk ; input rst ; output Q ; reg Q ; reg [9:0] Q_r ; always @( posedge clk or posedge rst) begin if (rst...
【ESP】乐鑫系列物联网芯片
CodeAllen嵌入式
10-06 2051
单核 CPU 时钟频率高达 240 MHz支持多种低功耗工作状态：精细时钟门控、动态电压时钟频率调节安全机制：eFuse 存储、安全启动、Flash 加密、数字签名，支持 AES、SHA 和 RSA 算法外设包括 43 个 GPIO 口，1 个全速 USB OTG 接口，SPI，I2S，UART，I2C，LED PWM，LCD 接口，Camera 接口，ADC，DAC，触摸传感器可对接丰富的网络云平台、拥有通用的产品特性，极大缩短产品构建与上市时间。
乐鑫科技2020届秋招-数字IC类真题
wczzmmp2的博客
06-28 460
乐鑫科技2020届秋招-数字IC类真题之将C语言串行处理转换为verilog并行处理
verilog学习总结及练习
weixin_42542969的博客
04-25 1671
1、一个程序模块有多个initial和always过程块，每个initial和always说明语句在仿真一开始同时立即开始执行。initial语句只执行一次，always语句则是不断循环往复的执行，所以initial过程快比较适合做变量的初始化。 2、mealy状态机与moore状态机的区别？ 前者的输出不但取决于状态还取决于输出。moore状态机只与 当前状态有关。 3、复位信号的边沿跳变与时钟...
乐鑫科技.rar
10-20
乐鑫科技是一家专注于物联网(IoT)领域的集成电路设计公司，以其高性能、低功耗的Wi-Fi和蓝牙SoC芯片解决方案而闻名。IC设计，即集成电路设计，是电子工程的一个重要分支，涉及到微小尺度上的电路设计、布局和布线，...
Arduino中乐鑫科技ESP32开发板库文件
最新发布
06-12
总结来说，"Arduino中乐鑫科技ESP32开发板库文件"提供了全面的工具和资源，使开发者能够充分利用ESP32的各种特性，轻松构建IoT项目。通过深入学习和实践这些库，可以提高开发效率，创造出更多创新的物联网解决方案。
科创板受理公司巡礼系列之（六）：乐鑫科技，IoT到AIoT，物联网芯片龙头冲刺科创板-20190421-安信证券-28页.pdf
09-01
乐鑫科技是一家专注于Wi-Fi芯片和模组领域的无晶圆厂半导体公司，成立于2008年，总部设在上海，并在全球多地设有子公司。该公司在物联网（IoT）领域有着深厚的技术积累，尤其在低功耗Wi-Fi+蓝牙双模解决方案上，通过...
wifi芯片ESP8266完全文档
01-19
这款芯片由乐鑫科技公司开发，以其强大的功能、低成本以及易用性而受到开发者和制造商的青睐。本完全文档集合了关于ESP8266的各种知识，旨在为初学者提供一个全面的学习资源。 1. ESP8266概述： ESP8266是一款集成...
序列产生器
spx1164376416的博客
04-25 4225
序列信号产生器 顾名思义，就是周期性的产生某段序列信号，这里介绍几种方法。 **第一种方法，**最容易想到的方法，设置一个长度和序列长度一样长的信号，在复位时，赋值为该段序列，接下来循环移位即可。 例 ：设计一个序列信号发生器电路，能在CLK信号作用下周期性输出“1010110111”的序列信号。 module sequence_generator( input clk , input rst_n , output out_sequence //可以根据题目要求加输出
Verilog状态机实现自动饮料售货机
06-10
使用状态机实现自动饮料售货机，一次只能投入一枚硬币，面值为1元或者5角。具有自动找零功能。
软件测试用例设计（二）——因果图和判定表的完美结合
baidu_37837739的博客
10-30 4375
因果图法和判定表法的结合使用 ——别在傻傻的用场景法了 因果图法： 关键点是找出事物之间的因果关系 我们将事物之间的这种关系划分为三种情形： （1）输入条件 （2）中间节点的状态变化 （3）输出条件 判定表法： 将表中的1表示满足条件，0表示不满足 【基础例题1】 有一个处理单价为1元5角钱的盒装饮料的自动售货机软件。若投入1元5角硬币，按下“可乐”、“雪碧”或“红茶”按钮，相应的饮料就送出来。若...
乐鑫科技数字芯片2017
bleauchat的博客
06-19 1781
1.setup time、hold time含义，并说明setup time和hold time会出现负值的原因 setup time是指在触发器的时钟信号触发之前，数据需要稳定不变的时间 hold time是指在触发器的时钟信号触发之后，数据需要稳定不变的时间 在考虑时钟skew的情况下，setup time和holdtime需要满足: T + Tskew >Ts...
乐鑫科技数字IC提前批2021
gemengxia的博客
08-17 1705
整理乐鑫科技2021届招聘的数字IC提前批笔试题，并做了部分答案和解析，有问题的地方欢迎一起探讨。 一．单选题 1.关于跨时钟域电路的设计，以下说法正确的是: A...
乐鑫提前批笔试
L_smartworld的博客
06-10 1244
题目解析： 主要考虑这么几个问题：1.输入的n和m是有范围的；2.注意有效字符和无效字符；3.就是溢出情况，大数取余；4最后就是输入输出问题（感觉题目没有说清楚） 参考代码： #include "iostream" #include "vector" #include "string" using namespace std; void check(string str, int& res, int jin_zhi, int quyu) {...
矩阵键盘的检测
Valieli的博客
09-28 1006
键盘有独立键盘和矩阵键盘两种。 下面是矩阵键盘的原理图：
乐鑫科技2022提前批-数字IC类6.29
weixin_43369700的博客
07-01 1842
1/10［单选｜3分］ 十六进制数0x12345678为big-endian格式，对应的little-endian格式是： 0x87654321 0x78563412 0x56781234 其他都不正确 2/10［单选｜3分］ X,Y是两个无符号定点小数，X的位宽 6bit,最低4bits是小数部分，最高2bits是整数部分；Y的位宽8bit,最低4bits是小数部分，最高4bits 是整数部分；现在需要计算X乘以Y的结果Z,即Z=X*Y,为了保证Z的结果不溢出，Z的整数部分和小数部分至少需要多少个bit?
乐鑫ESP8266芯片详细规格与应用指南
ESP8266芯片规格书借鉴文档详细介绍了由乐鑫信息科技于2014年12月发布的ESP8266芯片。该芯片是一款专为物联网（IoT）设计的高性能无线系统-on-chip（SoC），旨在为移动平台设计师提供经济高效的Wi-Fi功能集成解决...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值