adc与触摸屏调试记录

最新推荐文章于 2024-06-03 14:58:05 发布
最新推荐文章于 2024-06-03 14:58:05 发布
阅读量191 收藏
点赞数
原文链接：http://www.cnblogs.com/-song/archive/2012/06/02/3331870.html
版权
2440触摸屏原理

原理看了下面这张图就知道了

图中虚线表示屏被按压时x方向和y方向的电阻线会在按压的位置短接。
在操作触摸屏的寄存器测量屏幕坐标时，由触摸屏控制器自动开或关S1---S5

6410相比2440的触摸屏硬件接口没有变化，但中断系统有变化。

NOTE
When Touch Screen device is used, XM or YM is only connected to ground for Touch Screen I/F.

When Touch Screen device is not used, XM or YM is connecting Analog Input Signal for Normal ADC conversion



refer to
http://blog.chinaunix.net/uid-18921523-id-107097.html



************************************************
ok6410 linux2.6.36.2
adc 配置
Device Drivers  --->Character devices  ---><M> ADC driver for 6410
/drivers/char/adc.c

触摸屏配置
Device Drivers  --->Input device support  --->   [*]   Touchscreens  ---><*>   S3C touchscreen driver
drivers/input/touchscreen/s3c-ts.c

飞凌提供的内核，ad和触摸屏不能共同使用，甚至将adc.c编译成模块，在insmod时都会出现
[root@FORLINX6410]# insmod /mnt/adc.ko
insmod: cannot insert '/mnt/adc.ko': Device or resource busy
经过排查发现是adc.c在注册中断时报的错
    ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
原来在s3c-ts.c已经独自的注册了这个中断，
ret = request_irq(ts_irq->start, stylus_action, IRQF_SAMPLE_RANDOM, "s3c_action", ts);
加上中断号共享标志，如下，重新编译下载即可
ret = request_irq(ts_irq->start, stylus_action, IRQF_SAMPLE_RANDOM|IRQF_SHARED, "s3c_action", ts);

还有问题是ok6410的rmmod不管用，解决方法是建立目录/lib/modules/2.6.36.2

[root@FORLINX6410]# rmmod adc
rmmod: chdir(/lib/modules): No such file or directory

此时建立modules目录
[root@FORLINX6410]# cd /lib
[root@FORLINX6410]# mkdir modules
[root@FORLINX6410]# rmmod adc
rmmod: chdir(2.6.36.2): No such file or directory

此时建立2.6.36.2，即可卸载成功。使用modprobe -r  adc卸载也可以。
[root@FORLINX6410]#  cd modules/
[root@FORLINX6410]# mkdir 2.6.36.2
[root@FORLINX6410]# rmmod adc
rmmod: module 'adc' not found


使用ok6410的8个ai通道
首先把触摸屏驱动取消掉--在feiling给的2.6.36内核，需要在板子文件mach-smdk6410.c中注释掉两处触摸屏的部分，否则如果不把触摸屏搞进内核，编译不通过。
改动adc.c文件，init中注释掉ADCTSC = 0否则ai5和ai7不正常，加入ioctl函数。其他不必变。但是我把read函数也改了一下，去掉了sscanf和20自字节的str数组，直接将value拷给用户，为调用进程省了20字节的栈空间。
 
//adc8_driver.c
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>

#include <mach/map.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>
#include <plat/regs-timer.h>
#include <plat/regs-adc.h>

#define DEBUG  
#ifdef DEBUG    
#define DBG(...) printk(" DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); printk(__VA_ARGS__)    
#else    
#define DBG(...)    
#endif    
#define DEVICE_NAME    "adc"

static void __iomem *base_addr;

typedef struct {
    wait_queue_head_t wait;
    int channel;
    int prescale;
} ADC_DEV;

#ifdef CONFIG_TOUCHSCREEN_X6410
extern int X6410_adc_acquire_io(void);
extern void X6410_adc_release_io(void);
#else
static inline int X6410_adc_acquire_io(void) {
    return 0;
}
static inline void X6410_adc_release_io(void) {
    /* Nothing */
}
#endif

static int __ADC_locked = 0;

static ADC_DEV adcdev;
static volatile int ev_adc = 0;
static int adc_data;

static struct clk    *adc_clock;

#define __ADCREG(name)    (*(volatile unsigned long *)(base_addr + name))
#define ADCCON            __ADCREG(S3C_ADCCON)    // ADC control
#define ADCTSC            __ADCREG(S3C_ADCTSC)    // ADC touch screen control
#define ADCDLY            __ADCREG(S3C_ADCDLY)    // ADC start or Interval Delay
#define ADCDAT0            __ADCREG(S3C_ADCDAT0)    // ADC conversion data 0
#define ADCDAT1            __ADCREG(S3C_ADCDAT1)    // ADC conversion data 1
#define ADCUPDN            __ADCREG(S3C_ADCUPDN)    // Stylus Up/Down interrupt status

#define PRESCALE_DIS        (0 << 14)
#define PRESCALE_EN            (1 << 14)
#define PRSCVL(x)            ((x) << 6)
#define ADC_INPUT(x)        ((x) << 3)
#define ADC_START            (1 << 0)
#define ADC_ENDCVT            (1 << 15)

#define START_ADC_AIN(ch, prescale) \
    do { \
        ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
        ADCCON |= ADC_START; \
    } while (0)


static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
{
    if (__ADC_locked) {
        adc_data = ADCDAT0 & 0x3ff;

        ev_adc = 1;
        wake_up_interruptible(&adcdev.wait);

        /* clear interrupt */
        __raw_writel(0x0, base_addr + S3C_ADCCLRINT);
    }

    return IRQ_HANDLED;
}

static ssize_t s3c2410_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
    int value;
    size_t len=sizeof(value);

    if (X6410_adc_acquire_io() == 0) {
        __ADC_locked = 1;

        START_ADC_AIN(adcdev.channel, adcdev.prescale);

        wait_event_interruptible(adcdev.wait, ev_adc);
        ev_adc = 0;

        DBG("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ADCCON & 0x80 ? 1:0);

        value = adc_data;

        __ADC_locked = 0;
        X6410_adc_release_io();
    } else {
        value = -1;
    }

    if (count != len) {
    count=len;        
    };
    int r = copy_to_user(buffer, &value, len);
    DBG("len=%d,count=%d,r=%d\n",len,count,r);
    return r ? r : len;//if r=0,then return len
}

static int s3c2410_adc_open(struct inode *inode, struct file *filp)
{
    init_waitqueue_head(&(adcdev.wait));

    adcdev.channel=0;
    adcdev.prescale=0xff;

    DBG("adc opened\n");
    return 0;
}
//static int s3c2410_adc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
static long s3c2410_adc_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
    DBG("\n");
    DBG("cmd=%d,arg=%lx\n", cmd, arg);
    switch (cmd)
     {
    case 0:
        adcdev.channel=arg;
        DBG("adcdev.channel= %x\n",adcdev.channel);
        break;
    defalut:
        DBG("case defalut\n");
        return -EINVAL;
        break;
    }
    return 0;
}
static int s3c2410_adc_release(struct inode *inode, struct file *filp)
{
    DBG("adc closed\n");
    return 0;
}


static struct file_operations dev_fops = {
    owner:    THIS_MODULE,
    open:    s3c2410_adc_open,
    read:    s3c2410_adc_read,
    unlocked_ioctl:  s3c2410_adc_ioctl,    
    release:    s3c2410_adc_release,
};

static struct miscdevice misc = {
    .minor    = MISC_DYNAMIC_MINOR,
    .name    = DEVICE_NAME,
    .fops    = &dev_fops,
};

static int __init dev_init(void)
{
    int ret;

    base_addr = ioremap(SAMSUNG_PA_ADC, 0x20);
    if (base_addr == NULL) {
        printk(KERN_ERR "Failed to remap register block\n");
        return -ENOMEM;
    }

    adc_clock = clk_get(NULL, "adc");
    if (!adc_clock) {
        printk(KERN_ERR "failed to get adc clock source\n");
        return -ENOENT;
    }
    clk_enable(adc_clock);
    
    /* normal ADC */
    //ADCTSC = 0;

    ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
    if (ret) {
        iounmap(base_addr);
        return ret;
    }
    printk (DEVICE_NAME"\therr\n");

    ret = misc_register(&misc);

    printk (DEVICE_NAME"\tinitialized\n");
    return ret;
}

static void __exit dev_exit(void)
{
    free_irq(IRQ_ADC, &adcdev);
    iounmap(base_addr);

    if (adc_clock) {
        clk_disable(adc_clock);
        clk_put(adc_clock);
        adc_clock = NULL;
    }

    misc_deregister(&misc);
}

module_init(dev_init);
module_exit(dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Forlinx Inc.");




//adc_app.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <errno.h>

#define DEBUG
#ifdef DEBUG  
#define DBG(...) fprintf(stderr, " DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); fprintf(stderr, __VA_ARGS__)  
#else  
#define DBG(...)  
#endif  


int main()
{
	int fd,ret,i;
	int value[8]={0};
	int len=sizeof(value[0]);
	fd = open("/dev/adc", 0);
	if (fd < 0) {
	    exit(1);
	 }

//while(1){
//printf("\n");
	for(i=0;i<8;i++) {

		ret = ioctl(fd,0,i);//cmd,arg(channel)
		if(ret < 0) {
		perror("ioctl ADC error");
		exit(1);
		}

		int ret = read(fd, &value[i],len);
		if(ret==len)  
		{
			printf("ADC %d Value: %d,len=%d\n", i,value[i],len);
		}
	 }
//}

      return 0;

}
专业一点的话，就使用_IOW()构造设置通道的命令。类型使用0xfe，貌似在documentation/ioctl-number.c中还没被占用。驱动重写为 
//adc8_driver.c
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/init.h>
#include <linux/errno.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/wait.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <linux/miscdevice.h>

#include <asm/io.h>
#include <asm/irq.h>
#include <asm/uaccess.h>

#include <mach/map.h>
#include <mach/regs-clock.h>
#include <mach/regs-gpio.h>
#include <plat/regs-timer.h>
#include <plat/regs-adc.h>

#define DEBUG  
#ifdef DEBUG    
#define DBG(...) printk(" DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); printk(__VA_ARGS__)    
#else    
#define DBG(...)    
#endif    
#define DEVICE_NAME	"adc"

#define ADC8_IOC_MAGIC 0xfe  //类型，0xfe代表adc8设备
#define ADC8_IOC_SELECT_CHANNEL _IOW(ADC8_IOC_MAGIC,0,int)  //第0个命令是选择通道

static void __iomem *base_addr;

typedef struct {
	wait_queue_head_t wait;
	int channel;
	int prescale;
} ADC_DEV;

#ifdef CONFIG_TOUCHSCREEN_X6410
extern int X6410_adc_acquire_io(void);
extern void X6410_adc_release_io(void);
#else
static inline int X6410_adc_acquire_io(void) {
	return 0;
}
static inline void X6410_adc_release_io(void) {
	/* Nothing */
}
#endif

static int __ADC_locked = 0;

static ADC_DEV adcdev;
static volatile int ev_adc = 0;
static int adc_data;

static struct clk	*adc_clock;

#define __ADCREG(name)	(*(volatile unsigned long *)(base_addr + name))
#define ADCCON			__ADCREG(S3C_ADCCON)	// ADC control
#define ADCTSC			__ADCREG(S3C_ADCTSC)	// ADC touch screen control
#define ADCDLY			__ADCREG(S3C_ADCDLY)	// ADC start or Interval Delay
#define ADCDAT0			__ADCREG(S3C_ADCDAT0)	// ADC conversion data 0
#define ADCDAT1			__ADCREG(S3C_ADCDAT1)	// ADC conversion data 1
#define ADCUPDN			__ADCREG(S3C_ADCUPDN)	// Stylus Up/Down interrupt status

#define PRESCALE_DIS		(0 << 14)
#define PRESCALE_EN			(1 << 14)
#define PRSCVL(x)			((x) << 6)
#define ADC_INPUT(x)		((x) << 3)
#define ADC_START			(1 << 0)
#define ADC_ENDCVT			(1 << 15)

#define START_ADC_AIN(ch, prescale) \
	do { \
		ADCCON = PRESCALE_EN | PRSCVL(prescale) | ADC_INPUT((ch)) ; \
		ADCCON |= ADC_START; \
	} while (0)


static irqreturn_t adcdone_int_handler(int irq, void *dev_id)
{
	if (__ADC_locked) {
		adc_data = ADCDAT0 & 0x3ff;

		ev_adc = 1;
		wake_up_interruptible(&adcdev.wait);

		/* clear interrupt */
		__raw_writel(0x0, base_addr + S3C_ADCCLRINT);
	}

	return IRQ_HANDLED;
}

static ssize_t s3c2410_adc_read(struct file *filp, char *buffer, size_t count, loff_t *ppos)
{
	int value;
	size_t len=sizeof(value);

	if (X6410_adc_acquire_io() == 0) {
		__ADC_locked = 1;

		START_ADC_AIN(adcdev.channel, adcdev.prescale);

		wait_event_interruptible(adcdev.wait, ev_adc);
		ev_adc = 0;

		DBG("AIN[%d] = 0x%04x, %d\n", adcdev.channel, adc_data, ADCCON & 0x80 ? 1:0);

		value = adc_data;

		__ADC_locked = 0;
		X6410_adc_release_io();
	} else {
		value = -1;
	}

	if (count != len) {
	count=len;		
	};
	int r = copy_to_user(buffer, &value, len);
	DBG("len=%d,count=%d,r=%d\n",len,count,r);
	return r ? r : len;//if r=0,then return len
}

static int s3c2410_adc_open(struct inode *inode, struct file *filp)
{
	init_waitqueue_head(&(adcdev.wait));

	adcdev.channel=0;
	adcdev.prescale=0xff;

	DBG("adc opened\n");
	return 0;
}
//static int s3c2410_adc_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
static long s3c2410_adc_ioctl(struct file *filep, unsigned int cmd, unsigned long arg)
{
    DBG("\n");
    DBG("cmd=%d,arg=%lx\n", cmd, arg);
    DBG("ADC8_IOC_SELECT_CHANNEL=%d\n",ADC8_IOC_SELECT_CHANNEL);
    switch (cmd)
     {
	case ADC8_IOC_SELECT_CHANNEL:
		adcdev.channel=arg;
		DBG("adcdev.channel= %x\n",adcdev.channel);
		break;
	defalut:
		DBG("case defalut\n");
		return -EINVAL;
        break;
    }
    return 0;
}
static int s3c2410_adc_release(struct inode *inode, struct file *filp)
{
	DBG("adc closed\n");
	return 0;
}


static struct file_operations dev_fops = {
	owner:	THIS_MODULE,
	open:	s3c2410_adc_open,
	read:	s3c2410_adc_read,
	unlocked_ioctl:  s3c2410_adc_ioctl,	
	release:	s3c2410_adc_release,
};

static struct miscdevice misc = {
	.minor	= MISC_DYNAMIC_MINOR,
	.name	= DEVICE_NAME,
	.fops	= &dev_fops,
};

static int __init dev_init(void)
{
	int ret;

	base_addr = ioremap(SAMSUNG_PA_ADC, 0x20);
	if (base_addr == NULL) {
		printk(KERN_ERR "Failed to remap register block\n");
		return -ENOMEM;
	}

	adc_clock = clk_get(NULL, "adc");
	if (!adc_clock) {
		printk(KERN_ERR "failed to get adc clock source\n");
		return -ENOENT;
	}
	clk_enable(adc_clock);
	
	/* normal ADC */
	//ADCTSC = 0;

	ret = request_irq(IRQ_ADC, adcdone_int_handler, IRQF_SHARED, DEVICE_NAME, &adcdev);
	if (ret) {
		iounmap(base_addr);
		return ret;
	}
	printk (DEVICE_NAME"\therr\n");

	ret = misc_register(&misc);

	printk (DEVICE_NAME"\tinitialized\n");
	return ret;
}

static void __exit dev_exit(void)
{
	free_irq(IRQ_ADC, &adcdev);
	iounmap(base_addr);

	if (adc_clock) {
		clk_disable(adc_clock);
		clk_put(adc_clock);
		adc_clock = NULL;
	}

	misc_deregister(&misc);
}

module_init(dev_init);
module_exit(dev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Forlinx Inc.");
用户中也使用_IOW()构造命令 
//adc_app.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <errno.h>

#define DEBUG
#ifdef DEBUG  
#define DBG(...) fprintf(stderr, " DBG(%s, %s(), %d): ", __FILE__, __FUNCTION__, __LINE__); fprintf(stderr, __VA_ARGS__)  
#else  
#define DBG(...)  
#endif  


#define ADC8_IOC_MAGIC 0xfe
#define ADC8_IOC_SELECT_CHANNEL _IOW(ADC8_IOC_MAGIC,0,int)

int main()
{
	int fd,ret,i;
	int value[8]={0};
	int len=sizeof(value[0]);
	fd = open("/dev/adc", 0);
	if (fd < 0) {
	    exit(1);
	 }

//while(1){
//printf("\n");
	for(i=0;i<8;i++) {
		ret = ioctl(fd,ADC8_IOC_SELECT_CHANNEL,i);//cmd,arg
		DBG("ADC8_IOC_SELECT_CHANNEL=%d\n",ADC8_IOC_SELECT_CHANNEL);
		if(ret < 0) {
		perror("ioctl ADC error");
		exit(1);
		}

		int ret = read(fd, &value[i],len);
		if(ret==len)  
		{
			printf("ADC %d Value: %d,len=%d\n", i,value[i],len);
		}
	 }
//}

      return 0;

}
执行 
[root@FORLINX6410]# /mnt/adc_app
 DBG(drivers/char/adc.c, s3c2410_adc_open(), 140): adc opened
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 0
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[0] = 0x030d, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=1
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[1] = 0x0129, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=2
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 2
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[2] = 0x00b9, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=3
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 3
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[3] = 0x00a9, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=4
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 4
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[4] = 0x0081, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=5
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 5
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[5] = 0x0131, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=6
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 6
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[6] = 0x0090, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 146): 
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 147): cmd=1074068992,arg=7
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 148): ADC8_IOC_SELECT_CHANNEL=1074068992
 DBG(drivers/char/adc.c, s3c2410_adc_ioctl(), 153): adcdev.channel= 7
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 115): AIN[7] = 0x0121, 1
 DBG(drivers/char/adc.c, s3c2410_adc_read(), 129): len=4,count=4,r=0
 DBG(drivers/char/adc.c, s3c2410_adc_release(), 164): adc closed
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 0 Value: 781,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 1 Value: 297,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 2 Value: 185,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 3 Value: 169,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 4 Value: 129,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 5 Value: 305,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 6 Value: 144,len=4
 DBG(adc_app.c, main(), 40): ADC8_IOC_SELECT_CHANNEL=1074068992
ADC 7 Value: 289,len=4



多说一点，6410的adc分辨率是10位或者12位的，可以通过ADCCON.16来配置
RESSEL [16]
 A/D converter resolution selection
0 = 10-bit A/D conversion
1 = 12-bit A/D conversion
不同分辨率时，结果数据在ADCDAT0占用的位数不一样。10位分辨率时用到10位，12位分辨率时用到12位。上面程序用的是10位分辨率。
XPDATA_12[11:10]         When A/D resolution is 12bit, this is X-position conversion data [11:0] value.
XPDATA(Normal ADC)[9:0]  X-Position Conversion data value (Includes Normal ADC Conversion data value)  Data value : 0x0 ~ 0x3FF
电压和测量数据对应关系：
10位分辨率时：0-3.3------>0-1023
12位分辨率时：0-3.3------>0-4095


关于分辨率和精度的区别：
http://bbs.ednchina.com/BLOG_ARTICLE_2058763.HTM

简单点说，“精度”是用来描述物理量的准确程度的，而“分辨率”是用来描述刻度划分的。从定义上看，这两个量应该是风马牛不相及的。（是不是有朋友感到愕然^_^）。很多卖传感器的JS就是利用这一点来糊弄人的了。简单做个比喻：有这么一把常见的塑料尺（中学生用的那种），它的量程是10厘米，上面有100个刻度，最小能读出1毫米的有效值。那么我们就说这把尺子的分辨率是1毫米，或者量程的1%；而它的实际精度就不得而知了（算是0.1毫米吧）。当我们用火来烤一下它，并且把它拉长一段，然后再考察一下它。我们不难发现，它还有有100个刻度，它的“分辨率”还是1毫米，跟原来一样！然而，您还会认为它的精度还是原来的0.1毫米么？（这个例子是引用网上的，个人觉得比喻的很形象！）

回到电子技术上，我们考察一个常用的数字温度传感器：AD7416。供应商只是大肆宣扬它有10位的AD，分辨率是1/1024。那么，很多人就会这么欣喜：哇塞，如果测量温度0-100摄氏度，100/1024……约等于0.098摄氏度！这么高的精度，足够用了。但是我们去浏览一下AD7416的数据手册，居然发现里面赫然写着：测量精度0.25摄氏度！所以说分辨率跟精度完全是两回事，在这个温度传感器里，只要你愿意，你甚至可以用一个14位的AD，获得1/16384的分辨率，但是测量值的精度还是0.25摄氏度^_^

所以很多朋友一谈到精度，马上就和分辨率联系起来了，包括有些项目负责人，只会在那里说：这个系统精度要求很高啊，你们AD的位数至少要多少多少啊……

其实，仔细浏览一下AD的数据手册，会发现跟精度有关的有两个很重要的指标：DNL和INL。似乎知道这两个指标的朋友并不多，所以在这里很有必要解释一下。

DNL：Differencial NonLiner——微分非线性度

INL：Interger NonLiner——积分非线性度（精度主要用这个值来表示）

他表示了ADC器件在所有的数值点上对应的模拟值，和真实值之间误差最大的那一点的误差值。也就是，输出数值偏离线性最大的距离。单位是LSB（即最低位所表示的量）。

当然，像有的AD如△—∑系列的AD，也用Linearity error 来表示精度。

为什么有的AD很贵，就是因为INL很低。分辨率同为12bit的两个ADC，一个INL＝±3LSB，而一个做到了±1.5LSB，那么他们的价格可能相差一倍。

所以在这里帮大家把这两个概念理一下，以后大家就可以理直气壮的说精度和分辨率了，而不是将精度理解为分辨率。呵呵，希望对大家有用！

分辨率计算：测量电压范围/(2^AD位数-1)；










************************************************
sprintf函数,int-->str 
    //test.c  
#include <stdio.h>  
int main()  
{   
    char str[2];  
    int value=0x5678;  
    int i;
    char *cc;  
    sprintf(str, "%x", value);  


    cc=(char*)&value;
    printf("value[0]=%x\n",*cc);
    cc++;
    printf("value[1]=%x\n",*cc);
    cc++;
    printf("value[2]=%x\n",*cc);
    cc++;
    printf("value[3]=%x\n",*cc);

    printf("str=%s\n",str);  
    for( i=0 ;i<7;i++)  
    {  
    printf("str[%d]=%c\n",i,str[i]);  
    }  

    return 0;  
}  

root@song-virtual-machine:test# ./test 
value[0]=78
value[1]=56
value[2]=0
value[3]=0
str=5678
str[0]=5
str[1]=6
str[2]=7
str[3]=8
str[4]=
str[5]=
str[6]=
如果line9 是 sprintf(str, "%d", value);
即将value按照10进制数,每位数字依次塞进str。 
root@song-virtual-machine:test# ./test 
value[0]=78
value[1]=56
value[2]=0
value[3]=0
str=22136
str[0]=2
str[1]=2
str[2]=1
str[3]=3
str[4]=6
str[5]=
str[6]=
************************************************
sscanf函数,str-->int 
#include <stdio.h>  
int main()  
{   

	char str[20]="56";
	int value;

	sscanf(str, "%d", &value);
	printf("value: %d\n",value);

	sscanf(str, "%x", &value);
	printf("value: %d\n",value);

	return 0;  
}  
root@song-virtual-machine:test# ./test 
value: 56
value: 86




转载于:https://www.cnblogs.com/-song/archive/2012/06/02/3331870.html

weixin_30505043
关注
韦东山ARM裸机和uboot大全(第1期加强版)学习笔记18-第018课_ADC和触摸屏_第009~012节_触摸屏编程_较准原理
xiaoaojianghu09的博客
02-23 211
参考文章：STM32f103的电阻触摸屏的五点校正算法 一 校准原理 如下图，假如底下是LCD，上面是触摸屏膜（TS）。假设分辨率是480*272，那么在LCD坐标为（0,0）的地方，TS对应的点坐标为（x1’，y1’）。LCD坐标为（479,271）的地方，TS对应的点为（x2’，y2’）。 那么，假如触点的坐标为（x’，y’），对应的LCD的点坐标呢？ 为了简化，我们先看x轴的坐标：...
2021-12-16 RK3566 触摸屏调试记录、以及解决“触摸屏操作类似鼠标一样”的问题。
海月汐辰
12-16 5775
一、TP的硬件连接如下，接口包括i2c、中断pin和reset pin。 二、dts配置如下： &i2c4 { status = "okay"; pinctrl-names = "default"; pinctrl-0 = <&i2c4m0_xfer>; clock-frequency = <400000>; i2c-scl-rising-time-ns = <138>; i2c-scl-falling-time-ns ...
触摸屏的使用
最新发布
2302_76950368的博客
06-03 1133
触摸屏分类触摸屏又称触控面板，它是一种把触摸位置转化成坐标数据的输入设备，根据触摸屏的检测原理，主要分为电阻式触摸屏和电容式触摸屏。相对来说，电阻屏造价便宜，能适应较恶劣的环境，但它只支持单点触控 (一次只能检测面板上的一个触摸位置)，触摸时需要一定的压力，使用久了容易造成表面磨损，影响寿命；而电容屏具有支持多点触控、检测精度高的特点，电容屏通过与导电物体产生的电容效应来检测触摸动作，只能感应导电物体的触摸，湿度较大或屏幕表面有水珠时会影响电容屏的检测效果。
ADC触摸屏
weixin_34216196的博客
11-26 295
目录 ADC触摸屏 硬件原理 等效电路 测量逻辑 程序设计(一)获得ADC 寄存器初始化 中断初始化 ADC模式（中断、测量） 中断函数 程序设计(二)获得坐标 生产者...
STM32 ADC做触摸按键
qq_38960013的博客
03-06 3383
一、12位逐次逼近型ADC转换原理 ADC中输入的模拟信号是连续的，而输出的数字信号是离散的，所以转换时必须对输入的模拟信号进行采样；然后再把采样值转换成为输出的数字信号；这个过程需要经过采样、保持、量化、编码。 前置滤波器由于采样信号输出的是窄脉冲信号需要抗混叠滤波器来避免高频信号影响基带信号。 采样是将连续的模拟信号转换成时间上离散的采样信号；需要注意的是；根据奈奎斯特采样定理，采样频率必须大...
韦东山嵌入式Linux学习——017 ADC和触摸屏（1）-硬件原理介绍
weixin_42813232的博客
05-22 477
ADC和触摸屏-硬件原理与相关寄存器介绍介绍 /*  *硬件平台：韦东山嵌入式Linxu开发板（S3C2440.v3）  *软件平台：运行于VMware Workstation 12 Player下UbuntuLTS16.04_x64 系统，  *参考资料：开发版原理图，S3C2440A datasheet */ 目录ADC和触摸屏-硬件原理与相关寄存器介绍介绍一、硬件原理1、ADC2、触摸屏二、 一、硬件原理 1、ADC   ADC转换的应用电路如上图所示，通过采集模拟
ADC&TS;/ADC触摸屏的测试程序
02-20
在触摸屏应用中，ADC的作用是接收并转换来自触摸屏传感器的电压信号，这些信号反映了屏幕被触碰的位置。 TS，即触摸屏，是一种允许用户通过直接接触屏幕进行交互的输入设备。在S3C2440平台上，通常采用电阻式或电容...
电子秤.rar_4G_STM32 称重_stm32 触摸屏_stm32 电子秤_weighing
07-13
为了实现这些功能，开发者需要编写固件，包括底层驱动程序（如ADC驱动、触摸屏驱动、4G模块驱动）、中间件（如TCP/IP协议栈）、以及上层应用程序。编程语言通常使用C或C++，开发环境可能包括STM32CubeMX用于配置外设...
电子-实验26触摸屏实验.rar
09-05
8. **调试与测试**：使用开发板和相关的工具（如JTAG或SWD调试接口，以及串口监视器）进行程序调试，确保触摸屏的响应性和准确性。 实验26 触摸屏实验旨在让学生深入理解触摸屏的工作原理，熟悉STM32系列微控制器的...
adc_ts.rar_adc_ts
09-19
在这个特定的场景中，"adc_ts"指的是一个与触摸屏相关的ADC测试程序，用于TX2440开发板。TX2440是一款基于ARM9处理器的嵌入式开发平台，广泛应用于各种嵌入式系统设计和软件开发。 触摸屏技术通常依赖于ADC来将用户...
触摸屏设备驱动程序
bob_fly1984的专栏
03-10 1671
由于触摸屏设备简单、价格低廉，到处应用 在消费电子商品、工业控制系统、甚至航空领域都有应用   触摸屏作为一种最新的电脑输入设备，是目前最简单、方便、自然的的一种人机交互方式，具有坚固耐用、反应速度快、节省空间、易于交流等许多优点。 事实上，触摸屏是一个使多媒体信息系统改头换面的设备，它赋予多媒体系统以崭新的面貌，是极富有吸引力的全新多媒体交互设备   从技术原
ADC与触摸屏试验--TQ2440
空之轨迹～约修亚
01-29 1998
#define adc_mod_auto() {ADCTSC=(1<<2)|(1<<3);}#define adc_mod_wait() {ADCTSC=(1<<6)|(1<<7);}/*触屏中断。down中断进入自动adc转换模式，up中断就进入等待中断模式*/static void adc_tc(){ //先判断是按下还是抬起,通过读取adctsc的8bit
第018课 ADC和触摸屏硬件原理详解及裸机编程
韦东山嵌入式专栏
02-28 6158
第001节_ADC硬件原理 模数转换器即A/D转换器，或简称ADC，通常是指一个将模拟信号转变为数字信号的电子元件。 通常的模数转换器是把经过与标准量比较处理后的模拟量转换成以二进制数值表示的离散信号的转换器。 故任何一个模数转换器都需要一个参考模拟量作为转换的标准，比较常见的参考标准为最大的可转换信号大小。而输出的数字量则表示输入信号相对于参考信号的大小。 如图，是把可变电阻上的电压值变换...
S3C2416 +linux驱动移植之DM9000A
Hens007的专栏
02-20 4081
首先来看一下DM9000A的框图： 这里重要的是物理层PHY receiver，MAC(media access control)层，这里与软件中的协议栈不同，在硬件上MAC是PHY的下一层。DM9000A将MAC和PHY做到一起，也可以像IIS设备那样，SOC内有IIS的控制器，而声卡UDA1341放在片外。网卡当然也有这种设计，它是把PHY的下层MAC放入SOC内，片外的是PHY，当然我
ADC&TouchScreen
u014742281的专栏
03-06 247
如何使用 编程步骤
触摸开关原理
热门推荐
D_Boy
08-01 2万+
How touch Button Work 实现触摸按键的技术往往有三种：电阻触摸按键、电容触摸按键（常用）、电感触摸按键。 一、电阻原理实现touch 电阻触摸按键的原理是基于人的组织（皮肤）表面含有大量的盐分和水，使自身带有导电性。 上图中展示了一个基本的电阻触摸按键原理图，其工作原理很简单。图中的晶体管当做开关，RB电阻将晶体管基极（B）下拉到GND，当没有触摸时，不会浮空，影响判断。RP电阻用于保护电路，当电极短路时，防止电流过大，烧坏晶体管。图中展示了红色和蓝色两个电极，当只触摸其中一个时，晶体
ADC按键
让学习成为一种习惯
04-02 1629
扩展板上按键原理图如下：将八个按键的高电平端接入ADC_KEY引脚，并且每一个按键前串联相应的电阻。当每个按键按下时，该引脚的电位就会发生变化，不同的按键按下，通过ad采集到的电位不一样，因此可根据不同的电位来区分不同的按键。原理本质上是电阻分压，通过按下不同的按键来改变电压值，然后ADC引脚进行采集对应的电压，然后就可以做出判断，实现按键功能。优点：节省IO口，只需要一个IO口就可以检测这么多按键。但是缺点受硬件影响比较大，不同的板子，电阻也略有不同，检测得到的电压也有不同。
ADC&触摸屏
weixin_33881753的博客
01-09 154
1 硬件原理图 触摸屏的电路还是比较复杂的，暂时先不考虑其具体电路，我们先总结出和CPU相连的管脚。   管脚 功能 与S3C相连的管脚 RESET_IN 复位信号   LCD_PWREN LCD电源使能 GPG4 ENABLE     VSYNC 水平异步输入信号（RGB）   HSYNC 垂直异步输...
驱动之路四------adc驱动（input设备）
musesea的专栏
11-17 2425
开发板：smdk6410 开发环境：Linux 突然想起一点，写这些驱动，内核需要配成支持抢占才行。 前面的博客已经将其它的基本知识都解释了，这里也就不过多的阐述了，咱就直接写代码吧 这次写的是adc驱动，将其做为输入设备进行使用， 先写头文件，s3c_adc.h #ifndef __ADC_H #define __ADC_H #include #include #i
ARM2440裸机嵌入式触摸屏编程详解
- 程序中调用`Uart_Printf`函数，这可能是一个串行通信接口，用于打印调试信息，如"ADCtouchscreentest"，表示正在进行ADC触摸屏测试。 5. **编程流程**: - 通过这个例子，可以看出裸机开发中触摸屏编程的基本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值