예제 #1
0
파일: terminal.c 프로젝트: dresco/WeighFi
uint8_t TerminalReceiveChar(unsigned int timeout)
{
    // Try to read a character from the USB library

    unsigned int start = GetMilliSeconds();

    while (GetMilliSeconds() - start < timeout)
    {
        int16_t ReceivedByte = CDC_Device_ReceiveByte(&VirtualSerial_CDC_Interface);

        if (!(ReceivedByte < 0))
        {
            // got a character
            return((unsigned char)ReceivedByte);
        }
    }
    return 0;
}
예제 #2
0
int _tmain(int argc, _TCHAR* argv[])
{
    std::wcout << L"version : 2015.09.14" << std::endl;
    std::wcout << L"Usage : FbxExporter <path to fbx file> <outdir> [/fps:60|30|24] [/skipemptynodes] [/animstack:\"animstack name\"]" << std::endl;
    if (argc < 3) {
        std::wcerr << L"Invalid argument count" << std::endl;
        return -1;
    }
    std::wstring wInputPath(argv[1]);
    std::wstring wInputDir(argv[1]);
    std::wstring wInputFileName(argv[1]);
    auto lastDirSeparator = wInputDir.find_last_of(L'\\');
    if (lastDirSeparator == wInputDir.npos) {
        wInputDir = L".";
    }
    else {
        wInputDir.erase(lastDirSeparator);
        wInputFileName.erase(0, lastDirSeparator + 1);
    }
    std::wstring wOutputPath(argv[2]);
    CreateDirectory(wOutputPath.c_str(), nullptr);
    bool skipEmptyNodes = false;
    std::wstring animStackName;
    for (int i = 3; i < argc; ++i) {
        std::wstring warg = argv[i];
        if (warg == L"/skipemptynodes") {
            skipEmptyNodes = true;
        }
        else if (warg.find(L"/fps:") == 0) {
            if (warg == L"/fps:60") {
                GlobalSettings::Current().AnimationsTimeMode = FbxTime::EMode::eFrames60;
            }
            else if (warg == L"/fps:30") {
                GlobalSettings::Current().AnimationsTimeMode = FbxTime::EMode::eFrames30;
            }
            else if (warg == L"/fps:24") {
                GlobalSettings::Current().AnimationsTimeMode = FbxTime::EMode::eFrames24;
            }
            else {
                std::wcerr << L"Unrecognized fps parameter" << std::endl;
                return -2;
            }
        }
        else if (warg.find(L"/animstack:") == 0) {
            animStackName = warg.substr(11);

            if (animStackName.size()>0 && animStackName[0] == L'\"') {
                animStackName.erase(0, 1);
            }
            if (animStackName.size() > 0 && animStackName[animStackName.size() - 1] == L'\"') {
                animStackName.erase(animStackName.size() - 1, 1);
            }
        }

    }


    FbxSceneLoader sceneLoader(wstringToUtf8(wInputPath));
    auto animStackCount = sceneLoader.getScene()->GetSrcObjectCount<FbxAnimStack>();
    if (animStackName.size() == 0) {
        GlobalSettings::Current().AnimStackIndex = 0;
    }
    else {
        for (auto ix = 0; ix < animStackCount; ++ix) {
            auto animStack = sceneLoader.getScene()->GetSrcObject<FbxAnimStack>(ix);
            if (utf8ToWstring(animStack->GetName()) == animStackName) {
                GlobalSettings::Current().AnimStackIndex = ix;
            }
        }
    }
    std::wcout << L"Animation stacks : " << std::endl;
    for (auto ix = 0; ix < animStackCount; ++ix) {
        auto animStack = sceneLoader.getScene()->GetSrcObject<FbxAnimStack>(ix);
        if (ix == GlobalSettings::Current().AnimStackIndex) {
            std::wcout << L"[X] ";
            sceneLoader.getScene()->SetCurrentAnimationStack(animStack);
        }
        else {
            std::wcout << L"[ ] ";
        }

        std::wcout << utf8ToWstring(animStack->GetName());
        auto ts=animStack->GetLocalTimeSpan();
        auto start = ts.GetStart();
        auto stop = ts.GetStop();
        std::wcout << L"(" << start.GetMilliSeconds() << L" - " << stop.GetMilliSeconds() << L")" << std::endl;
    }

    auto root = sceneLoader.rootNode();

    BabylonScene babScene(*root, skipEmptyNodes);

    for (auto& mat : babScene.materials()) {
        exportTexture(mat.ambientTexture, wOutputPath);
        exportTexture(mat.diffuseTexture, wOutputPath);
        exportTexture(mat.specularTexture, wOutputPath);
        exportTexture(mat.emissiveTexture, wOutputPath);
        exportTexture(mat.reflectionTexture, wOutputPath);
        exportTexture(mat.bumpTexture, wOutputPath);

    }



    auto json = babScene.toJson();
    if (L'\\' != *wOutputPath.crbegin()) {
        wOutputPath.append(L"\\");
    }
    wOutputPath.append(wInputFileName);

    auto lastDot = wOutputPath.find_last_of(L'.');
    wOutputPath.erase(lastDot);
    wOutputPath.append(L".babylon");
    DeleteFile(wOutputPath.c_str());
    std::ofstream stream(wOutputPath);
    json.serialize(stream);
    stream.flush();
    return 0;
}
예제 #3
0
/*
 * Writes Out information of one frame of the worm to a disk
 * in YAML format.
 *
 * Note the Worm object must have the following fields
 * Worm->frameNum
 * Worm->Segmented->Head
 * Worm->Segmented->Tail
 * Worm->Segmented->LeftBound
 * Worm->Segmented->RightBound
 * Worm->Segmented->Centerline
 *
 * and Params object must have
 * Params->DLPOn
 * Params->IllumSegCenter
 * Params->IllumSegRadius
 * Params->IllumLRC
 *
 * And more now!
 */
int AppendWormFrameToDisk(WormAnalysisData* Worm, WormAnalysisParam* Params, WriteOut* DataWriter){

	CvFileStorage* fs=DataWriter->fs;

	cvStartWriteStruct(fs,NULL,CV_NODE_MAP,NULL);
		/** Frame Number Info **/
		cvWriteInt(fs,"FrameNumber",Worm->frameNum);

		/** TimeStamp **/
		cvWriteInt(fs,"sElapsed",GetSeconds(Worm->timestamp));
		cvWriteInt(fs,"msRemElapsed",GetMilliSeconds(Worm->timestamp));


		/** Segmentation Info **/
		if(cvPointExists(Worm->Segmented->Head)){
		cvStartWriteStruct(fs,"Head",CV_NODE_MAP,NULL);
			cvWriteInt(fs,"x",Worm->Segmented->Head->x);
			cvWriteInt(fs,"y",Worm->Segmented->Head->y);
		cvEndWriteStruct(fs);
		}

		if(cvPointExists(Worm->Segmented->Tail)){
		cvStartWriteStruct(fs,"Tail",CV_NODE_MAP,NULL);
			cvWriteInt(fs,"x",Worm->Segmented->Tail->x);
			cvWriteInt(fs,"y",Worm->Segmented->Tail->y);
		cvEndWriteStruct(fs);
		}


		if(cvSeqExists(Worm->Segmented->LeftBound)) cvWrite(fs,"BoundaryA",Worm->Segmented->LeftBound);
		if(cvSeqExists(Worm->Segmented->RightBound)) cvWrite(fs,"BoundaryB",Worm->Segmented->RightBound);
		if(cvSeqExists(Worm->Segmented->Centerline)) cvWrite(fs,"SegmentedCenterline",Worm->Segmented->Centerline);

		/** Illumination Information **/
		cvWriteInt(fs,"DLPIsOn",Params->DLPOn);
		cvWriteInt(fs,"FloodLightIsOn",Params->IllumFloodEverything);
		cvWriteInt(fs,"IllumInvert",Params->IllumInvert);
		cvWriteInt(fs,"IllumFlipLR",Params->IllumFlipLR);

		CvPoint origin=ConvertSlidlerToWormSpace(Params->IllumSquareOrig,Params->DefaultGridSize);
		cvStartWriteStruct(fs,"IllumRectOrigin",CV_NODE_MAP,NULL);
			cvWriteInt(fs,"x",origin.x);
			cvWriteInt(fs,"y",origin.y);
		cvEndWriteStruct(fs);

		cvStartWriteStruct(fs,"IllumRectRadius",CV_NODE_MAP,NULL);
			cvWriteInt(fs,"x",Params->IllumSquareRad.width);
			cvWriteInt(fs,"y",Params->IllumSquareRad.height);
		cvEndWriteStruct(fs);

		if (Params->stageTrackingOn){
			cvStartWriteStruct(fs,"StageVelocity",CV_NODE_MAP,NULL);
				cvWriteInt(fs,"i",Worm->stageVelocity.x);
				cvWriteInt(fs,"j",Worm->stageVelocity.y);
			cvEndWriteStruct(fs);
		}

		/** Protocol Information **/

		cvWriteInt(fs,"ProtocolIsOn",Params->ProtocolUse);
		cvWriteInt(fs,"ProtocolStep",Params->ProtocolStep);
	cvEndWriteStruct(fs);

	return 0;
}
예제 #4
0
EipStatus
NetworkHandlerInitialize(void)
{
#ifdef WIN32
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	WSAStartup(wVersionRequested, &wsaData);
#endif

	/* clear the master an temp sets                                            */
	FD_ZERO(&master);
	FD_ZERO(&read_fds);

	/* create a new TCP socket */
	if ((g_network_status.tcp_listener = socket(PF_INET, SOCK_STREAM, 0)) == -1)
	{
		OPENER_TRACE_ERR("error allocating socket stream listener, %d\n", errno);
		return kEipStatusError;
	}

	int nOptVal = 1;
	if (setsockopt(g_network_status.tcp_listener, SOL_SOCKET, SO_REUSEADDR,
		(char *)&nOptVal, sizeof(nOptVal)) == -1)
	{
		OPENER_TRACE_ERR("error setting socket option SO_REUSEADDR on nTCPListener\n");
		return kEipStatusError;
	}

	/* create a new UDP unicast socket */
	if ((g_network_status.udp_unicast_listener = socket(PF_INET, SOCK_DGRAM, 0)) == -1)
	{
		OPENER_TRACE_ERR("error allocating udp listener socket, %d\n", errno);
		return kEipStatusError;
	}

	if (setsockopt(g_network_status.udp_unicast_listener, SOL_SOCKET, SO_REUSEADDR,
		(char *)&nOptVal, sizeof(nOptVal)) == -1)
	{
		OPENER_TRACE_ERR("error setting socket option SO_REUSEADDR on nUDPListener\n");
		return kEipStatusError;
	}

	/* create a new UDP broadcast socket */
	if ((g_network_status.udp_broadcast_listener = socket(PF_INET, SOCK_DGRAM, 0)) == -1)
	{
		OPENER_TRACE_ERR("error allocating udp listener socket, %d\n", errno);
		return kEipStatusError;
	}

	if (setsockopt(g_network_status.udp_broadcast_listener, SOL_SOCKET, SO_REUSEADDR,
		(char *)&nOptVal, sizeof(nOptVal)) == -1)
	{
		OPENER_TRACE_ERR("error setting socket option SO_REUSEADDR on nUDPListener\n");
		return kEipStatusError;
	}

	/* set up unicast udp socket */
	struct sockaddr_in unicast_address = { 
		.sin_family = AF_INET,
		.sin_port = htons(kOpenerEthernetPort),
		.sin_addr.s_addr = interface_configuration_.ip_address 
	};

	if ((bind(g_network_status.udp_unicast_listener, (struct sockaddr *) &unicast_address,
		sizeof(struct sockaddr))) == -1)
	{
		int error_code = WSAGetLastError();
		OPENER_TRACE_ERR("error with udp bind: %d, %s\n", error_code, strerror(error_code));
		return kEipStatusError;
	}

	struct sockaddr_in my_address = { 
		.sin_family = AF_INET, 
		.sin_port = htons(kOpenerEthernetPort), 
		.sin_addr.s_addr = htonl(INADDR_ANY)
	};

  /* bind the new socket to port 0xAF12 (CIP) */
  if ((bind(g_network_status.tcp_listener, (struct sockaddr *) &my_address,
      sizeof(struct sockaddr))) == -1)
    {
      OPENER_TRACE_ERR("error with bind: %s\n", strerror(errno));
      return kEipStatusError;
    }

  /* enable the udp socket to receive broadcast messages*/
  int y = 1;
  if (0
      > setsockopt(g_network_status.udp_broadcast_listener, SOL_SOCKET, SO_BROADCAST, (char *)&y,
          sizeof(int)))
    {
      OPENER_TRACE_ERR("error with setting broadcast receive for udp socket: %s\n", strerror(errno));
      return kEipStatusError;
    }

  if ((bind(g_network_status.udp_broadcast_listener, (struct sockaddr *) &my_address,
      sizeof(struct sockaddr))) == -1)
    {
      OPENER_TRACE_ERR("error with udp bind: %s\n", strerror(errno));
      return kEipStatusError;
    }

  /* switch socket in listen mode */
  if ((listen(g_network_status.tcp_listener, MAX_NO_OF_TCP_SOCKETS)) == -1)
    {
      OPENER_TRACE_ERR("networkhandler: error with listen: %s\n", strerror(errno));
      return kEipStatusError;
    }

  /* add the listener socket to the master set */
  FD_SET(g_network_status.tcp_listener, &master);
  FD_SET(g_network_status.udp_broadcast_listener, &master);
  FD_SET(g_network_status.udp_unicast_listener, &master);

  /* keep track of the biggest file descriptor */
  fdmax = GetMaxSocket(g_network_status.tcp_listener, g_network_status.udp_unicast_listener, g_network_status.udp_broadcast_listener, -1);
  last_time = GetMilliSeconds(); /* initialize time keeping */
  g_network_status.elapsed_time = 0;

  return kEipStatusOk;
}

EipStatus
NetworkHandlerProcessOnce(void)
{
  int fd;
  int res;

  read_fds = master;

  time_value.tv_sec = 0;
  time_value.tv_usec = (
      g_network_status.elapsed_time < kOpenerTimerTickInMilliSeconds ? kOpenerTimerTickInMilliSeconds
          - g_network_status.elapsed_time :
          0) * 1000; /* 10 ms */

  res = select(fdmax + 1, &read_fds, 0, 0, &time_value);

  if (res == -1)
    {
      if (EINTR == errno) /* we have somehow been interrupted. The default behavior is to go back into the select loop. */
        {
          return kEipStatusOk;
        }
      else
        {
          OPENER_TRACE_ERR("networkhandler: error with select: %s\n", strerror(errno));
          return kEipStatusError;
        }
    }

  if (res > 0)
    {

      CheckAndHandleTcpListenerSocket();
      CheckAndHandleUdpBroadCastSocket();
	  CheckAndHandleUdpUnicastSocket();
      CheckAndHandleConsumingUdpSockets();

      for (fd = 0; fd <= fdmax; fd++)
        {
          if (true == checkSocketSet(fd))
            {
              /* if it is still checked it is a TCP receive */
              if (kEipStatusError == handleDataOnTCPSocket(fd)) /* if error */
                {
                  CloseSocket(fd);
                  CloseSession(fd); /* clean up session and close the socket */
                }
            }
        }
    }

  actual_time = GetMilliSeconds();
  g_network_status.elapsed_time += actual_time - last_time;
  last_time = actual_time;

  /* check if we had been not able to update the connection manager for several OPENER_TIMER_TICK.
   * This should compensate the jitter of the windows timer
   */
  while (g_network_status.elapsed_time >= kOpenerTimerTickInMilliSeconds)
    {
      /* call manage_connections() in connection manager every OPENER_TIMER_TICK ms */
      ManageConnections();
      g_network_status.elapsed_time -= kOpenerTimerTickInMilliSeconds;
    }
  return kEipStatusOk;
}