Esempio n. 1
0
int main(int argc, char* argv[])
{
  int retval = 0;
  char * selected_serial_port;
  int numTimerFDs = NUM_OF_TIMERS;
  timerFDs_t *timer_fds = malloc(  NUM_OF_TIMERS * sizeof( timerFDs_t ) );
  char dbFilename[MAX_DB_FILENAMR_LEN];
 
  printf("%s -- %s %s\n", argv[0], __DATE__, __TIME__ );
 
  // accept only 1
  if( argc < 2 )
  {
    usage(argv[0]);
    printf("attempting to use /dev/ttyACM0\n\n");
	selected_serial_port = "/dev/ttyACM0";
  }
  else
  {
  	selected_serial_port = argv[1];
  }
  
  zbSocOpen( selected_serial_port );
  zbSocForceRun(); //skip the bootloader wait period
  
  if( serialPortFd == -1 )
  {
    exit(-1);
  }

  if (argc > 2)
  {
  	uartDebugPrintsEnabled = atoi(argv[2]);
  }

  if (argc > 3)
  {
    if (atoi(argv[3]) == 1)
    {
      zbSocResetToFn();
      printf("Sent Reset to Factory New\n");
    }
      else if (atoi(argv[3])  > 1)
    {
      //...
    }
  }
  
  zbSocGetTimerFds(timer_fds);
  
  sprintf(dbFilename, "%.*s/devicelistfile.dat",strrchr(argv[0],'/') - argv[0] , argv[0]);
  devListInitDatabase(dbFilename);
  sprintf(dbFilename, "%.*s/grouplistfile.dat",strrchr(argv[0],'/') - argv[0] , argv[0]);
  groupListInitDatabase(dbFilename);  
  sceneListRestorScenes();
  
  zbSocRegisterCallbacks( zbSocCbs );    
  SRPC_Init();
  
  while(1)
  {          
    int numClientFds = socketSeverGetNumClients(); 
    
	  //poll on client socket fd's and the zbSoC serial port for any activity
		if(numClientFds)
		{
		  int pollFdIdx;  		   
      int timerFdIdx;
		  int *client_fds = malloc(  numClientFds * sizeof( int ) );

		  //socket client FD's + serialPortFd serial port FD
      struct pollfd *pollFds = malloc(  ((numClientFds + 1 + numTimerFDs) * sizeof( struct pollfd )) );
		  
		  if(client_fds && pollFds)	
		  {
		    //set the serialPortFd serial port FD in the poll file descriptors
		    pollFds[0].fd = serialPortFd;
#if (!HAL_UART_SPI)
          //Fd will be a characture driver
  			pollFds[0].events = POLLIN;
#else	      
          //Fd Will be GPIO
    	  pollFds[0].events = POLLPRI;
  			
          //try to read any messages that might already be wating
          if(zbSocTransportPoll())
          {
            zbSocProcessRpc();
          }
    	 
          //flush events
          int buf[1];
          lseek(pollFds[0].fd, SEEK_SET, 0);
          read(pollFds[0].fd, buf, 1);
            	  
#endif  			
		    //Set the socket file descriptors  		    
	  	  socketSeverGetClientFds(client_fds, numClientFds);  			    	  	    	  	 
		  	for(pollFdIdx=0; pollFdIdx < numClientFds; pollFdIdx++)
  	  	{
  			  pollFds[pollFdIdx+1].fd = client_fds[pollFdIdx];
  			  pollFds[pollFdIdx+1].events = POLLIN | POLLRDHUP;
  			  //printf("%s: adding fd %d to poll()\n", argv[0], pollFds[pollFdIdx].fd); 	  				
  		  }	
        for(timerFdIdx=0; timerFdIdx < numTimerFDs; timerFdIdx++)
        {
          pollFds[numClientFds+1+timerFdIdx].fd = timer_fds[timerFdIdx].fd;
          pollFds[numClientFds+1+timerFdIdx].events =POLLIN;
          //printf("%s: adding fd %d to poll()\n", argv[0], pollFds[pollFdIdx].fd); 					
        } 

//        printf("%s: waiting for poll()\n", argv[0]);

        poll(pollFds, (numClientFds+1+numTimerFDs), current_poll_timeout);

        //printf("%s: got poll()\n", argv[0]);
        
        //did the poll unblock because of the zllSoC serial?
        if(pollFds[0].revents)
        {
          printf("Message from the ZigBee SoC\n");
          zbSocProcessRpc();
        }

        //did the poll unblock because of activity on the socket interface?
        for(pollFdIdx=1; pollFdIdx < (numClientFds+1); pollFdIdx++)
        {
          if ( (pollFds[pollFdIdx].revents) )
          {
            printf("Message from the client\n");
            socketSeverPoll(pollFds[pollFdIdx].fd, pollFds[pollFdIdx].revents);
          }
        }          
		
        //did the poll unblock because of timer expiration?
        for(timerFdIdx=0; timerFdIdx < numTimerFDs; timerFdIdx++)
        {
          if (pollFds[numClientFds+1+timerFdIdx].revents)
        {
            printf("Timer expired: #%d\n", timerFdIdx);
            timer_fds[timerFdIdx].callback();
        }
        }
        	  
        free( client_fds );	  
        free( pollFds );	  		
        }
      }  		           
  }    

  return retval;
}
Esempio n. 2
0
int main(int argc, char* argv[])
{	
	int retval = 0;
	int zbSoc_fd;

	//printf("%s -- %s %s\n", argv[0], __DATE__, __TIME__);


	// accept only 1
	if (argc != 2)
	{
		usage(argv[0]);
		//printf("attempting to use /dev/ttyACM0\n");
		zbSoc_fd = zbSocOpen("/dev/ttyO4");
	}
	else
	{
		zbSoc_fd = zbSocOpen(argv[1]);
	}

	if (zbSoc_fd == -1)
	{
		exit(-1);
	}

	zbSocRegisterCallbacks(zbSocCbs);

	zbSocGetInfo();

	while (1)
	{
		struct pollfd pollFd;

		//set the zllSoC serial port FD in the poll file descriptors
		pollFd.fd = zbSoc_fd;
		pollFd.events = POLLIN;

		//printf("%s: waiting for poll()\n", argv[1]);

		poll(&pollFd, 1, 500);

		//printf("%s: got poll()\n", argv[1]);

		//did the poll unblock because of the zllSoC serial?
		if (pollFd.revents)
		{
			//printf("%s: Message from ZB SoC\n", argv[1]);
			zbSocProcessRpc();
		}
                else
                {
                        //printf("timeout\n");
			static int timeoutCnt = 0;
			timeoutCnt++;
			if(timeoutCnt > 5)
			{
				printf("Unknown model\n");
				zbSocClose();
				exit(0);
			}
			else if(timeoutCnt > 3)
			{
				//maybe MT_UTIL is not define, assume coord (nwkAddr=0x0) and try to get model ID
				zbSocGetModel(0x0000, 0xff, afAddr16Bit);
			}
			else
			{
				zbSocGetInfo();
			}
                }
	}

	return retval;
}