S5PV210裸机(八):I2C

最新推荐文章于 2024-05-21 20:59:48 发布
最新推荐文章于 2024-05-21 20:59:48 发布
阅读量94 收藏
点赞数
文章标签： 嵌入式硬件 c语言 arm开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyro_wzp/article/details/134099730
版权

        本文主要探讨210的I2C相关知识。

I2C
        物理接口：SCL + SDA
        SCL：时钟线传输CLK信号(KHz)
        SDA: 数据线传输通信数据
        通信特征：串行、同步、非差分、低速率
        主设备发起通信,从设备按照I2C协议接受信息并响应
        同一设备可以是主设备,也可是从设备
        主设备可挂载多从设备（主从地址唯一）在总线上,实现一对多通信,但同一时间内主设备只能和一台从设备通信
        用途：SoC和外设间通信（EEPROM、sensor）

I2C通信时序
        时序：通信线上按时间顺序电平发生变化且变化对通信具有意义
        I2C总线状态:空闲状态、忙态
        两相邻通信周期间是空闲态(其余忙态),通信周期由起始位开始,结,中间为通信数据
        起始是时间段：SCL维持高电平,SDA由高到低
        结束是时间段：SCL维持高电平,SDA由低到高

 

210的I2C
        主设备在一通信周期广播发送8位从设备地址（7位从地址,1位表示读写，0主写1主接收）到总线,对应从设备响应
        发送方发送一段数据,接收方接收数据响应ACK(1bit),无响应则未收到
        I2C通信时每次传输有效数据都1个字节（8位）
        移位寄存器将数据一位位从SDA线上去发送/接收
        时钟源是PCLK_PSYS,内部分频得到I2C控制器CLK，通过SCL线传给从设备


       

210的I2C寄存器(SoC)

        gpio

 

 


        I2CCON + I2CSTAT：产生通信时序,I2C接口配置 ,时钟一级分频I2CCON的bit6（等于PCLK/16或者PCLK/512）二级分频系数为[1,16]：65000KHz/512/4=31KHz


       

         I2CADD：从设备地址


        I2CDS：发送/接收数据区

210的gsensor(KXTE9)
        gsensor供电由PWMTOUT3控制,低电平不工作,高电平工作
        gsensor的SDA和SCL接S5PV210的I2C端口0
        KXTE9的I2C地址为0b0001111（0x0f）,最高支持400KHz
        主设备读取gsensor信息时SAD是：0b00011111（0x1F）,读时SAD应该是：0b00011110(0x1E)

寄存器 

        CT_RESP (0x0C)    

                默认为0x55,当把CTRL_3的bit4为1，读取0xAA,第二次读自动变为0x55,用于测试通信是否成功
        CTRL_1 (0x1B)
                写入0x98,KXTE9 为操作模式（默认为待机），数据传输速率设为40Hz
        CTRL_3 (0x1D)
               CTRL_3的bit4为1，读取CT_RESP得到0xAA,第二次读自动变为0x55,用于测试通信是否成功

流程 

210的I2C通信流程


        主发送

      
        主接收


       从发送（ gsensor）


       从接收（ gsensor）


I2C通信功能(主)
        I2C控制器初始化：s3c24xx_i2c_init(初始化GPIO，设置IRQEN和ACKEN、设置时钟)

 
/* s3c24xx_i2c_init
 *
 * initialise the controller, set the IO lines and frequency
*/
 
static int s3c24xx_i2c_init(struct s3c24xx_i2c *i2c)
{
	unsigned long iicon = S3C2410_IICCON_IRQEN | S3C2410_IICCON_ACKEN;
	struct s3c2410_platform_i2c *pdata;
	unsigned int freq;
 
	/* get the plafrom data */
 
	pdata = i2c->dev->platform_data;
 
	/* inititalise the gpio */
 
	if (pdata->cfg_gpio)
		pdata->cfg_gpio(to_platform_device(i2c->dev));
 
	/* write slave address */
 
	writeb(pdata->slave_addr, i2c->regs + S3C2410_IICADD);
 
	dev_dbg(i2c->dev, "slave address 0x%02x\n", pdata->slave_addr);
 
	writel(iicon, i2c->regs + S3C2410_IICCON);
 
	/* we need to work out the divisors for the clock... */
 
	if (s3c24xx_i2c_clockrate(i2c, &freq) != 0) {
		writel(0, i2c->regs + S3C2410_IICCON);
		dev_err(i2c->dev, "cannot meet bus frequency required\n");
		return -EINVAL;
	}
 
	/* todo - check that the i2c lines aren't being dragged anywhere */
 
	dev_dbg(i2c->dev, "bus frequency set to %d KHz\n", freq);
	dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02lx\n", iicon);
 
	dev_dbg(i2c->dev, "S3C2440_IICLC=%08x\n", pdata->sda_delay);
	writel(pdata->sda_delay, i2c->regs + S3C2440_IICLC);
 
	return 0;
}


        I2C控制器开始读写：s3c24xx_i2c_message_start

 
/* s3c24xx_i2c_message_start
 *
 * put the start of a message onto the bus
*/
 
static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
				      struct i2c_msg *msg)
{
	unsigned int addr = (msg->addr & 0x7f) << 1;
	unsigned long stat;
	unsigned long iiccon;
 
	stat = 0;
	stat |=  S3C2410_IICSTAT_TXRXEN;
 
	if (msg->flags & I2C_M_RD) {
		stat |= S3C2410_IICSTAT_MASTER_RX;
		addr |= 1;
	} else
		stat |= S3C2410_IICSTAT_MASTER_TX;
 
	if (msg->flags & I2C_M_REV_DIR_ADDR)
		addr ^= 1;
 
	/* todo - check for wether ack wanted or not */
	s3c24xx_i2c_enable_ack(i2c);
 
	iiccon = readl(i2c->regs + S3C2410_IICCON);
	writel(stat, i2c->regs + S3C2410_IICSTAT);
 
	dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
	writeb(addr, i2c->regs + S3C2410_IICDS);
 
	/* delay here to ensure the data byte has gotten onto the bus
	 * before the transaction is started */
 
	ndelay(i2c->tx_setup);
 
	dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
	writel(iiccon, i2c->regs + S3C2410_IICCON);
 
	stat |= S3C2410_IICSTAT_START;
	writel(stat, i2c->regs + S3C2410_IICSTAT);
}


        I2C控制器结束读写：s3c24xx_i2c_stop

static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
{
	unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT);
 
	dev_dbg(i2c->dev, "STOP\n");
 
	/* stop the transfer */
	iicstat &= ~S3C2410_IICSTAT_START;
	writel(iicstat, i2c->regs + S3C2410_IICSTAT);
 
	i2c->state = STATE_STOP;
 
	s3c24xx_i2c_master_complete(i2c, ret);
	s3c24xx_i2c_disable_irq(i2c);
}

demo：

        编写i2c读写

start.S

#define WTCON           0xE2700000
#define SVC_STACK       0xd0037d80
 
.global _start
 
_start:
        //close watchDog
        ldr r0,=WTCON
        ldr r1,=0x0
        str r1,[r0]
 
        //init SVC stack
        ldr sp,=SVC_STACK
 
        //init icache
        mrc p15,0,r0,c1,c0,0
        bic r0,r0,#(1<<12)      //close icache
        orr r0,r0,#(1<<12)      //open icache
        mcr p15,0,r0,c1,c0,0    
 
        //use func
        bl main
 
        b .

main.c 

#include "i2c_gsensor.h"
#include "uart_printf.h"

int main()
{
        //init uart
        init_uart();

        //init i2c
        i2c_init();

        //read and write i2c
        gsensor_read_write();
        return 0;
}

uart_printf.h 

void init_uart();

uart_printf.c

#define GPA0CON         0xE0200000
 
#define ULCON0          0xE2900000
#define UCON0           0xE2900004
#define UFCON0          0xE2900008
#define UMCON0          0xE290000C
#define UTRSTAT0        0xE2900010
#define UTXH0           0xE2900020
#define URXH0           0xE2900024
#define UBRDIV0         0xE2900028
#define UDIVSLOT0       0xE290002C
 
#define rGPA0CON        (*(volatile unsigned int *)GPA0CON)
#define rULCON0         (*(volatile unsigned int *)ULCON0)
#define rUCON0          (*(volatile unsigned int *)UCON0)
#define rUFCON0         (*(volatile unsigned int *)UFCON0)
#define rUMCON0         (*(volatile unsigned int *)UMCON0)
#define rUTRSTAT0       (*(volatile unsigned int *)UTRSTAT0)
#define rUTXH0          (*(volatile unsigned int *)UTXH0)
#define rURXH0          (*(volatile unsigned int *)URXH0)
#define rUBRDIV0        (*(volatile unsigned int *)UBRDIV0)
#define rUDIVSLOT0      (*(volatile unsigned int *)UDIVSLOT0)
 
//init uart
void init_uart()
{
        //set gpio as uart(rx,tx)
        rGPA0CON &= ~(0xff);
        rGPA0CON |= ((1<<2)|(1<<5));
 
        //set uart base configure(mode)
        rULCON0 = 0x3;
        rUCON0 = 0x5;
        rUMCON0 = 0;
        rUFCON0 = 0;
 
        //set uart baud
        //DIV_VAL = (PCLK / (bps x 16))-1
        //(66000000 /(115200 * 16)) -1 = 34.8
        rUBRDIV0 = 34;
 
        //set uart baud calibration
        //0.8 * 16 = 13,check 210 table
        rUDIVSLOT0 = 0xdfdd;
}
 
 
//send data
void putc(char data)
{                  
        while (!(rUTRSTAT0 & (1<<1)));
        rUTXH0 = data;
}
 
//receive data
char getc()
{
        while (!(rUTRSTAT0 & (1<<0)));
        return (rURXH0 & 0xff);
}

 i2c_gsensor.h

void i2c_init();

void gsensor_read_write();

  i2c_gsensor.c

#include "uart_printf.h"
#include "stdio.h"

#define  GPD1CON        0xE02000C0
#define  rGPD1CON       (*(volatile unsigned int *)0xE02000C0)

#define  I2CCON0        0xE1800000
#define  I2CSTAT0       0xE1800004
#define  I2CADD0        0xE1800008
#define  I2CDS0         0xE180000C
#define  rI2CCON0       (*(volatile unsigned int *)0xE1800000)
#define  rI2CSTAT0      (*(volatile unsigned int *)0xE1800004)
#define  rI2CADD0       (*(volatile unsigned int *)0xE1800008)
#define  rI2CDS0        (*(volatile unsigned int *)0xE180000C)

#define  WRITE_GSENSOR  0x1E
#define  READ_GSENSOR   0x1F

#define  CT_RESP_ADDR   0x0C
#define  CTRL_REG2_ADDR 0x1C


static void dealy_time()
{
        volatile unsigned int num = 100;
        while(num--);
}

void i2c_init()
{
        printf("start i2c init\r\n");
        //set gpio as i2c output
        rGPD1CON &= ~(0xff);
        rGPD1CON |= (0x22);

        //enable interrupt
        rI2CCON0 |= (1<<5);

        //set i2c clock,65Mhz / 512 /2 = 31Khz
        rI2CCON0 |= (1<<6);
        rI2CCON0 &= ~(0x0f);
        rI2CCON0 |= (1<<0); 

        //enable serial output
        rI2CSTAT0 |= (1<<4);
        printf("i2c init end\r\n");
}
 
static void i2c_start_send_get(int num)
{
        //enable ack
        rI2CCON0 |= (1<<7);
        //judge send or get ,0 is send,1 is get
        if(num == 0)
        {
                //send gsensor addr and mode(read or read)
                rI2CDS0 = WRITE_GSENSOR;
                //start send
                rI2CSTAT0 = 0xF0;
        }
        else
        {
                //send gsensor addr and mode(read or read)
                rI2CDS0 = READ_GSENSOR;
                //start send
                rI2CSTAT0 = 0xB0;
        }
        //hang on  interrupt
        while((rI2CCON0 & (1<<4)) == 0);
                dealy_time();
}

static void i2c_restart_send_get(int num)
{
        //judge send or get ,0 is send,1 is get
        if(num == 0)
        {
                //send gsensor addr and mode(read or read)
                rI2CDS0 = WRITE_GSENSOR;
                //start send
                rI2CSTAT0 = 0xF0;
        }
        else
        {
                //send gsensor addr and mode(read or read)
                rI2CDS0 = READ_GSENSOR;
                //start send
                rI2CSTAT0 = 0xB0;
        }
        //clear interrupt
        rI2CCON0 &= ~(1<<4);
        //hang on  interrupt
        while((rI2CCON0 & (1<<4)) == 0);
        dealy_time();
}
 
static void i2c_send(unsigned char data)
{
        rI2CDS0 = data;
        //clear interrupt
        rI2CCON0 &= ~(1<<4);
        //hang on interrupt
        while((rI2CCON0 & (1<<4)) == 0)
                dealy_time();
}

static unsigned char i2c_get()
{
        //disable ack
        rI2CCON0 &= ~(1<<7);
        //clear interrupt
        rI2CCON0 &= ~(1<<4);
        //hang on  interrupt
        while((rI2CCON0 & (1<<4)) == 0);
                dealy_time();
        return  rI2CDS0;
}
 
static void i2c_stop_send_get(int num)
{
        //judge send or get ,0 is send,1 is get
        if(num == 0)
        {
                rI2CSTAT0 = 0xD0;
        }
        else
        {
                rI2CSTAT0 = 0x90;
        }
        //clear interrupt
        rI2CCON0 &= ~(1<<4);
        dealy_time();
}

void gsensor_read_write()
{
        printf("start read\r\n");
        volatile unsigned char get = 0; 

        i2c_start_send_get(0);
        i2c_send(CT_RESP_ADDR);
        i2c_restart_send_get(1);
        get = i2c_get();
        i2c_stop_send_get(0);
        printf("CT_RESP :0x%x\r\n",get);
        printf("start read end\r\n",get);

        printf("start write end\r\n",get);
        i2c_start_send_get(0);
        i2c_send(CTRL_REG2_ADDR);
        i2c_restart_send_get(1);
        get = i2c_get();
        i2c_stop_send_get(0);
        printf("before wrtie ,CTRL_REG2 :0x%x\r\n",get);

        printf("wrting 0xbc to CTRL_REG2\r\n");
        i2c_start_send_get(0);
        i2c_send(CTRL_REG2_ADDR);
        i2c_send(0xbc);
        i2c_restart_send_get(1);

        i2c_start_send_get(0);
        i2c_send(CTRL_REG2_ADDR);
        i2c_restart_send_get(1);
        get = i2c_get();
        i2c_stop_send_get(0);
        printf("after wrtied,CTRL_REG2 :0x%x\r\n",get);

}

 

link.lds 

SECTIONS
{
        . = 0xd0020010;
 
        .text : 
        {
                start.o
                * (.text)
        }
    
        .data : 
        {
                * (.data)
        }
 
        bss_start = .;
 
        .bss : 
        {
                * (.bss)
        }
}

Makefile

 

CC      =       arm-linux-gcc
LD      =       arm-linux-ld
OBJCOPY =       arm-linux-objcopy
OBJDUMP =       arm-linux-objdump
 
INCDIR  := $(shell pwd)
 
#预处理器的flag，flag就是编译器可选的选项
CPPFLAGS  := -nostdlib -nostdinc -I$(INCDIR)/include
#C编译器的flag
CFLAGS    := -Wall -O2 -fno-builtin
 
export CC LD OBJCOPY OBJDUMP CPPFLAGS CFLAGS
 
objs      := start.o uart_printf.o main.o i2c_gsensor.o
objs      += lib/libc.a
 
led.bin:$(objs)
        $(LD) -Tlink.lds -o i2c.elf $^
        $(OBJCOPY) -O binary i2c.elf i2c.bin
        $(OBJDUMP) -D i2c.elf > i2c.dis
        gcc mkv210.c -o mkv210
        ./mkv210 i2c.bin sd.bin
 
lib/libc.a:
        cd lib;  make;  cd ..
 
%.o:%.S
        $(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $< -c
 
%.o:%.c
        $(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $< -c
 
clean:
        rm *.o *.elf *.bin *.dis mkv210 -f
        cd lib; make clean; cd ..

文件示例:

结果示例： 

菜_小_白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
s5pv210-spi.rar_s5pv210 spi_s5pv210-spi_s5pv210裸机SPI
09-14
基于S5PV210的SPI控制器设置，可以实现SPI的发送和接收数据，可以设置数据位宽
S5PV210 天嵌E8 裸机实验例程
03-14
天嵌E8 S5PV210 裸机例程 代码来自朱有鹏嵌入式Linux核心课程-ARM裸机篇，经过小修改可在天嵌E8卡片电脑上运行 已包含添加头部校验信息的程序。 写入方法见write2sd或者直接sudo dd iflag=dsync oflag=dsync if=210.bin of=/dev/sdb seek=1 1.leds_s 10.wdt_reset 11.wdt_interrupt 12.adc 13.sd_relocate 2.set_sp_c 3.icache 4.sram_relocate 5.ddr2_init 6.clock_init_c 6.clock_init_s 7.uart_c 8.key_interrupt 9.pwm 使用的交叉编译器： gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabihf.tar.xz 下载地址：http://releases.linaro.org/components/toolchain/binaries/latest-4/arm-linux-gnueabihf/
No-OS().rar_S5PV210 裸机_s5pv210 裸
09-24
基于linux操作系统下的裸机开发程序在s5pv210开发板上实现的。
s5pv210裸机开发
04-30
s5pv210裸机开发，从最基本的编译环境，到各个外设的驱动编写，深入到rtos，嵌入式gui， 文件系统，网络协议等等中间件的移植及应用
s5pv210外部中断裸机程序
09-24
实现了按键外部中断，裸机程序，可以直接运行，下载到SD卡里运行。
嵌入式硬件中PCB走线与过孔的电流承载能力分析
嵌入式技术开发
05-03 2007
此外测试板的设计和实验方案的设计为理想状态，而实际产品的安装位置不同，产品上的元器件分布的不同，布线的密集度以及使用基材的不同，都是测试板无法模拟的，所以分析数据不能直接指导设计。文中介绍设计和测试FR4敷铜板上走线和过孔的电流承载能力的方案和测试结果，其测试结果可以为设计人员在今后的设计中提供一定的借鉴，使PCB设计更合理、更符合电流要求。由于不同产品、不同模块电流大小不同，为实现各个功能，设计人员需要知道所设计的走线和过孔能否承载相应的电流，以实现产品的功能，防止过流时产品烧毁。测试板PCB分三组。
比大小（打擂台）（C语言）
m0_67184754的博客
05-14 215
【代码】比大小（打擂台）（C语言）
c语言：递归与迭代
qq_58761784的博客
05-14 1090
它却没有得出结果，这是为什么呢，因为，函数在内部多次调用了自己，产生了大量的重复计算，导致计算量巨大，代码执行效率非常低，让计算机也无法快速得出结果，这个例子告诉我们，递归是有使用条件的 ，如果要设计一个需要重复计算的程序，不能无脑使用递归，而是首先要思考递归能不能用，是否能让代码简洁的同时，更加高效，那么此类例子我们如何解决呢？可以看到，很快就得到了结果，但是答案是错误的，因为要求的数太大，一个字节无法表示，但是我们可以很直观的看见两者的差别，在这这样一个例子中，使用迭代会优于使用递归。
手撕C语言题典——链表的中间节点
Antigonos的博客
05-14 402
链表的中间节点同样也是力扣上一道简单题，适合刚学过单链表的我们更好的理解链表相关知识~
Android广播+定时管理器AlarmManager笔记
2303_76230584的博客
05-18 304
setAndAllowWhiledle:设置一次性的定时器，即使设备属于空闲状态，也会保证定时器的执行。setRepeating:设置重复的定时器，但系统部不保证能按时发送广播。1、定时管理器AlarmManager利用系统 闹钟定时发送广播。cancel：取消指定延迟的 定时器。set:设置一次性的定时器；
OpenHarmony 实战开发——ArkUI容器类API介绍
maniuT的博客
05-15 405
在 ArkUI 开发框架中，提供了线性和非线性两类容器类，共 14 种，每种容器都有自身的特性及使用场景。下面，我们将为大家一一道来。1.1线性容器类线性容器类底层主要通过数组实现，包括 ArrayList、Vector、List、LinkedList、Deque、Queue、Stack 七种。线性容器类 API，充分考虑了数据访问的速度，实现了运行时（Runtime）通过一条指令就可以完成增删改查等操作。ArrayList 即动态数组，可用来构造全局的数组对象。
arm-day6控制灯
最新发布
weixin_51648475的博客
05-21 467
i--)//20的递减，可改成while（1）成死循环流水灯。= '\0') && (*str1 == *str2))//判断字符串是否结束。int my_strcmp(char* str1, char* str2)//strcmp函数具体实现。(my_strcmp("close",buf)))//关闭。(my_strcmp("11",buf)))//流水灯。(my_strcmp("open",buf)))//打开。//比较对应字符大小。//手动补上一个'\0'//阻塞等待数据发送完毕，函数结束。
对OpenHarmony中LiteOS的内核分析——超时原理和应用
maniuT的博客
05-17 671
在软件世界里面，超时是一个非常重要的概念。比如● 当前线程暂时休眠1秒钟，休眠结束后继续执行● 每5秒钟采集一下CPU利用率● 数据发送失败，2秒钟以后再试一试● 等待某种数据，但最多等待50毫秒本文描述了超时逻辑在OpenHarmony中的实现，从原理，使用以及具体实现细节上进行了详尽讨论，并归纳整理了当前这种实现方式所带来的益处。搭建开发环境Windows 开发环境的搭建Ubuntu 开发环境搭建Linux 与 Windows 之间的文件共享……构建子系统启动流程子系统。
ARM day3
weixin_69331128的博客
05-21 188
【代码】ARM day3。
OpenHarmony 实战开发——智能指南针
maniuT的博客
05-17 1003
电子指南针是现代的一种重要导航工具，大到飞机船舶的导航，小到个人手机导航，电子指南针可以说和咱们生活息息相关，密不可分。为什么电子指南针能指示方向？本 Demo 将为你呈现，其中蕴含了人类智慧及大自然的奥妙。本项目分为数据采集端（设备端）和效果展示端（应用端）：1、指南针数据采集端：使用的是 Geek_Lite_Board 开发板，其内置了三轴磁力计 AK8963，通过解析磁力计数据获得指南针数据信息，操作系统版本为 OpenAtom OpenHarmony 3.0（以下简称“OpenHarmony”）
OpenHarmony 实战开发——CircleIndicator组件，使指示器风格更加多样化
maniuT的博客
05-18 996
CircleIndicator组件UI效果展示圆形指示器：长条指示器：横幅指示器：三角指示器：图标指示器：携带中央视图的Tabs指示器：固定位置Tabs指示器：固定位置Tabs指示器（胶囊风格）:固定位置Tabs指示器（携带角标）:可滑动Tabs指示器：可滑动Tabs指示器(水滴滑块)：可滑动Tabs指示器(首列固定)：什么是CircleIndicator？CircleIndicator顾名思义，它指的是圆形指示器。
嵌入式软件工程师笔试面试指南-ARM体系与架构
weixin_54140739的博客
05-18 627
在一种计算机环境中运行的编译程序，能编译出在。
OpenHarmony Camera源码分析
maniuT的博客
05-21 689
相机组件支持相机业务的开发，开发者可以通过已开放的接口实现相机硬件的访问、操作和新功能开发，最常见的操作如：预览、拍照和录像等。相机框架中主要包含会话管理、设备输入和数据输出，设备的输入和数据的输出配置都是在采集会话中完成，会话管理模块管理相机设备输入和数据输出。应用层在调用相机功能时，首先需要创建采集会话，在配置会话的过程中会将创建的设备输入和数据输出添加到采集会话中。
Linux程序开发（七）：alarm /setitimer 编写文字时钟程序
m0_60732994的博客
05-18 602
1. 问答题 1.1. 简述什么是可靠信息和不可靠信息，并试验验证SIGINT是可靠还是不可靠信息。 2. 编程题 2.1. 编写程序实现如下功能： 2.2. 编写一个程序，实现以下功能：由父进程创建两个子进程，通过在终端输入“Ctrl+\”组合键向父进程发送SIGQUIT信号；父进程接收到这个信号后，向其两个子进程分别发送整数值为35的信号，子进程获得对应的信号后，终止运行；父进程调用wait函数等待两个子进程都终止后，再自我终止。 2.3. 编写一个程序，实现以下功能： 2.4. 利用alarm函数（也
s5pv210移植qt
01-22
s5pv210是一款嵌入式处理器，而Qt是一个跨平台的C++应用程序开发框架。将Qt移植到s5pv210处理器上，可以为嵌入式设备开发运行Qt应用程序提供支持。具体移植过程包括以下几个步骤： 首先，需要配置交叉编译环境，即...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值