383 lines
9.0 KiB
C
Executable File
383 lines
9.0 KiB
C
Executable File
#if 1
|
|
#include <errno.h>
|
|
#include <pthread.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <fcntl.h> //define O_WRONLY and O_RDONLY
|
|
#include "../inc/type.h"
|
|
#include "../inc/igpio.h"
|
|
#include "../inc/isys_com.h"
|
|
|
|
|
|
extern int executeCMD(const char *cmd, char *result, u16 result_size);
|
|
pthread_mutex_t mutex_gpio;
|
|
|
|
|
|
#define DIR_OUT_VAL "out"
|
|
#define DIR_IN_VAL "in"
|
|
#define GP_VAL_H "1"
|
|
#define GP_VAL_L "0"
|
|
|
|
|
|
int set_gpio_export(uint16_t gp_num)
|
|
{
|
|
#if SHELL_CTRL_GPIO
|
|
char cmd[300];
|
|
memset(cmd, 0, sizeof(cmd));
|
|
sprintf(cmd, "echo %d > /sys/class/gpio/export",gp_num);
|
|
system(cmd);
|
|
#else
|
|
int fd;
|
|
char s_gp_num[20];
|
|
|
|
pthread_mutex_lock(&mutex_gpio);
|
|
fd = open("/sys/class/gpio/export", O_WRONLY);
|
|
if(fd == -1) {
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
log_printf(LOG_ERR, I_NOUSED, "gpio %d pin open-export error.\n", gp_num);
|
|
return -1;
|
|
}
|
|
memset(s_gp_num,0,sizeof(s_gp_num));
|
|
sprintf(s_gp_num,"%d",gp_num);
|
|
write(fd, s_gp_num ,strlen(s_gp_num));
|
|
close(fd);
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
int set_gpio_unexport(uint16_t gp_num)
|
|
{
|
|
#if SHELL_CTRL_GPIO
|
|
char cmd[300];
|
|
memset(cmd, 0, sizeof(cmd));
|
|
sprintf(cmd, "echo %d > /sys/class/gpio/unexport",gp_num);
|
|
system(cmd);
|
|
#else
|
|
int fd;
|
|
char s_gp_num[20];
|
|
|
|
pthread_mutex_lock(&mutex_gpio);
|
|
fd = open("/sys/class/gpio/unexport", O_WRONLY);
|
|
if(fd == -1){
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
log_printf(LOG_ERR,I_NOUSED,"ERR: gpio %d pin open-unexport error.\n",gp_num);
|
|
return -1;
|
|
}
|
|
log_printf(LOG_DEBUG,I_NOUSED,".setxpt sys/gpio/class/gpio/unexport");
|
|
|
|
memset(s_gp_num,0,sizeof(s_gp_num));
|
|
sprintf(s_gp_num,"%d",gp_num);
|
|
|
|
write(fd, s_gp_num ,strlen(s_gp_num));
|
|
close(fd);
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
int set_gpio_io_direct(uint16_t gp_num,E_IO io_dir)
|
|
{
|
|
int fd;
|
|
char cmd[300];
|
|
memset(cmd, 0, sizeof(cmd));
|
|
|
|
#if SHELL_CTRL_GPIO
|
|
sprintf(cmd, "echo %s > /sys/class/gpio/gpio%d/direction",(io_dir==E_IO_OUT?"out":"in"),gp_num);
|
|
system(cmd);
|
|
#else
|
|
|
|
if(io_dir==E_IO_OUT) {
|
|
sprintf(cmd, "/sys/class/gpio/gpio%d/direction",gp_num);
|
|
}
|
|
else{//E_IO_IN
|
|
sprintf(cmd, "/sys/class/gpio/gpio%d/direction",gp_num);
|
|
}
|
|
|
|
pthread_mutex_lock(&mutex_gpio);
|
|
fd = open(cmd, O_WRONLY);
|
|
if(fd == -1) {
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
log_printf(LOG_ERR, I_NOUSED, "set io_dir, gpio %d pin open-direction error.\n",gp_num);
|
|
return -1;
|
|
}
|
|
if(io_dir==E_IO_OUT) {
|
|
write(fd, DIR_OUT_VAL, sizeof(DIR_OUT_VAL));
|
|
}
|
|
else{
|
|
write(fd, DIR_IN_VAL, sizeof(DIR_IN_VAL));
|
|
}
|
|
close(fd);
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
|
|
int set_gpio_value(uint16_t gp_num, E_IO_VAL val)
|
|
{
|
|
int fd;
|
|
char cmd[200];
|
|
memset(cmd, 0, sizeof(cmd));
|
|
|
|
#if SHELL_CTRL_GPIO
|
|
sprintf(cmd, "echo %d > /sys/class/gpio/gpio%d/value",val,gp_num);
|
|
system(cmd);
|
|
#else
|
|
char logbuf[50]={0};
|
|
sprintf(cmd, "/sys/class/gpio/gpio%d/value",gp_num);
|
|
|
|
pthread_mutex_lock(&mutex_gpio);
|
|
fd = open(cmd, O_WRONLY);
|
|
if(fd == -1){
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
sprintf(logbuf,"error. set_io_val %d open\n",gp_num);
|
|
usr_sec_printf("%s",logbuf);
|
|
return -1;
|
|
}
|
|
|
|
if(val==E_IO_H){
|
|
write(fd, GP_VAL_H, sizeof(GP_VAL_H));
|
|
}
|
|
else{
|
|
write(fd, GP_VAL_L, sizeof(GP_VAL_L));
|
|
}
|
|
close(fd);
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
int get_gpio_value(uint16_t gp_num, uint8 *pval)
|
|
{
|
|
#if SHELL_CTRL_GPIO
|
|
char cmd[300];
|
|
char vbuf[20];
|
|
int ret = 0;
|
|
|
|
sprintf(cmd, "cat /sys/class/gpio/gpio%d/value",gp_num);
|
|
ret = executeCMD(cmd, vbuf, sizeof(cmd));
|
|
if(ret>=0){
|
|
*pval = atoi(vbuf);
|
|
}else{
|
|
log_printf(LOG_ERR,I_NOUSED,"%s get value err\n", cmd);
|
|
}
|
|
#else
|
|
int fd;
|
|
char cmd[300];
|
|
char vbuf[20];
|
|
uint8 u8val;
|
|
char logbuf[50]={0};
|
|
|
|
memset(cmd, 0, sizeof(cmd));
|
|
|
|
sprintf(cmd, "/sys/class/gpio/gpio%d/value",gp_num);
|
|
pthread_mutex_lock(&mutex_gpio);
|
|
fd = open(cmd, O_RDONLY);
|
|
if(fd == -1){
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
sprintf(logbuf,"error. get_io_val %d open\n",gp_num);
|
|
usr_sec_printf("%s",logbuf);
|
|
return -1;
|
|
}
|
|
|
|
memset(vbuf,0,sizeof(vbuf));
|
|
read(fd, vbuf, sizeof(vbuf));
|
|
|
|
if(vbuf!=NULL){
|
|
u8val = atoi(vbuf);
|
|
*pval = u8val;
|
|
}
|
|
else{
|
|
log_printf(LOG_DEBUG,I_NOUSED,"gpio read err\n");
|
|
}
|
|
close(fd);
|
|
pthread_mutex_unlock(&mutex_gpio);
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
void key_gpio_init(void)
|
|
{
|
|
/*printf("\n\ninit key gpio unexport.\n");
|
|
set_gpio_unexport(KEY1_GP_NUM);
|
|
set_gpio_unexport(KEY2_GP_NUM);
|
|
set_gpio_unexport(KEY3_GP_NUM);
|
|
set_gpio_unexport(KEY4_GP_NUM);
|
|
set_gpio_unexport(KEY5_GP_NUM);
|
|
set_gpio_unexport(KEY6_GP_NUM);*/
|
|
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "init key gpio export\n");
|
|
set_gpio_export(KEY1_GP_NUM);
|
|
set_gpio_export(KEY2_GP_NUM);
|
|
set_gpio_export(KEY3_GP_NUM);
|
|
set_gpio_export(KEY4_GP_NUM);
|
|
set_gpio_export(KEY5_GP_NUM);
|
|
set_gpio_export(KEY6_GP_NUM);
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "over. init key gpio export\n");
|
|
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "init key gpio input\n");
|
|
set_gpio_io_direct(KEY1_GP_NUM, E_IO_IN);//E_IO_IN
|
|
set_gpio_io_direct(KEY2_GP_NUM, E_IO_IN);
|
|
set_gpio_io_direct(KEY3_GP_NUM, E_IO_IN);
|
|
set_gpio_io_direct(KEY4_GP_NUM, E_IO_IN);
|
|
set_gpio_io_direct(KEY5_GP_NUM, E_IO_IN);
|
|
set_gpio_io_direct(KEY6_GP_NUM, E_IO_IN);
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "over. init key gpio input\n");
|
|
}
|
|
|
|
#define KEY_GPIO_MAX_NUM 6
|
|
uint8 key_gp_list[KEY_GPIO_MAX_NUM]=
|
|
{
|
|
KEY1_GP_NUM ,
|
|
KEY2_GP_NUM ,
|
|
KEY3_GP_NUM ,
|
|
KEY4_GP_NUM ,
|
|
KEY5_GP_NUM ,
|
|
KEY6_GP_NUM ,
|
|
};
|
|
|
|
#define LCD_GPIO_MAX_NUM 12
|
|
uint8 lcd_gp_list[LCD_GPIO_MAX_NUM]=
|
|
{
|
|
LCD_CTL_GP_NUM ,
|
|
LCD_RS_GP_NUM ,
|
|
LCD_E_GP_NUM ,
|
|
LCD_RW_GP_NUM ,
|
|
LCD_D1_GP_NUM ,
|
|
LCD_D0_GP_NUM ,
|
|
LCD_D3_GP_NUM ,
|
|
LCD_D2_GP_NUM ,
|
|
LCD_D5_GP_NUM ,
|
|
LCD_D4_GP_NUM ,
|
|
LCD_D7_GP_NUM ,
|
|
LCD_D6_GP_NUM ,
|
|
};
|
|
|
|
void gpio_mutex_init(void)
|
|
{
|
|
pthread_mutex_init(&mutex_gpio, NULL);
|
|
}
|
|
|
|
void fpga_reset_gpio_init(void)
|
|
{
|
|
set_gpio_export(FPGA_RST_GP_NUM);
|
|
set_gpio_io_direct(FPGA_RST_GP_NUM,E_IO_OUT);
|
|
}
|
|
|
|
void lcd_gpio_init(void)
|
|
{
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "init lcd gpio export\n");
|
|
set_gpio_export(LCD_CTL_GP_NUM);
|
|
set_gpio_export(LCD_RS_GP_NUM);
|
|
set_gpio_export(LCD_E_GP_NUM);
|
|
set_gpio_export(LCD_RW_GP_NUM);
|
|
set_gpio_export(LCD_D1_GP_NUM);
|
|
set_gpio_export(LCD_D0_GP_NUM);
|
|
set_gpio_export(LCD_D3_GP_NUM);
|
|
set_gpio_export(LCD_D2_GP_NUM);
|
|
set_gpio_export(LCD_D5_GP_NUM);
|
|
set_gpio_export(LCD_D4_GP_NUM);
|
|
set_gpio_export(LCD_D7_GP_NUM);
|
|
set_gpio_export(LCD_D6_GP_NUM);
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "over. init lcd gpio export\n");
|
|
|
|
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "init lcd gpio output\n");
|
|
set_gpio_io_direct(LCD_CTL_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_RS_GP_NUM, E_IO_OUT);
|
|
set_gpio_io_direct(LCD_E_GP_NUM, E_IO_OUT);
|
|
set_gpio_io_direct(LCD_RW_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D1_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D0_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D3_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D2_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D5_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D4_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D7_GP_NUM,E_IO_OUT);
|
|
set_gpio_io_direct(LCD_D6_GP_NUM,E_IO_OUT);
|
|
log_printf(LOG_INFO, I_SYS_STATUS, "over. init lcd gpio output\n");
|
|
|
|
|
|
set_gpio_export(LCD_EN_GP_NUM);
|
|
set_gpio_io_direct(LCD_EN_GP_NUM, E_IO_OUT);
|
|
set_gpio_value(LCD_EN_GP_NUM, E_IO_H);
|
|
}
|
|
|
|
|
|
|
|
void i2c_gpio_init(void)
|
|
{
|
|
log_printf(LOG_DEBUG,I_NOUSED,"\n\n>>>:init i2c gpio export.\n");
|
|
set_gpio_export(I2C2_SDA_GP_NUM);
|
|
set_gpio_export(I2C2_SCL_GP_NUM);
|
|
|
|
set_gpio_export(I2C1_SDA_GP_NUM);
|
|
set_gpio_export(I2C1_SCL_GP_NUM);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"\n\n===:over. init i2c gpio export.\n");
|
|
|
|
log_printf(LOG_DEBUG,I_NOUSED,"\n\n>>>:init i2c gpio input.\n");
|
|
set_gpio_io_direct(I2C2_SDA_GP_NUM, E_IO_OUT);//E_IO_IN
|
|
set_gpio_io_direct(I2C2_SCL_GP_NUM, E_IO_OUT);
|
|
|
|
set_gpio_io_direct(I2C1_SDA_GP_NUM, E_IO_OUT);
|
|
set_gpio_io_direct(I2C1_SCL_GP_NUM, E_IO_OUT);
|
|
log_printf(LOG_DEBUG,I_NOUSED,"\n\n===:over. init i2c gpio output.\n");
|
|
}
|
|
|
|
|
|
|
|
|
|
#if 0//test
|
|
|
|
void test_gpio_init()
|
|
{
|
|
key_gpio_init();
|
|
lcd_gpio_init();
|
|
}
|
|
|
|
void test_key_lcd_gpio(void)
|
|
{
|
|
|
|
static uint32 sec_cnt;
|
|
uint8 gp=0;
|
|
|
|
sec_cnt++;
|
|
|
|
for(gp=0;gp<KEY_GPIO_MAX_NUM;gp++){
|
|
set_gpio_value(key_gp_list[gp], (E_IO_VAL)(sec_cnt%2));
|
|
}
|
|
|
|
for(gp=0;gp<LCD_GPIO_MAX_NUM;gp++){
|
|
set_gpio_value(lcd_gp_list[gp], (E_IO_VAL)(sec_cnt%2));
|
|
}
|
|
}
|
|
|
|
|
|
#include "time.h"
|
|
void main()
|
|
{
|
|
int sec_cnt=0;
|
|
uint8 rdata=0;
|
|
|
|
test_gpio_init();
|
|
|
|
while(1)
|
|
{
|
|
sleep(2);
|
|
sec_cnt++;
|
|
test_key_lcd_gpio();
|
|
|
|
printf(".test round %d\n",sec_cnt);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
#endif
|
|
|