void dump_touch_reg()
{
printf_string("\n\n-------------- dump_touch_reg --------------------\n\n");
printf_string("ADCCON = 0x%x\n", ADCCON);
printf_string("ADCTSC = 0x%x\n", ADCTSC);
printf_string("\n\n-------------------------------------------------------\n\n");
}
int DecodeBibleVersion(
struct RecordVersion* version,
FILE* fp)
{
fread_blob(version->versionName, 16, fp);
fread_blob(version->versionInfo, 128, fp);
version->sepChar = fread_u8(fp);
version->versionAttrib = fread_u8(fp);
version->wordIndex = fread_u16(fp);
version->totalWordRec = fread_u16(fp);
version->totalBooks = fread_u16(fp);
#ifdef PDB_DEBUG
printf("version.versionName : %s\n", version->versionName);
printf("version.versionInfo : ");
printf_string(version->versionInfo, 128);
printf("\n");
printf("version.sepChar : 0x%02x\n", version->sepChar);
printf("version.versionAttrib : 0x%02x\n", version->versionAttrib);
printf("version.wordIndex : 0x%04x\n", version->wordIndex);
printf("version.totalWordRec: %d\n", version->totalWordRec);
printf("version.totalBooks : %d\n", version->totalBooks);
printf("\n");
#endif
DecodeBibleBookBriefInfo(version->bookBriefInfo, version->totalBooks, fp);
return 0;
}
/******************************************************
* DISPLAY SCORE
* DESCRIPTION: Shows the player scores on the screen.
******************************************************/
void displayPongScore(unsigned int* inUserScore, unsigned int* inCompScore) //Pass by ref
{
set_LCD_Cursor(0, 0);
printf_string(" ");
set_LCD_Cursor(25, 0);
printf_int(*inUserScore);
set_LCD_Cursor(45, 0);
printf_int(*inCompScore);
}
char *printf_s(char *f, char type, void *s)
{
if (type == 'p')
return (printf_hexa(f, type, ft_atoi(s)));
else if (type == 'S')
return (printf_wstring(f, (wchar_t *)s));
else if (type == 's')
return (printf_string(f, (char *)s, type));
return (f);
}
///////////////////////////////////////////////////////////////////////////////
//Local PDB decode interface define
int DecodePDBHeader(struct PDBHeader* header, FILE* fp)
{
//Fill pdb header
fread_blob(header->fileName, 32, fp);
header->fileAttributes = fread_u16(fp);
header->versionNumber = fread_u16(fp);
header->createDate = fread_u32(fp);
header->modificationDate = fread_u32(fp);
header->lastBackupDate = fread_u32(fp);
header->modificationNumber = fread_u32(fp);
header->appInfoArea = fread_u32(fp);
header->sortInfoArea = fread_u32(fp);
fread_blob(header->dataBaseType, 4, fp);
fread_blob(header->creatorID, 4, fp);
fread_blob(header->uniqueIDSeed, 4, fp);
header->nextRecord = fread_u32(fp);
header->numRecs = fread_u16(fp);
#ifdef PDB_DEBUG
//Debug info
printf("header->FileName : %s\n", header->fileName);
printf("header->DatabaseType: ");
printf_string(header->dataBaseType, 4);
printf("\n");
printf("header->CreatorID : ");
printf_string(header->creatorID, 4);
printf("\n");
printf("header->NumRecs : 0x%02x\n",header->numRecs);
#endif
return 0;
}
/**
****************************************************************************************
* @brief Main routineof the DA14580 Peripheral Examples Functions
* DA14580 Peripherals Udage Examples
* - UART
* - SPI Flash
* - Boot From SPI flash
* - EEPROM
* - Timers
* - Battery Level Indication - ADC
* - Quadrature
* - Buzzer
* Due to HW Development Kit limitations, user must select one of the follwoing configuartion for UART, SPI, I2C.
* Addicional Hardware (SPI, EEPROM boadrs) or Hardware modification may needed for some tof the tests.
* More information in the file periph_setup.h, Application Notes, and User Guide for DA14580
* - UART only ( No HW modifications on rev C2 motherboard, No additional hardware)
* - SPI Flash with UART (HW modifications & additional Hardware needed , SPI_DI_PIN on the additional SPI / EEPROM daughterboard )
* - Boot From SPI Flash with UART (HW modifications & additional Hardware needed, (UART TX) )
* - Boot From SPI Flash without UART (Additional Hardware needed)
* - Boot From EEPROM with UART (Additional Hardware needed)
*
****************************************************************************************
*/
int main (void)
{
short int index = 0;
char mchoice;
periph_init();
printf_string("\n\rDA14580 Peripheral Examples\n\r");
printf_string( "---------------------------\n\r");
printf_string("Before running the tests:\n\r");
printf_string(" 1) Make sure you have connected the appropriate peripheral(s).\n\r");
printf_string(" 2) Select the associated hardware configuration in 'periph_setup.h'.\n\r");
printf_string(" 3) Build.\n\r");
printf_string("Please, refer to DA14580 Peripheral Examples User Manual\n\r");
printf_string("for detailed instructions.\n\r");
print_menu();
while(1){
if (index==1) break;
mchoice = uart_receive_byte();
switch (mchoice){
case 'u': uart_test(); endtest_bridge(&index); break;
#ifdef SPI_ENABLED
case 'f': spi_test(); endtest_bridge(&index); break;
#endif //SPI_ENABLED
#ifdef EEPROM_ENABLED
case 'e': i2c_test(); endtest_bridge(&index); break;
#endif //EEPROM_ENABLED
#ifdef QUADEC_ENABLED
case 'q': quad_decoder_test(); endtest_bridge(&index); break;
#endif //QUADEC_ENABLED
#ifdef BUZZER_ENABLED
case 't': timer0_test(); endtest_bridge(&index); break;
case 'p': timer2_test(); endtest_bridge(&index); break;
#endif //BUZZER_ENABLED
case 'b': batt_test(); endtest_bridge(&index); break;
case 'x': index=1;break;
default: print_input(); continue;
};
};
printf_string("\n\r End of tests\n\r");
while(1);
}
int main()
{
extern void enter_string(char str[]);
extern void delete_string(char str[],char ch);
extern void printf_string(char str[]);
char c,str[80];
enter_string(str);
scanf("%c",&c);
delete_string(str,c);
printf_string(str);
return 0;
}
/**
****************************************************************************************
* @briefend of test option
*
****************************************************************************************
*/
void endtest_bridge(short int *idx)
{
short int index2 = 0;
char bchoice;
printf_string("\n\r\n\rPress m for Engineering Examples Menu or x to exit : ");
while(1){
if (index2 == 1) break;
bchoice = uart_receive_byte();
switch (bchoice){
case 'm' : print_menu(); index2 = 1; break;
case 'x' : (*idx)=1; index2 = 1; break;
default : ; break;
};
};
}
/**
****************************************************************************************
* @brief Main routineof the DA14580 Engineering Examples Functions
* DA14580 Peripherals Udage Examples
* - UART
* - SPI Flash
* - Boot From SPI flash
* - EEPROM
* - Timers
* - Battery Level Indication - ADC
* - Quadrature
* - Buzzer
* Due to HW Development Kit limitations, user must select one of the follwoing configuartion for UART, SPI, I2C.
* Addicional Hardware (SPI, EEPROM boadrs) or Hardware modification may needed for some tof the tests.
* More information in the file periph_setup.h, Application Notes, and User Guide for DA14580
* - UART only ( No HW modifications on rev C2 motherboard, No additional hardware)
* - SPI Flash with UART (HW modifications & additional Hardware needed , SPI_DI_PIN on the additional SPI / EEPROM daughterboard )
* - Boot From SPI Flash with UART (HW modifications & additional Hardware needed, (UART TX) )
* - Boot From SPI Flash without UART (Additional Hardware needed)
* - Boot From EEPROM with UART (Additional Hardware needed)
*
****************************************************************************************
*/
int main (void)
{
short int index = 0;
char mchoice;
periph_init();
printf_string("DA14580 Engineering Examples\n\r");
printf_string("Connect the appropriate peripheral before choosing each test\n\r\n\r");
printf_string("Refer to Engineering Examples User Guide\n\r\n\r");
print_menu();
while(1){
if (index==1) break;
mchoice = uart_receive_byte();
switch (mchoice){
case 'u': uart_test(); endtest_bridge(&index); break;
case 'f': spi_test(); endtest_bridge(&index); break;
case 'i': spi_image(); endtest_bridge(&index); break;
case 'e': i2c_test(); endtest_bridge(&index); break;
case 'd': i2c_image(); endtest_bridge(&index); break;
// case 't': swt_test(); endtest_bridge(&index); break;
#ifdef QUADEC_ENABLED
case 'q': quad_decoder_test(); endtest_bridge(&index); break;
#endif //QUADEC_ENABLED
case 't': timer0_test(); endtest_bridge(&index); break;
case 'p': timer2_test(); endtest_bridge(&index); break;
case 'b': batt_test(); endtest_bridge(&index); break;
case 'x': index=1;break;
default: print_input(); continue;
};
};
printf_string("\n\r End of tests\n\r");
while(1);
}
/**
****************************************************************************************
* @brief Battery Level Indication example function
*
****************************************************************************************
*/
void batt_test(void){
printf_string("\n\r\n\r****************");
printf_string("\n\r* BATTERY TEST *\n\r");
printf_string("****************\n\r");
#if BATT_CR2032
printf_string("\n\rBattery type: CR2032");
printf_string("\n\rCurrent battery level (max.0xFF%): 0x");
printf_byte(battery_get_lvl(BATT_CR2032));
printf_string("% left");
#else
printf_string("\n\rBattery type unknown");
#endif
}
void printf_conversion_p(t_printf *t)
{
const void *ptr;
ptr = VA_ARG(t->args, void *);
if (t->flags.prec == 0 && ptr == NULL)
{
t->flags.prec = -1;
t->flags.pad = ' ';
printf_string(t, "0x", 2);
return ;
}
t->flags.base = 16;
t->flags.number.word = (unsigned long int)ptr;
t->flags.is_negative = false;
t->flags.alt = true;
t->flags.spec = 'x';
printf_number(t);
}
void app_sample128_enable(void)
{
struct sample128_enable_req* req = KE_MSG_ALLOC(
SAMPLE128_ENABLE_REQ,
TASK_SAMPLE128, TASK_APP,
sample128_enable_req
);
req->conhdl = app_env.conhdl;
req->sec_lvl = PERM(SVC, ENABLE);
//req->sample128_1_val = 0x01; // default value for sample128 characteristic 1
memcpy(&req->sample128_1_val,&sample128_my_new,sizeof(My_new_t));
req->sample128_2_val = 0xff; // default value for sample128 characteristic 2
req->feature = 0x00; // client CFG notify/indication
printf_string(" app_sample128_enable \r\n");
// send the message
ke_msg_send(req);
}
void touch_handler()
{
print_string("touch_handler");
//1. Start X/Y coordinate auto convert
ADCCON |= (1 << 0);
ADCTSC |= (1 << 2);
//2. Wait conversion finish
while((ADCCON & (1 << 15)) == 0);
//3. Get X/Y coordinate
xdata = ADCDAT0 & 0x03ff;
ydata = ADCDAT1 & 0x03ff;
//4. Clear interrupt(Write 1)
(SUBSRCPND) |= (1 << 9);
(SRCPND) |= (1 << 31);
(INTPND) |= (1 << 31);
//5. Enter wait stylus up interrupt
ADCTSC = 0xd3;
ADCTSC |= (1 << 8);
while(1)
{
if((SUBSRCPND) & (1 << 9))
{
break;
}
}
printf_string("\n\nxdata = %d\nydata = %d\n\n", xdata, ydata);
//6. Clear stylus up interrupt
(SUBSRCPND) |= (1 << 9);
(SRCPND) |= (1 << 31);
(INTPND) |= (1 << 31);
//7. Wait another stylus down
ADCTSC = 0xd3;
}
static void s_check_action(t_printf *t, char **s)
{
char sc[2];
++(*s);
while ((printf_flags(t, s) || printf_modifiers(t, s)))
++(*s);
if (**s)
{
if (printf_function_conversion(t, **s) == false)
{
sc[0] = **s;
sc[1] = '\0';
t->flags.prec = -1;
printf_string(t, ft_strdup(sc));
}
}
else
{
--(*s);
}
}
static int printf_type(t_printf *p, const int flag)
{
if (flag & C_WCHAR)
return (printf_wchar(p));
if (flag & C_WSTRING)
return (printf_wstring(p));
if (flag & C_STRING)
return (printf_string(p));
if (flag & C_CHAR)
return (printf_char(p));
if (flag & (C_INT | C_LONG))
return (printf_long(p, p->arg));
if (flag & C_UINT)
return (printf_ulong_base(p, p->arg, 10));
if (flag & C_ULONG)
return (printf_ulong_base(p, p->arg, 10));
if (flag & (C_HEXA | C_MHEXA))
return (printf_ulong_base(p, p->arg, 16));
if (flag & (C_LOCTAL | C_OCTAL))
return (printf_ulong_base(p, p->arg, 8));
if (flag & C_BIN)
return (printf_ulong_base(p, p->arg, 2));
return (1);
}
/**
****************************************************************************************
* @brief print menu function
*
****************************************************************************************
*/
void print_menu(void)
{
printf_string("\n\r====================================\n\r");
printf_string("= DA14580 Peripheral Examples Menu =\n\r");
printf_string("\n\r====================================\n\r");
printf_string("u. UART Print String Example\n\r");
#ifdef SPI_ENABLED
printf_string("f. SPI Flash Memory Example\n\r");
#else
printf_string("f. (disabled in this build) SPI Flash Memory Example\n\r");
#endif //SPI_ENABLED
#ifdef EEPROM_ENABLED
printf_string("e. I2C EEPROM Example\n\r");
#else
printf_string("e. (disabled in this build) I2C EEPROM Example\n\r");
#endif //EEPROM_ENABLED
#ifdef QUADEC_ENABLED
printf_string("q. Quadrature Encoder Example\n\r");
#else
printf_string("q. (disabled in this build) Quadrature (Rotary Encoder) Example\n\r");
#endif //QUADEC_ENABLED
#ifdef BUZZER_ENABLED
printf_string("t. Timer0 (PWM0, PWM1) Example\n\r");
printf_string("p. Timer2 (PWM2, PWM3, PWM4) Example\n\r");
#else
printf_string("t. (disabled in this build) Timer0 (PWM0, PWM1) Example\n\r");
printf_string("p. (disabled in this build) Timer2 (PWM2, PWM3, PWM4) Example\n\r");
#endif //BUZZER_ENABLED
printf_string("b. Battery Example\n\r");
printf_string("x. Exit\n\r\n\r");
print_input();
}
char *flowdrv_create_offline_device(const char *path, int format)
// Create new offline device
// path = tracefile that should be used
// format = tracefile format constant
{
struct mapiipcbuf qbuf;
int file;
char *mapidsocket, *mapidsocketglobal;
mapidsocket = printf_string(MAPIDSOCKHOME, getenv("HOME"));
mapidsocketglobal = strdup(MAPIDSOCKGLOBAL);
mapiipc_set_socket_names(mapidsocket, mapidsocketglobal);
pthread_once(&mapi_is_initialized, (void*)mapi_init);
//Check to see if file can be opened
if (path == NULL){
printf("ERROR: NULL path in flowdrv_create_offline_device\n");
return NULL;
}
else if ((file = open(path,O_LARGEFILE)) == -1) {
*local_err = MAPI_ERROR_FILE;
return NULL;
}
while(__sync_lock_test_and_set(mapi_lock,1));
if (((*get_numflows)() == 0) && ((*get_totalflows)() > 0) && *minit) { // socket has been closed, re-create it
if (mapiipc_client_init()<0) {
*mapi_lock = 0;
*local_err = MCOM_INIT_SOCKET_ERROR;
return NULL;
}
}
*mapi_lock = 0;
qbuf.mtype = 1;
qbuf.cmd = CREATE_OFFLINE_DEVICE;
qbuf.fd = getpid();
qbuf.pid = getpid();
qbuf.fid = format;
strncpy((char *)qbuf.data, path, DATA_SIZE);
while(__sync_lock_test_and_set(mapi_lock,1));
if (mapiipc_write((struct mapiipcbuf*)&qbuf) < 0)
{
*mapi_lock = 0;
*local_err = MCOM_SOCKET_ERROR;
return NULL;
}
if (mapiipc_read((struct mapiipcbuf*)&qbuf) < 0)
{
*mapi_lock = 0;
*local_err = MCOM_SOCKET_ERROR;
return NULL;
}
if(qbuf.cmd == SEND_FD)
{
if(mapiipc_send_fd(file) == -1)
{
*local_err = MAPI_ERROR_SEND_FD;
*mapi_lock = 0;
return NULL;
}
}
else
{
*local_err = MAPI_ERROR_SEND_FD;
*mapi_lock = 0;
return NULL;
}
if (mapiipc_read((struct mapiipcbuf*)&qbuf) < 0)
{
*mapi_lock = 0;
*local_err = MCOM_SOCKET_ERROR;
return NULL;
}
*mapi_lock = 0;
switch(qbuf.cmd)
{
case CREATE_OFFLINE_DEVICE_ACK:
offline_devices++;
return strdup((char *)qbuf.data);
case ERROR_ACK:
*local_err = qbuf.remote_errorcode;
return NULL;
default:
*local_err = MCOM_UNKNOWN_ERROR;
return NULL;
}
}
/**
****************************************************************************************
* @briefend exit test
*
****************************************************************************************
*/
void exit_test(void)
{
printf_string("\n\r End of tests \n\r");
}
//Initializes MAPI - called only once by pthread_once()
void mapi_init()
{
if (!globals_set)
{
fprintf(stderr, "\nERROR: driver not initialized!\n");
return;
}
struct mapiipcbuf qbuf;
char libpath[4096], *str, *s;
*minit = 1;
char *mapidsocket, *mapidsocketglobal;
char errstr[512];
mapidsocket = printf_string(MAPIDSOCKHOME, getenv("HOME"));
mapidsocketglobal = strdup(MAPIDSOCKGLOBAL);
mapiipc_set_socket_names(mapidsocket, mapidsocketglobal);
if (mapiipc_client_init() == -1)
{
*local_err = MCOM_INIT_SOCKET_ERROR;
*minit=0;
fprintf(stderr, "\n--------------------------------------------------------\n");
fprintf(stderr, "WARNING: mapid may not be running at the given interface\n");
fprintf(stderr,"--------------------------------------------------------\n");
}
offline_devices = 0;
//Get libpath from mapid
qbuf.mtype = 1;
qbuf.cmd = GET_LIBPATH;
qbuf.fd = getpid();
qbuf.pid = getpid();
while(__sync_lock_test_and_set(mapi_lock,1));
if (mapiipc_write((struct mapiipcbuf*)&qbuf))
*local_err = MCOM_SOCKET_ERROR;
if (mapiipc_read((struct mapiipcbuf*)&qbuf))
*local_err = MCOM_SOCKET_ERROR;
if (*local_err)
{
mapi_read_error(local_err, errstr);
fprintf(stderr, "ERROR: %d: %s \n", *local_err, errstr);
}
*mapi_lock = 0;
switch(qbuf.cmd)
{
case GET_LIBPATH_ACK:
strncpy(libpath, (char *)qbuf.data, 4096);
break;
default:
/* MAPI_ERROR_GETTING_LIBPATH */
return;
}
printf("libpath=%s\n", libpath);
//get libs from mapid
qbuf.mtype = 1;
qbuf.cmd = GET_LIBS;
qbuf.fd = getpid();
qbuf.pid = getpid();
while(__sync_lock_test_and_set(mapi_lock,1));
if (mapiipc_write((struct mapiipcbuf*)&qbuf))
*local_err = MCOM_SOCKET_ERROR;
if (mapiipc_read((struct mapiipcbuf*)&qbuf))
*local_err = MCOM_SOCKET_ERROR;
if (*local_err)
{
mapi_read_error(local_err, errstr);
fprintf(stderr, "ERROR: %d: %s \n", *local_err, errstr);
}
*mapi_lock = 0;
switch(qbuf.cmd)
{
case GET_LIBS_ACK:
break;
default:
/* MAPI_ERROR_GETTING_LIBS */
return;
}
//Load function libraries
str = (char *)qbuf.data;
while((s = strchr(str, ':')) != NULL)
{
*s = '\0';
mapilh_load_library(libpath, str);
str=s+1;
}
mapilh_load_library(libpath, str);
return;
}
void arp_process(u8* arp_buff, int length)
{
u32 i = 0;
u8* ptr = NULL;
ARP_HDR* arp_buff_ptr = (ARP_HDR*)arp_buff;
u8 dev_mac_addr[6] = {9, 8, 7, 6, 5, 4};
u8 src_ip_addr[4] = {192, 168, 1, 20};
ARP_HDR arp_send_buf;
u8 host_ip_addr[4];
u8 host_mac_addr[6];
switch(ADJUST_ENDIAN(arp_buff_ptr->opcode))
{
// printf_string("arp_buff_ptr->opcode = 0x%x\n", ADJUST_ENDIAN(arp_buff_ptr->opcode));
case 1: /* Arp request packet */
/* 1. Construct arp ack packet */
memcpy(arp_send_buf.eth_hdr.d_mac, arp_buff_ptr->src_mac, 6);
memcpy(arp_send_buf.eth_hdr.s_mac,arp_buff_ptr->dst_mac, 6);
arp_send_buf.eth_hdr.type = ADJUST_ENDIAN(0x0806);
arp_send_buf.hw_type = ADJUST_ENDIAN(0x01);
arp_send_buf.protocol = ADJUST_ENDIAN(0x0800);
arp_send_buf.hw_len = 6;
arp_send_buf.protocol_len = 4;
arp_send_buf.opcode = ADJUST_ENDIAN(0x02);
memcpy(arp_send_buf.src_mac, dev_mac_addr, 6);
memcpy(arp_send_buf.src_ip_addr, src_ip_addr, 4);
memcpy(arp_send_buf.dst_mac, arp_buff_ptr->src_mac, 6);
memcpy(arp_send_buf.dst_ip_addr, arp_buff_ptr->src_ip_addr, 4);
/* 2. Send request packet*/
dm9000_send((u8*)&arp_send_buf, (14 + 28));
break;
case 2: /* Arp ack packet */
memcpy(host_ip_addr, (*arp_buff_ptr).src_ip_addr, 4);
memcpy(host_mac_addr, (*arp_buff_ptr).src_mac, 6);
print_string("\nHost ip = ");
for(i = 0; i < 4; i++)
{
printf_string("%d ", host_ip_addr[i]);
}
print_string("\nHost mac = ");
for(i = 0; i < 6; i++)
{
printf_string("%C ", host_mac_addr[i]);
}
print_string("\n");
break;
default:
break;
}
}
void uart_test(void){
printf_string("\n\r\n\r*************");
printf_string("\n\r* UART TEST *\n\r");
printf_string("*************\n\r");
printf_string("\n\rHello World! == UART printf_string() ==.\n\r");
}
int main(int argc, char *argv[]) {
const char *homedir;
parse_arguments(argc, argv);
flowlist=malloc(sizeof(flist_t));
flist_init(flowlist);
clientlist = malloc(sizeof(flist_t));
flist_init(clientlist);
gflist = malloc(sizeof(global_function_list_t));
gflist->fflist=malloc(sizeof(flist_t));
flist_init(gflist->fflist);
gflist->lock = 0;
homedir = getenv("HOME");
if (homedir == NULL) {
fputs("Environment variable HOME not set. Giving up.\n", stderr);
exit( 1);
}
mapid_conf = printf_string( CONFDIR"/"CONF_FILE );
printf("using %s\n", mapid_conf);
log_level = get_log_level(mapid_conf); // get log level from mapi.conf
if (log_to_syslog) // logging to syslog is enabled
open_syslog(log_level, "MAPID");
log_to_file = set_logging_to_file(mapid_conf, &log_fd_info, &log_fd_debug); // support for logging to file
if (log_to_syslog == 0 && log_to_file == 0)
log_level = LOGGING_DISABLED;
if (log_to_syslog == 0)
printf("logging to syslog: disabled\n");
else
printf("logging to syslog: enabled - LogLevel: %d\n", log_level);
if (log_to_file) {
daemon_started(log_fd_info, "MAPID", daemonize, 0);
daemon_started(log_fd_debug, "MAPID", daemonize, 0);
}
if (log_to_syslog)
log_message(
"MAPID was started %s%s",
daemonize ? " ( is running as daemon )" : "");
drvlist = load_drivers();
if (drvlist == NULL) {
DEBUG_CMD(Debug_Message("ERROR: No MAPI drivers found"));
exit(EXIT_FAILURE);
}
// Grab some signals so we can mapid_shutdown gracefully
signal(SIGTERM, mapid_shutdown);
signal(SIGQUIT, mapid_shutdown);
signal(SIGINT, mapid_shutdown);
if (daemonize)
continue_as_daemon();
mapidcom();
mapid_shutdown(0);
// wait for shutdown to finish
// espenb TODO: use pthread_cond_wait (or similar) instead
while (running_shutdown != 2)
usleep(10000);
return 0;
}
/**
****************************************************************************************
* @brief print menu function
*
****************************************************************************************
*/
void print_menu(void)
{
printf_string("\n\r=====================================\n\r");
printf_string("= DA14580 Engineering Examples Menu =\n\r");
printf_string("\n\r=====================================\n\r");
printf_string("u. UART Print String Example\n\r");
printf_string("f. SPI Flash Memory Example\n\r");
printf_string("i. SPI Flash Memory Image Write\n\r");
printf_string("e. I2C EEPROM Example\n\r");
printf_string("d. I2C EEPROM Image Write/Verify Example\n\r");
#ifdef QUADEC_ENABLED
printf_string("q. Quadrature (Rotary Encoder) Example\n\r");
#else
printf_string("q. (disabled in this build) Quadrature (Rotary Encoder) Example\n\r");
#endif //QUADEC_ENABLED
printf_string("t. Timer0 (PWM0, PWM1) Example\n\r");
printf_string("p. Timer2 (PWM2, PWM3, PWM4) Example\n\r");
printf_string("b. Battery Example\n\r");
printf_string("x. Exit Example\n\r\n\r");
print_input();
}
/**
****************************************************************************************
* @brief print input function
*
****************************************************************************************
*/
void print_input(void)
{
printf_string("\n\rMake a choice : ");
}
static void mapidcom()
//Communicates with clients through IPC
{
fd_set active_fd_set; // active file descriptor list
fd_set read_fd_set; // temp file descriptor list for select()
int fdmax; // maximum file descriptor number
int yes = 1; // for setsockopt() SO_REUSEADDR, below
struct sockaddr_un mapidaddr;
struct sockaddr_un remoteaddr;
struct mapiipcbuf qbuf;
socklen_t addrlen;
int nbytes, len, s;
struct client *cl= NULL;
flist_node_t *tmpnode;
conf_category_entry_t *cat=NULL;
char *local;
struct group *mapi_group;
conf_category_t *conf;
mapidsocket=strdup(MAPIDSOCKGLOBAL);
if ((conf = pc_load(mapid_conf)) != NULL) {
cat = pc_get_category(conf, "");
local=pc_get_param(cat, "local");
if (local!=NULL && strcmp(local, "1")==0) {
free(mapidsocket);
mapidsocket=printf_string(MAPIDSOCKHOME, getenv("HOME") );
}
pc_close(conf);
}
// create the listener socket
if ((listenerfd = socket(AF_LOCAL, SOCK_STREAM, 0)) == -1) {
DEBUG_CMD(Debug_Message("ERROR: socket: %s", strerror(errno)));
exit(EXIT_FAILURE);
}
// avoid "address already in use" error message
if (setsockopt(listenerfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int))
== -1) {
DEBUG_CMD(Debug_Message("ERROR: setsockopt: %s", strerror(errno)));
exit(EXIT_FAILURE);
}
// set up the address we will be binding to
memset(&mapidaddr, 0, sizeof (mapidaddr));
mapidaddr.sun_family = AF_LOCAL;
memcpy(mapidaddr.sun_path, mapidsocket, strlen(mapidsocket)+1);
unlink(mapidsocket);
len = sizeof mapidaddr.sun_family + strlen(mapidaddr.sun_path);
if (bind(listenerfd, (struct sockaddr *) &mapidaddr, len)) {
DEBUG_CMD(Debug_Message("ERROR: bind: %s", strerror(errno)));
exit(EXIT_FAILURE);
}
// allow any member of our own group to connect
chmod(mapidsocket, S_IRWXU | S_IRWXG);
// if a mapi user group exists, set group permissions accordingly,
// otherwise the group ID will be equal to the user ID of the user that
// invoked mapid
mapi_group = getgrnam(MAPI_GROUP_NAME);
if (mapi_group != NULL) {
chown(mapidsocket, -1, mapi_group->gr_gid);
}
if (listen(listenerfd, BACKLOG) == -1) {
DEBUG_CMD(Debug_Message("ERROR: listen: %s", strerror(errno)));
exit(EXIT_FAILURE);
}
FD_ZERO (&active_fd_set);
// add the listener to the active set
FD_SET (listenerfd, &active_fd_set)
;
// keep track of the biggest file descriptor
fdmax = listenerfd; // so far, it's just this one
// wait for commands from the mapi stub, for ever...
while (1) {
read_fd_set = active_fd_set; // copy it
if (select(fdmax + 1, &read_fd_set, NULL, NULL, NULL) == -1) {
DEBUG_CMD(Debug_Message("ERROR: select: %s", strerror(errno)));
break;
}
// run through the existing connections
for (s = 0; s <= fdmax; s++) {
if (FD_ISSET (s, &read_fd_set)) {
// connection on the original listener socket
if (s == listenerfd) {
addrlen = sizeof (remoteaddr);
if ((newfd = accept(listenerfd,
(struct sockaddr *) &remoteaddr, &addrlen)) == -1) {
DEBUG_CMD(Debug_Message("accept: %s", strerror(errno)));
} else {
FD_SET (newfd, &active_fd_set)
; // add to active set
if (newfd > fdmax)
{ // keep track of the maximum
fdmax = newfd;
}
}
}
// handle data from an existing client
else
{
if ((nbytes = recv (s, &qbuf, MAX_SEND_SIZE, 0)) <= 0)
{
if (nbytes == 0)
{
// connection closed - find client's pid
while(__sync_lock_test_and_set(&clientlist_lock,1));
tmpnode = (flist_node_t *) flist_head (clientlist);
cl = NULL;
while (tmpnode != NULL)
{
if (((struct client *) tmpnode->data)->sock == s)
{
cl = (struct client *) tmpnode->data;
break;
}
tmpnode = flist_next (tmpnode);
}
clientlist_lock = 0;
if (cl == NULL)
{/* This is not interesting, as it will occur upon requests from clients without flows etc.
WARNING_CMD (printf
("WARNING: Zero bytes from socket %d [%s:%d]\n",
s, __FILE__, __LINE__));
*/
/* shouldn't really exit here?
* this will cause the program to exit on errors with an empty
* client-list which isn't really an error (IMHO)
*/
//exit(EXIT_FAILURE);
}
else
{
while(__sync_lock_test_and_set(&clientlist_lock,1));
//clean up any remaining flows
tmpnode = (flist_node_t *) flist_head (cl->flowlist);
while (tmpnode != NULL)
{
cleanup_flow ((struct flow *) tmpnode->data);
tmpnode = flist_next (tmpnode);
}
tmpnode = (flist_node_t *) flist_head (cl->devicelist);
while (tmpnode != NULL)
{
mapidrv_delete_device = get_drv_funct (tmpnode->data, "mapidrv_delete_device");
mapidrv_delete_device (tmpnode->id);
tmpnode = flist_next (tmpnode);
}
flist_destroy (cl->flowlist);
flist_destroy (cl->devicelist);
free(cl->devicelist);
free (cl->flowlist);
//remove this client from global client list
free(flist_remove (clientlist, cl->pid));
clientlist_lock = 0;
}
}
else
{
DEBUG_CMD(Debug_Message("WARNING: recv: %s at", strerror (errno)));
}
close (s);
FD_CLR (s, &active_fd_set); // remove it from active set
}
else
{
// we got some data from a client: process request
switch (qbuf.cmd)
{
case GET_LIBS:
cmd_get_libs (qbuf.pid, s);
break;
case GET_LIBPATH:
cmd_get_libpath (qbuf.pid, s);
break;
case CREATE_FLOW:
cmd_create_flow ((char *)qbuf.data, qbuf.pid, qbuf.uid, s);
break;
case CLOSE_FLOW:
cmd_close_flow (qbuf.fd, qbuf.pid, s, 1);
break;
case GET_FLOW_INFO:
cmd_get_flow_info (qbuf.fd, qbuf.pid, s);
break;
case GET_FUNCTION_INFO:
cmd_get_function_info (qbuf.fd, qbuf.fid, qbuf.pid, s);
break;
case GET_NEXT_FUNCTION_INFO:
cmd_get_next_function_info (qbuf.fd, qbuf.fid, qbuf.pid, s);
break;
case GET_NEXT_FLOW_INFO:
cmd_get_next_flow_info (qbuf.fd, qbuf.pid, s);
break;
case GET_NEXT_DEVICE_INFO:
cmd_get_next_device_info (qbuf.fd, qbuf.pid, s);
break;
case GET_DEVICE_INFO:
cmd_get_device_info (qbuf.fd, qbuf.pid, s);
break;
case MAPI_STATS:
cmd_stats ((char *)qbuf.data, qbuf.pid, qbuf.uid, s);
break;
case APPLY_FUNCTION:
cmd_apply_function (&qbuf, qbuf.pid, s);
break;
case READ_RESULT:
cmd_read_results (qbuf.fd, qbuf.fid, qbuf.pid, s);
break;
case CONNECT:
cmd_connect (qbuf.fd, qbuf.pid, s);
break;
case CREATE_FLOW_ACK:
case APPLY_FUNCTION_ACK:
case READ_RESULT_ACK:
case CONNECT_ACK:
case CLOSE_FLOW_ACK:
case SET_AUTHDATA_ACK:
break;
case READ_ERROR_ACK:
break;
case ERROR_ACK:
break;
case CREATE_OFFLINE_DEVICE:
cmd_create_offline_device ((char *)qbuf.data, qbuf.fid, qbuf.pid, s);
break;
case CREATE_OFFLINE_DEVICE_ACK:
break;
case START_OFFLINE_DEVICE:
cmd_start_offline_device ((char *)qbuf.data, qbuf.pid, s);
break;
case START_OFFLINE_DEVICE_ACK:
break;
case DELETE_OFFLINE_DEVICE:
cmd_delete_offline_device ((char *)qbuf.data, qbuf.pid, s);
break;
case DELETE_OFFLINE_DEVICE_ACK:
break;
case CREATE_OFFLINE_FLOW_ACK:
break;
case LOAD_LIBRARY:
cmd_load_library ((char *)qbuf.data, qbuf.pid, s);
default:
break;
}
}
}
}
} // for
} // while(1)
}
