一、 看门狗芯片
1.1 看门狗芯片与处理器引脚连接
本次主控单元使用的看门狗芯片为SP706芯片 。
引脚定义:
1.2 使能外部看门狗
(1) 看门狗芯片SP706芯片手册中的电路图:
(2) 看门狗与主控板连接原理图如下所示:
当J2接上跳线帽时,开启看门狗。反之,看门狗关闭。
独立的看门狗芯片:这种看门狗主要有一个用于喂狗的引脚(一般与CPU的GPIO相连)和一个复位引脚(与系统的RESET引脚相连),如果没有在一定时间内改变喂狗脚的电平,复位引脚就会改变状态复位CPU。当J2接上跳线帽时,看门狗被使能,系统一上电看门狗就开始工作,1.6秒系统便会复位一次,所以必须进行喂狗操作,在嵌入式系统uboot、内核、启动脚本等阶段可能都需要喂狗。
二、测试程序
基于Linux下GPIO的操作:
/* Copyright (c) 2011, RidgeRun
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the RidgeRun.
* 4. Neither the name of the RidgeRun nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY RIDGERUN ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL RIDGERUN BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <fcntl.h>
#include <poll.h>
/****************************************************************
* Constants
****************************************************************/
#define SYSFS_GPIO_DIR "/sys/class/gpio"
#define POLL_TIMEOUT (3 * 1000) /* 3 seconds */
#define MAX_BUF 64
#define GPIO_GROUP_NUM (5)
#define GPIO_NUM_PER_GROUP (32)
#define GPIO_NAME_LEN (10)
/****************************************************************
* gpio_num_to_string
****************************************************************/
int gpio_num_to_string(unsigned int gpio, char * name)
{
int i = 0;
if ((gpio >= GPIO_GROUP_NUM * GPIO_NUM_PER_GROUP) || (!name)) {
printf("[%s : %d] wrong para\n", __FUNCTION__, __LINE__);
return -1;
}
memset(name, 0, GPIO_NAME_LEN);
i = gpio / GPIO_NUM_PER_GROUP;
switch (i) {
case 0:
sprintf(name, "pioA%d", gpio % GPIO_NUM_PER_GROUP);
break;
case 1:
sprintf(name, "pioB%d", gpio % GPIO_NUM_PER_GROUP);
break;
case 2:
sprintf(name, "pioC%d", gpio % GPIO_NUM_PER_GROUP);
break;
case 3:
sprintf(name, "pioD%d", gpio % GPIO_NUM_PER_GROUP);
break;
case 4:
sprintf(name, "pioE%d", gpio % GPIO_NUM_PER_GROUP);
break;
default:
return -1;
}
return 0;
}
/****************************************************************
* gpio_export
****************************************************************/
int gpio_export(unsigned int gpio)
{
int fd, len;
char buf[MAX_BUF];
fd = open(SYSFS_GPIO_DIR "/export", O_WRONLY);
if (fd < 0) {
printf("[%s : %d] gpio/export\n", __FUNCTION__, __LINE__);
return fd;
}
len = snprintf(buf, sizeof(buf), "%d", gpio);
write(fd, buf, len);
close(fd);
return 0;
}
/****************************************************************
* gpio_unexport
****************************************************************/
int gpio_unexport(unsigned int gpio)
{
int fd, len;
char buf[MAX_BUF];
fd = open(SYSFS_GPIO_DIR "/unexport", O_WRONLY);
if (fd < 0) {
printf("[%s : %d] gpio/export\n", __FUNCTION__, __LINE__);
return fd;
}
len = snprintf(buf, sizeof(buf), "%d", gpio);
write(fd, buf, len);
close(fd);
return 0;
}
/****************************************************************
* gpio_set_dir
****************************************************************/
int gpio_set_dir(unsigned int gpio, unsigned int out_flag)
{
int fd, len;
char buf[MAX_BUF], name[GPIO_NAME_LEN];
if ((fd = gpio_num_to_string(gpio, name)) < 0) {
return fd;
}
//len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/direction", gpio);
len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/%s/direction", name);
fd = open(buf, O_WRONLY);
if (fd < 0) {
printf("[%s : %d] gpio/direction\n", __FUNCTION__, __LINE__);
return fd;
}
if (out_flag)
write(fd, "out", 4);
else
write(fd, "in", 3);
close(fd);
return 0;
}
/****************************************************************
* gpio_set_value
****************************************************************/
int gpio_set_value(unsigned int gpio, unsigned int value)
{
int fd, len;
char buf[MAX_BUF], name[GPIO_NAME_LEN];
if ((fd = gpio_num_to_string(gpio, name)) < 0) {
return fd;
}
// len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);
len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/%s/value", name);
fd = open(buf, O_WRONLY);
if (fd < 0) {
printf("[%s : %d] gpio/set-value\n", __FUNCTION__, __LINE__);
return fd;
}
if (value)
write(fd, "1", 2);
else
write(fd, "0", 2);
close(fd);
return 0;
}
/****************************************************************
* gpio_get_value
****************************************************************/
int gpio_get_value(unsigned int gpio, unsigned int *value)
{
int fd, len;
char buf[MAX_BUF];
char ch, name[GPIO_NAME_LEN];
if ((fd = gpio_num_to_string(gpio, name)) < 0) {
return fd;
}
// len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);
len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/%s/value", name);
fd = open(buf, O_RDONLY);
if (fd < 0) {
printf("[%s : %d] gpio/get-value\n", __FUNCTION__, __LINE__);
return fd;
}
read(fd, &ch, 1);
if (ch != '0') {
*value = 1;
} else {
*value = 0;
}
close(fd);
return 0;
}
/****************************************************************
* gpio_set_edge
****************************************************************/
int gpio_set_edge(unsigned int gpio, char *edge)
{
int fd, len;
char buf[MAX_BUF], name[GPIO_NAME_LEN];
if ((fd = gpio_num_to_string(gpio, name)) < 0) {
return fd;
}
// len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/edge", gpio);
len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/%s/edge", name);
fd = open(buf, O_WRONLY);
if (fd < 0) {
printf("[%s : %d] gpio/set-edge\n", __FUNCTION__, __LINE__);
return fd;
}
write(fd, edge, strlen(edge) + 1);
close(fd);
return 0;
}
/****************************************************************
* gpio_fd_open
****************************************************************/
int gpio_fd_open(unsigned int gpio)
{
int fd, len;
char buf[MAX_BUF], name[GPIO_NAME_LEN];
if ((fd = gpio_num_to_string(gpio, name)) < 0) {
return fd;
}
// len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);
len = snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/%s/value", name);
fd = open(buf, O_RDONLY | O_NONBLOCK );
if (fd < 0) {
printf("[%s : %d] gpio/fd_open\n", __FUNCTION__, __LINE__);
}
return fd;
}
/****************************************************************
* gpio_fd_close
****************************************************************/
int gpio_fd_close(int fd)
{
return close(fd);
}
/****************************************************************
* Main
****************************************************************/
int main(int argc, char **argv, char **envp)
{
struct pollfd fdset[2];
int nfds = 2;
int gpio_fd, timeout, rc;
char *buf[MAX_BUF];
unsigned int gpio;
int len;
int num = 0, dir = 0;
if ((argc != 2) && (argc != 3)) {
printf("Usage: gpio-int <gpio-pin> <gpio-direction>\n\n");
printf("Waits for a change in the GPIO pin voltage level or input on stdin\n");
exit(-1);
}
gpio = atoi(argv[1]);
if (argc == 3) {
if (strcmp(argv[2], "out")) {
dir = 1;
}
else if (strcmp(argv[2], "in")) {
dir = 0;
}
else {
printf("[%s : %d] wrong direction, must [in/out]\n", __FUNCTION__, __LINE__);
exit(-1);
}
}
gpio_export(gpio);
gpio_set_dir(gpio, 1);
//gpio_set_edge(gpio, "rising");
//gpio_fd = gpio_fd_open(gpio);
timeout = POLL_TIMEOUT;
while(1) {
gpio_fd = gpio_fd_open(gpio);
gpio_set_value(gpio, 1);
printf("[%s : %d] set gpio [%d] to watchdog, num [%d]\n", __FUNCTION__, __LINE__, gpio, num++);
gpio_fd_close(gpio_fd);
sleep(2);
}
// while (1) {
// memset((void*)fdset, 0, sizeof(fdset));
// fdset[0].fd = STDIN_FILENO;
// fdset[0].events = POLLIN;
// fdset[1].fd = gpio_fd;
// fdset[1].events = POLLPRI;
// rc = poll(fdset, nfds, timeout);
// if (rc < 0) {
// printf("\npoll() failed!\n");
// return -1;
// }
// if (rc == 0) {
// printf(".");
// }
// if (fdset[1].revents & POLLPRI) {
// len = read(fdset[1].fd, buf, MAX_BUF);
// printf("\npoll() GPIO %d interrupt occurred\n", gpio);
// }
// if (fdset[0].revents & POLLIN) {
// (void)read(fdset[0].fd, buf, 1);
// printf("\npoll() stdin read 0x%2.2X\n", (unsigned int) buf[0]);
// }
// fflush(stdout);
// }
// gpio_fd_close(gpio_fd);
return 0;
}