rfeng/smod_atsc_app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

提交SMOD ATSC IMX APP版本 V122

Browse Source
This commit is contained in:
rfeng
2026-07-16 14:35:59 +08:00
commit 7601c270d5
485 changed files with 255032 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
atsc_app/bsp/igpio.c
Executable
+382
View File
@@ -0,0 +1,382 @@
#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