Exemple #1
0
void WmLButtonDblclkProc(HWND hwnd, LPARAM lParam){
	ChannelData *cd;
	bool changeFlg = FALSE;

	ChannelDataLock.on();
	cd = channelDataTop;
	while(cd){
		int x = LOWORD(lParam);
		int y = HIWORD(lParam);
		if (cd->checkDown(LOWORD(lParam), HIWORD(lParam))){
			if (!(cd->isSelected())){
				changeFlg = TRUE;
			}
			if (!(cd->getOpenFlg())){
				changeFlg = TRUE;
				cd->setOpenFlg(TRUE);
			} else {
				changeFlg = TRUE;
				cd->setOpenFlg(FALSE);
			}
			cd->setSelected(TRUE);
		} else {
			if (cd->isSelected()){
				changeFlg = TRUE;
			}
			cd->setSelected(FALSE);
		}
/*		int sx = cd->getPosX() + cd->getWidth();
		int sy = cd->getPosY();
		int index = 0;
		ServentData *sd = cd->getServentDataTop();
		while(sd){
			if (	(	(!cd->getOpenFlg())
					&&	(sx + index*14 < x)
					&&	(x < sx + (index+1)*14)
					&&	(sy < y)
					&&	(y < sy + 14)	)
				||	sd->checkDown(LOWORD(lParam), HIWORD(lParam))
			){
				if (!sd->getSelected()){
					changeFlg = TRUE;
				}
				sd->setSelected(TRUE);
			} else {
				if (sd->getSelected()){
					changeFlg = TRUE;
				}
				sd->setSelected(FALSE);
			}
			sd = sd->getNextData();
			index++;
		}*/
		cd = cd->getNextData();
	}
	ChannelDataLock.off();
	if (changeFlg){
		MakeBack(hwnd);
	}
}
Exemple #2
0
void MakeBack(HWND hwnd, UINT x, UINT y){
	MakeBackLock.on();

	winWidth = x;
	winHeight = y;

	if (backGra){
		::delete backBmp;
		::delete backGra;
	}

	backBmp = ::new Bitmap(x,y);
	backGra = ::new Graphics(backBmp);

	// 全て白で塗りつぶし
	SolidBrush b(Color(255,255,255,255));
	backGra->FillRectangle(&b, 0, 0, x, y);

	backWidth = backImage->GetWidth();
	backHeight = backImage->GetHeight();

	// 背景画像を描画
	for (UINT xx = 0; xx < x/backWidth + 1; xx++){
		for (UINT yy = 0; yy < y/backHeight + 1; yy++){
			UINT width,height;
			if (backWidth*(xx+1) > x){
				width = x % backWidth;
			} else {
				width = backWidth;
			}
			if (backHeight*(yy+1) > y){
				height = y % backHeight;
			} else {
				height = backHeight;
			}
			Rect r((INT)backWidth*xx, (INT)backHeight*yy, width, height);
			backGra->DrawImage(backImage, r, 0, 0, (INT)width, (INT)height, UnitPixel);
		}
	}

	INT posX = 20;
	INT posY = 20;

	// 速度描画
	drawSpeed(backGra, winWidth-205, 5);

	// チャンネル情報を描画
	ChannelDataLock.on();
	ChannelData *cd = channelDataTop;
	while(cd){
		posY = cd->drawChannel(backGra, 20, posY);
		cd = cd->getNextData();
	}
	ChannelDataLock.off();
	MakeBackLock.off();
}
Exemple #3
0
ChannelData *findChannelData(int channel_id){
	ChannelData *cd = channelDataTop;

	while(cd){
		if (cd->getChannelId() == channel_id){
			return cd;
		}
		cd = cd->getNextData();
	}

	return NULL;
}
//
// Implementation of the receiveData for both Data and Status consumers
// The execution of these methods happens in a thread created by the Enobio
// instance so accesing GUI resources might lead to a program crash
//
void EnobioDataConsumer::receiveData(const PData &data)
{
    // The EnobioData is destroyed after the execution of receiveData by
    // the caller
    ChannelData * pData = (ChannelData *)data.getData();
    // Provide the data to whatever slot is connected to that signal
    emit newData(QString::number(pData->data()[0]) + "\t" +
                 QString::number(pData->data()[1]) + "\t" +
                 QString::number(pData->data()[2]) + "\t" +
                 QString::number(pData->data()[3]) + "\t" +
                 QString::number(pData->data()[4]) + "\t" +
                 QString::number(pData->data()[5]) + "\t" +
                 QString::number(pData->data()[6]) + "\t" +
                 QString::number(pData->data()[7]) + "\t" +
                 QString::number(pData->timestamp()));
}
    LoggedDataSweep DatalogDownloader::getNextData()
    {
        if(complete())
        {
            throw Error_NoData("There is no more data available to download from the Node.");
        }

        const uint32 startReadIndex = m_nodeMemory->readIndex();
        ChannelData chData;

        try
        {
            //check if the next group of bytes look like the start of a trigger
            if(m_nodeMemory->isNextByteNewHeader())
            {
                //Download Version 1
                if(m_datalogDownloadVersion == 1)
                {
                    //parse the trigger header and update all of the trigger session info
                    parseTriggerHeader_v1();

                    m_foundFirstTrigger = true;
                }
                //Download Version 2
                else
                {
                    //parse the trigger header for v2 and update any new trigger session info
                    parseTriggerHeader_v2();

                    m_foundFirstTrigger = true;
                }
            }
            else
            {
                //if the first trigger hasn't been found yet
                if(!m_foundFirstTrigger)
                {
                    //the start of trigger isn't at the first memory location on the Node
                    m_outOfMemory = true;
                    throw Error_NoData("No triggers were found on the Node.");
                }

                //set the startOfTrigger flag to false
                m_sessionInfo.startOfTrigger = false;
            }

            uint8 lastActiveCh = m_sessionInfo.activeChannels.lastChEnabled();

            Utils::Endianness dataEndian = Utils::bigEndian;
            if(m_datalogDownloadVersion == 2)
            {
                dataEndian = Utils::littleEndian;
            }

            //calibrations are applied if floating point data
            m_sessionInfo.calsApplied = (m_sessionInfo.dataType == WirelessTypes::dataType_float32);

            //loop through all the channels
            for(uint8 chItr = 1; chItr <= lastActiveCh; ++chItr)
            {
                //if the current channel is enabled
                if(m_sessionInfo.activeChannels.enabled(chItr))
                {
                    anyType dataPoint;

                    switch(m_sessionInfo.dataType)
                    {
                        //4 byte float
                        case WirelessTypes::dataType_float32:
                        case WirelessTypes::dataType_float32_noCals:
                            dataPoint = m_nodeMemory->read_float(dataEndian);
                            break;

                        //uint32
                        case WirelessTypes::dataType_uint32:
                            dataPoint = m_nodeMemory->read_uint32(dataEndian);
                            break;

                        //uint24 (get as a uint32)
                        case WirelessTypes::dataType_uint24:
                            dataPoint = m_nodeMemory->read_uint24(dataEndian);
                            break;

                        //uint16 (from a 18-bit device, shift bits)
                        case WirelessTypes::dataType_uint16_18bitTrunc:
                        {
                            uint32 val = m_nodeMemory->read_uint16(dataEndian);
                            dataPoint = (val << 2);
                            break;
                        }

                        //uint16
                        case WirelessTypes::dataType_uint16_shifted:
                        case WirelessTypes::dataType_uint16_12bitRes:
                        case WirelessTypes::dataType_uint16:
                        default:
                            dataPoint = m_nodeMemory->read_uint16(dataEndian);
                            break;
                    }

                    //create a WirelessDataPoint and add it to the ChannelData vector
                    chData.push_back(WirelessDataPoint(static_cast<WirelessChannel::ChannelId>(chItr), chItr, m_sessionInfo.valueType, dataPoint));
                }
            }
        }
        catch(Error_Communication&)
        {
            //downloader v1 needs to reset the memory position on comm failure
            if(m_datalogDownloadVersion == 1)
            {
                //set the read address back so that we the user can retry
                m_nodeMemory->setAddress(startReadIndex);
            }

            //then rethrow the exception
            throw;
        }

        //calculate the timestamp and tick for the sweep
        uint64 sweepTime = m_sessionInfo.timestamp + (m_sessionInfo.timeBetweenSweeps * m_sweepCount);
        uint64 sweepTick = m_sweepCount;

        //increment the sweep count
        m_sweepCount++;

        //return the LoggedDataSweep object containing the data that was downloaded
        return LoggedDataSweep(Timestamp(sweepTime), sweepTick, chData);
    }
Exemple #6
0
void ApiWrap::gotChatFull(PeerData *peer, const MTPmessages_ChatFull &result, mtpRequestId req) {
	const MTPDmessages_chatFull &d(result.c_messages_chatFull());
	const QVector<MTPChat> &vc(d.vchats.c_vector().v);
	bool badVersion = false;
	if (peer->isChat()) {
		badVersion = (!vc.isEmpty() && vc.at(0).type() == mtpc_chat && vc.at(0).c_chat().vversion.v < peer->asChat()->version);
	} else if (peer->isChannel()) {
		badVersion = (!vc.isEmpty() && vc.at(0).type() == mtpc_channel && vc.at(0).c_channel().vversion.v < peer->asChannel()->version);
	}

	App::feedUsers(d.vusers, false);
	App::feedChats(d.vchats, false);

	if (peer->isChat()) {
		if (d.vfull_chat.type() != mtpc_chatFull) {
			LOG(("MTP Error: bad type in gotChatFull for chat: %1").arg(d.vfull_chat.type()));
			return;
		}
		const MTPDchatFull &f(d.vfull_chat.c_chatFull());
		App::feedParticipants(f.vparticipants, false, false);
		const QVector<MTPBotInfo> &v(f.vbot_info.c_vector().v);
		for (QVector<MTPBotInfo>::const_iterator i = v.cbegin(), e = v.cend(); i < e; ++i) {
			switch (i->type()) {
			case mtpc_botInfo: {
				const MTPDbotInfo &b(i->c_botInfo());
				UserData *user = App::userLoaded(b.vuser_id.v);
				if (user) {
					user->setBotInfo(*i);
					App::clearPeerUpdated(user);
					emit fullPeerUpdated(user);
				}
			} break;
			}
		}
		PhotoData *photo = App::feedPhoto(f.vchat_photo);
		ChatData *chat = peer->asChat();
		if (photo) {
			chat->photoId = photo->id;
			photo->peer = chat;
		} else {
			chat->photoId = 0;
		}
		chat->invitationUrl = (f.vexported_invite.type() == mtpc_chatInviteExported) ? qs(f.vexported_invite.c_chatInviteExported().vlink) : QString();

		App::main()->gotNotifySetting(MTP_inputNotifyPeer(peer->input), f.vnotify_settings);
	} else if (peer->isChannel()) {
		if (d.vfull_chat.type() != mtpc_channelFull) {
			LOG(("MTP Error: bad type in gotChatFull for channel: %1").arg(d.vfull_chat.type()));
			return;
		}
		const MTPDchannelFull &f(d.vfull_chat.c_channelFull());
		PhotoData *photo = App::feedPhoto(f.vchat_photo);
		ChannelData *channel = peer->asChannel();
		channel->flagsFull = f.vflags.v;
		if (photo) {
			channel->photoId = photo->id;
			photo->peer = channel;
		} else {
			channel->photoId = 0;
		}
		if (f.has_migrated_from_chat_id()) {
			if (!channel->mgInfo) {
				channel->flags |= MTPDchannel::flag_megagroup;
				channel->flagsUpdated();
			}
			ChatData *cfrom = App::chat(peerFromChat(f.vmigrated_from_chat_id));
			bool updatedTo = (cfrom->migrateToPtr != channel), updatedFrom = (channel->mgInfo->migrateFromPtr != cfrom);
			if (updatedTo) {
				cfrom->migrateToPtr = channel;
			}
			if (updatedFrom) {
				channel->mgInfo->migrateFromPtr = cfrom;
				if (History *h = App::historyLoaded(cfrom->id)) {
					if (History *hto = App::historyLoaded(channel->id)) {
						if (!h->isEmpty()) {
							h->clear(true);
						}
						if (!hto->dialogs.isEmpty() && !h->dialogs.isEmpty()) {
							App::removeDialog(h);
						}
					}
				}
				Notify::migrateUpdated(channel);
			}
			if (updatedTo) {
				Notify::migrateUpdated(cfrom);
				App::main()->peerUpdated(cfrom);
			}
		}
		const QVector<MTPBotInfo> &v(f.vbot_info.c_vector().v);
		for (QVector<MTPBotInfo>::const_iterator i = v.cbegin(), e = v.cend(); i < e; ++i) {
			switch (i->type()) {
			case mtpc_botInfo: {
				const MTPDbotInfo &b(i->c_botInfo());
				UserData *user = App::userLoaded(b.vuser_id.v);
				if (user) {
					user->setBotInfo(*i);
					App::clearPeerUpdated(user);
					emit fullPeerUpdated(user);
				}
			} break;
			}
		}
		channel->about = qs(f.vabout);
		int32 newCount = f.has_participants_count() ? f.vparticipants_count.v : 0;
		if (newCount != channel->count) {
			if (channel->isMegagroup() && !channel->mgInfo->lastParticipants.isEmpty()) {
				channel->mgInfo->lastParticipantsStatus |= MegagroupInfo::LastParticipantsCountOutdated;
				channel->mgInfo->lastParticipantsCount = channel->count;
			}
			channel->count = newCount;
		}
		channel->adminsCount = f.has_admins_count() ? f.vadmins_count.v : 0;
		channel->invitationUrl = (f.vexported_invite.type() == mtpc_chatInviteExported) ? qs(f.vexported_invite.c_chatInviteExported().vlink) : QString();
		if (History *h = App::historyLoaded(channel->id)) {
			if (h->inboxReadBefore < f.vread_inbox_max_id.v + 1) {
				h->setUnreadCount(channel->isMegagroup() ? f.vunread_count.v : f.vunread_important_count.v);
				h->inboxReadBefore = f.vread_inbox_max_id.v + 1;
				h->asChannelHistory()->unreadCountAll = f.vunread_count.v;
			}
		}
		channel->fullUpdated();

		App::main()->gotNotifySetting(MTP_inputNotifyPeer(peer->input), f.vnotify_settings);
	}

	if (req) {
		QMap<PeerData*, mtpRequestId>::iterator i = _fullPeerRequests.find(peer);
		if (i != _fullPeerRequests.cend() && i.value() == req) {
			_fullPeerRequests.erase(i);
		}
	}
	if (badVersion) {
		if (peer->isChat()) {
			peer->asChat()->version = vc.at(0).c_chat().vversion.v;
		} else if (peer->isChannel()) {
			peer->asChannel()->version = vc.at(0).c_channel().vversion.v;
		}
		requestPeer(peer);
	}
	App::clearPeerUpdated(peer);
	emit fullPeerUpdated(peer);
	App::emitPeerUpdated();
}
Exemple #7
0
THREAD_PROC GUIDataUpdate(ThreadInfo *thread){
	int i;

	// set GUI thread status to running
	thread->finish = false;

	while(thread->active){
		// チャンネルデータロック
		ChannelDataLock.on();
		// チャンネルデータの更新フラグを全てFALSEにする
		ChannelData *cd = channelDataTop;
		while(cd){
			// Serventの更新フラグをFALSEにする
			ServentData *sv = cd->getServentDataTop();
			while(sv){
				sv->setEnableFlg(FALSE);
				sv = sv->getNextData();
			}
			cd->setEnableFlg(FALSE);
			cd = cd->getNextData();
		}

		Channel *c = chanMgr->channel;
		// 現在存在するチャンネル分ループ
		while(c){
			// 既にチャンネルデータを持っているか
			cd = channelDataTop;
			// 発見フラグFALSE
			bool bFoundFlg = FALSE;
			while(cd){
				if (cd->getChannelId() == c->channel_id){
					//既にチャンネルデータがあるので、そのまま更新
					cd->setData(c);
					// 更新フラグTRUE
					cd->setEnableFlg(TRUE);
					// 発見フラグTRUE
					bFoundFlg = TRUE;
					// ループ離脱
					break;
				}
				// 見つからなかった場合、次のデータをチェック
				cd = cd->getNextData();
			}

			// 新しいチャンネルの場合、新規データ作成
			if (!bFoundFlg){
				// 新規データ作成
				cd = ::new ChannelData();
				// データ更新
				cd->setData(c);
				// 更新フラグTRUE
				cd->setEnableFlg(TRUE);

				// 新規データをリストの先頭に入れる
				cd->setNextData(channelDataTop);
				channelDataTop = cd;
			}
			// 次のチャンネルを取得
			c = c->next;
		}

#if 1
		// COUTを検索
		{
			bool foundFlg = false;
			bool foundFlg2 = false;
			Servent *s = servMgr->servents;
			while (s)
			{
				if (s->type == Servent::T_COUT && s->status == Servent::S_CONNECTED)
				{
					foundFlg = true;

					// ChannelData末尾まで探索
					ChannelData *prev = NULL;
					cd = channelDataTop;
					while (cd)
					{
						if (cd->type == Servent::T_COUT && cd->servent_id == s->servent_id)
						{
							foundFlg2 = true;
							cd->setEnableFlg(true);
							break;
						}
						prev = cd;
						cd = cd->getNextData();
					}
					cd = prev;

					if (foundFlg2)
						break;

					// ノード追加
					if (channelDataTop)
					{
						// channelDataが空でない。cdはここでリスト末尾を指してる(はず)
						cd->setNextData(::new ChannelData());
						cd = cd->getNextData();
						memset(cd, 0, sizeof(cd));
						cd->setNextData(NULL);
					} else
					{
						// channelDataが空
						channelDataTop = ::new ChannelData();
						channelDataTop->setNextData(NULL);
						cd = channelDataTop;
					}

					// データ設定
					cd->type = s->type;
					cd->servent_id = s->servent_id;
					cd->setEnableFlg(true);
				}

				s = s->next;
			}

			// COUTが切れてたら削除
			if (!foundFlg)
			{
				cd = channelDataTop;
				ChannelData *prev = NULL;
				while (cd)
				{
					// COUTの情報を削除
					if (cd->type == Servent::T_COUT)
					{
						// 先頭
						if (!prev)
						{
							channelDataTop = cd->getNextData();
						} else
						{
							prev->setNextData(cd->getNextData());
						}
						//::delete cd;
					}

					prev = cd;
					cd = cd->getNextData();
				}
			}
		}
#endif

		// チャンネルがなくなっている場合の処理
		cd = channelDataTop;
		ChannelData *prev = NULL; 
		while(cd){
			// データを更新しなかったか
			if (cd->getEnableFlg() == FALSE){
				// チャンネルがなくなっているので削除
				ChannelData *next;
				next = cd->getNextData();
				if (!prev){
					// 先頭のデータを削除
					// ここメモリリークしそう by えるー
					channelDataTop = next;
				} else {
					// 途中のデータを削除
					prev->setNextData(next);
				}
				// 次のデータへ
				cd = next;
			} else {
				// データ更新済:次のデータへ
				prev = cd;
				cd = cd->getNextData();
			}
		}

		Servent *s = servMgr->servents;
		while(s){
			// 初期化
			ChanHitList *chl;
			bool infoFlg = false;
			bool relay = true;
			bool firewalled = false;
			unsigned int numRelays = 0;
			int vp_ver = 0;
			char ver_ex_prefix[2] = {' ', ' '};
			int ver_ex_number = 0;
			// 直下ホスト情報チェック
			unsigned int totalRelays = 0;
			unsigned int totalListeners = 0;

			ChanHit hitData;
			// 受信中か
			if ((s->type == Servent::T_RELAY) && (s->status == Servent::S_CONNECTED)){
				// ホスト情報ロック
				chanMgr->hitlistlock.on();
				// 直下ホストが受信しているチャンネルのホスト情報を取得
				chl = chanMgr->findHitListByID(s->chanID);
				// チャンネルのホスト情報があるか
				if (chl){
					// チャンネルのホスト情報がある場合
					ChanHit *hit = chl->hit;
					// チャンネルのホスト情報を全走査して
					while(hit){
						// IDが同じものであれば
						if (hit->servent_id == s->servent_id){
							// トータルリレーとトータルリスナーを加算
							totalRelays += hit->numRelays;
							totalListeners += hit->numListeners;
							// 直下であれば
							if (hit->numHops == 1){
								// 情報を一旦保存
								infoFlg = true;
								hitData.relay = hit->relay;
								hitData.firewalled = hit->firewalled;
								hitData.numRelays = hit->numRelays;
								hitData.version_vp = hit->version_vp;
								hitData.version_ex_prefix[0] = hit->version_ex_prefix[0];
								hitData.version_ex_prefix[1] = hit->version_ex_prefix[1];
								hitData.version_ex_number = hit->version_ex_number;
							}
						}
						// 次をチェック
						hit = hit->next;
					}
				}

				// チャンネルデータからServentを検索
				bool bFoundFlg = FALSE;
				cd = channelDataTop;
				while(cd){
					ServentData *sv = cd->findServentData(s->servent_id);
					// ServentDataがあれば
					if (sv && cd->getChannelId() == s->channel_id){
						// データ設定
						sv->setData(s, &hitData, totalListeners, totalRelays, infoFlg);
						sv->setEnableFlg(TRUE);
						bFoundFlg = TRUE;
						break;
					}
					cd = cd->getNextData();
				}
				// ServentDataが見つからなかった場合
				if (!bFoundFlg){
					// チャンネルデータを探す
					cd = channelDataTop;
					while(cd){
						// チャンネルIDが同じか
						if (cd->getChannelId() == s->channel_id){
							// データ設定
							ServentData *sv = ::new ServentData();
							sv->setData(s, &hitData, totalListeners, totalRelays, infoFlg);
							sv->setEnableFlg(TRUE);
							// チャンネルデータにServentData追加
							cd->addServentData(sv);
							// ホスト名を取得する
							IdData *id = ::new IdData(cd->getChannelId(), sv->getServentId(), sv->getHost().ip);
							ThreadInfo *t;
							t = ::new ThreadInfo();
							t->func = GetHostName;
							t->data = (void*)id;
							sys->startThread(t);
							LOG_DEBUG("resolving thread was started(%d)", id->getServentId());
							// ループ終了
							break;
						}
						// 次のデータへ
						cd = cd->getNextData();
					}
				}
				// ホスト情報アンロック
				chanMgr->hitlistlock.off();
			}
			s = s->next;
		}

		// 更新していないServentDataを削除
		cd = channelDataTop;
		while(cd){
			cd->deleteDisableServents();
			cd = cd->getNextData();
		}

		// チャンネルデータアンロック
		ChannelDataLock.off();

		// 描画更新
		if (guiWnd){
			MakeBack(guiWnd);
		}

		// 0.1秒×10で1秒待ち
		for(i=0; i<2; i++)
		{
			if (!thread->active)
				break;
			sys->sleep(100);
		}
	}

	// set GUI thread status to terminated
	thread->finish = true;

	return 0;
}
Exemple #8
0
void WmRButtonDownProc(HWND hwnd, LPARAM lParam){
	ChannelData *cd;
	bool changeFlg = FALSE;
	bool channel_selected = FALSE;
	bool servent_selected = FALSE;
	int channel_id = 0;
	int servent_id = 0;

	cd = channelDataTop;
	while(cd){
		if (cd->checkDown(LOWORD(lParam), HIWORD(lParam))){
			if (!(cd->isSelected())){
				changeFlg = TRUE;
			}
			cd->setSelected(TRUE);
			channel_id = cd->getChannelId();
			channel_selected = TRUE;

			// COUT識別
			if (cd->type == Servent::T_COUT)
			{
				channel_selected = FALSE;
				servent_selected = TRUE;
				servent_id = cd->servent_id;
			}
		} else {
			if (cd->isSelected()){
				changeFlg = TRUE;
			}
			cd->setSelected(FALSE);
		}
		ServentData *sd = cd->getServentDataTop();
		while(sd){
			if (sd->checkDown(LOWORD(lParam), HIWORD(lParam))){
				if (!sd->getSelected()){
					changeFlg = TRUE;
				}
				sd->setSelected(TRUE);
				servent_id = sd->getServentId();
				servent_selected = TRUE;
			} else {
				if (sd->getSelected()){
					changeFlg = TRUE;
				}
				sd->setSelected(FALSE);
			}
			sd = sd->getNextData();
		}
		cd = cd->getNextData();
	}
	if (changeFlg){
		MakeBack(hwnd);
	}

	if (channel_selected){
		PopupChannelMenu(channel_id);
	} else if (servent_selected){
		PopupServentMenu(servent_id);
	} else {
		PopupOtherMenu();
	}
}
Exemple #9
0
void PopupOtherMenu(){
	POINT pos;
	MENUITEMINFO info, separator;
	HMENU hMenu;
	DWORD dwID;

	hMenu = CreatePopupMenu();

	memset(&separator, 0, sizeof(MENUITEMINFO));
	separator.cbSize = sizeof(MENUITEMINFO);
	separator.fMask = MIIM_ID | MIIM_TYPE;
	separator.fType = MFT_SEPARATOR;
	separator.wID = 8000;

	memset(&info, 0, sizeof(MENUITEMINFO));
	info.cbSize = sizeof(MENUITEMINFO);
	info.fMask = MIIM_ID | MIIM_TYPE;
	info.fType = MFT_STRING;

	info.wID = 1107;
	info.dwTypeData = "非リレー中のチャンネルを削除";
	InsertMenuItem(hMenu, -1, true, &info);

	InsertMenuItem(hMenu, -1, true, &separator);

	if (!gbDispTop){
		info.wID = 1101;
		info.dwTypeData = "最前面表示";
		InsertMenuItem(hMenu, -1, true, &info);
	} else {
		info.wID = 1102;
		info.dwTypeData = "最前面解除";
		InsertMenuItem(hMenu, -1, true, &info);
	}

	InsertMenuItem(hMenu, -1, true, &separator);

	if (!gbAllOpen){
		info.wID = 1103;
		info.dwTypeData = "全直下展開";
		InsertMenuItem(hMenu, -1, true, &info);
	} else {
		info.wID = 1104;
		info.dwTypeData = "全直下隠蔽";
		InsertMenuItem(hMenu, -1, true, &info);
	}

	InsertMenuItem(hMenu, -1, true, &separator);

	if (!servMgr->autoServe){
		info.wID = 1105;
		info.dwTypeData = "有効";
		InsertMenuItem(hMenu, -1, true, &info);
	} else {
		info.wID = 1106;
		info.dwTypeData = "無効";
		InsertMenuItem(hMenu, -1, true, &info);
	}

	GetCursorPos(&pos);
	dwID = TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RETURNCMD, pos.x, pos.y, 0, guiWnd, NULL);

	DestroyMenu(hMenu);

	ChannelData *cd = channelDataTop;

	switch(dwID){
		case 1101:	// 最前面表示
			gbDispTop = true;
			::SetWindowPos(guiWnd, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
			break;

		case 1102:	// 最前面解除
			gbDispTop = false;
			::SetWindowPos(guiWnd, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
			break;

		case 1103:	// 全直下展開
			gbAllOpen = true;
			while(cd){
				cd->setOpenFlg(true);
				cd = cd->getNextData();
			}
			break;

		case 1104:	// 全直下隠蔽
			gbAllOpen = false;
			while(cd){
				cd->setOpenFlg(false);
				cd = cd->getNextData();
			}
			break;

		case 1105:	// 有効
			servMgr->autoServe = true;
			break;

		case 1106:	// 無効
			servMgr->autoServe = false;
			break;

		case 1107:  // 非リレー中のチャンネル情報を全て削除
			{
				LOG_DEBUG("Start cleaning up unused channels");
				while (cd)
				{
					if (cd->getStatus() == Channel::S_NOTFOUND
						|| cd->getStatus() == Channel::S_IDLE)
					{
						Channel *c = chanMgr->findChannelByChannelID(cd->getChannelId());

						if (c && !c->bumped)
						{
							c->thread.active = false;
							c->thread.finish = true;
						}
					}

					cd = cd->getNextData();
				}
				LOG_DEBUG("Finish a cleanup of unused channels");
			}
			break;
	}
}
Exemple #10
0
void PopupServentMenu(int servent_id){
	POINT pos;
	MENUITEMINFO info, separator;
	HMENU hMenu;
	DWORD dwID;

	hMenu = CreatePopupMenu();

	memset(&separator, 0, sizeof(MENUITEMINFO));
	separator.cbSize = sizeof(MENUITEMINFO);
	separator.fMask = MIIM_ID | MIIM_TYPE;
	separator.fType = MFT_SEPARATOR;
	separator.wID = 8000;

	memset(&info, 0, sizeof(MENUITEMINFO));
	info.cbSize = sizeof(MENUITEMINFO);
	info.fMask = MIIM_ID | MIIM_TYPE;
	info.fType = MFT_STRING;

	ServentData *sd = NULL;
	ChannelData *cd = channelDataTop;
	while(cd){
		// COUT
		if (cd->type == Servent::T_COUT
			&& cd->servent_id == servent_id)
			break;

		sd = cd->findServentData(servent_id);
		if (sd){
			break;
		}
		cd = cd->getNextData();
	}

	if (cd == NULL || sd == NULL
		&& cd->type != Servent::T_COUT) // COUT
	{
		return;
	}

	info.wID = 1001;
	info.dwTypeData = "切断";
	InsertMenuItem(hMenu, -1, true, &info);

//	InsertMenuItem(hMenu, -1, true, &separator);

	GetCursorPos(&pos);
	dwID = TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RETURNCMD, pos.x, pos.y, 0, guiWnd, NULL);

	DestroyMenu(hMenu);

	cd = channelDataTop;
	while(cd){
		// COUT
		if (cd->type == Servent::T_COUT
			&& cd->servent_id == servent_id)
			break;

		sd = cd->findServentData(servent_id);
		if (sd){
			break;
		}
		cd = cd->getNextData();
	}

	if (cd == NULL || sd == NULL
		&& cd->type != Servent::T_COUT) // COUT
	{
		return;
	}

	Servent *s = servMgr->findServentByServentID(servent_id);

	if (s == NULL){
		return;
	}

	switch(dwID){
		case 1001:	// 切断
			s->thread.active = false;

			// COUT切断
			if (s->type == Servent::T_COUT)
				s->thread.finish = true;

			break;

	}
}
Exemple #11
0
void PopupChannelMenu(int channel_id){
	POINT pos;
	MENUITEMINFO info, separator;
	HMENU hMenu;
	DWORD dwID;

	hMenu = CreatePopupMenu();

	memset(&separator, 0, sizeof(MENUITEMINFO));
	separator.cbSize = sizeof(MENUITEMINFO);
	separator.fMask = MIIM_ID | MIIM_TYPE;
	separator.fType = MFT_SEPARATOR;
	separator.wID = 8000;

	memset(&info, 0, sizeof(MENUITEMINFO));
	info.cbSize = sizeof(MENUITEMINFO);
	info.fMask = MIIM_ID | MIIM_TYPE;
	info.fType = MFT_STRING;

	ChannelData *cd = findChannelData(channel_id);

	if (cd == NULL){
		return;
	}

	info.wID = 1001;
	info.dwTypeData = "切断";
	InsertMenuItem(hMenu, -1, true, &info);

	InsertMenuItem(hMenu, -1, true, &separator);

	info.wID = 1000;
	info.dwTypeData = "再生";
	InsertMenuItem(hMenu, -1, true, &info);

	InsertMenuItem(hMenu, -1, true, &separator);

	info.wID = 1002;
	info.dwTypeData = "再接続";
	InsertMenuItem(hMenu, -1, true, &info);

	info.wID = 1003;
	info.dwTypeData = "キープ";
	InsertMenuItem(hMenu, -1, true, &info);

	InsertMenuItem(hMenu, -1, true, &separator);

	if (!cd->getOpenFlg()){
		info.wID = 1004;
		info.dwTypeData = "直下表示";
		InsertMenuItem(hMenu, -1, true, &info);
	} else {
		info.wID = 1005;
		info.dwTypeData = "直下隠蔽";
		InsertMenuItem(hMenu, -1, true, &info);
	}

	GetCursorPos(&pos);
	dwID = TrackPopupMenu(hMenu, TPM_LEFTALIGN|TPM_RETURNCMD, pos.x, pos.y, 0, guiWnd, NULL);

	DestroyMenu(hMenu);

	cd = findChannelData(channel_id);

	if (cd == NULL){
		return;
	}

	Channel *c = chanMgr->findChannelByChannelID(channel_id);

	if (c == NULL){
		return;
	}

	switch(dwID){
		case 1000:	// 再生
			chanMgr->playChannel(c->info);
			break;

		case 1001:	// 切断
			// bump中は切断しない
			if (!c->bumped)
			{
				c->thread.active = false;
				c->thread.finish = true;
			}
			break;

		case 1002:	// 再接続
			// 直下かつ受信中であれば確認メッセージ表示
			if (cd->isTracker() && cd->getStatus() == Channel::S_RECEIVING)
			{
				int id;
				id = MessageBox(guiWnd,
					"直下ですが再接続しますか?",
					"直下警告",
					MB_YESNO|MB_ICONQUESTION|MB_DEFBUTTON2);
				if (id != IDYES)
					break;
			}

			c->bump = true;
			break;

		case 1003:	// キープ
			if (!c->stayConnected){
				c->stayConnected  = true;
			} else {
				c->stayConnected = false;
			}
			break;

		case 1004:	// 直下表示
			cd->setOpenFlg(TRUE);
			MakeBack(guiWnd);
			break;

		case 1005:	// 直下隠蔽
			cd->setOpenFlg(FALSE);
			MakeBack(guiWnd);
			break;
	}
}
Exemple #12
0
THREAD_PROC GetHostName(ThreadInfo *thread){
	IdData *id = (IdData*)(thread->data);

	//HOSTENT *he;
	u_long ip;
	struct sockaddr_in sa;
	char host[256];
	char *tmp;
	bool flg = TRUE;
	bool findFlg;
	int error;

	ip = htonl(id->getIpAddr());

	memset(&sa, 0, sizeof(sa));
	sa.sin_addr.S_un.S_addr = ip;
	sa.sin_family = AF_INET;

	for (int i=0; i<10 && flg; i++){
		error = getnameinfo(reinterpret_cast<sockaddr*>(&sa), sizeof(sa), host, sizeof(host)/sizeof(host[0]), NULL, 0, NI_NAMEREQD);
		switch (error)
		{
		case 0:
			// success
			flg = FALSE;
			break;

		case WSAHOST_NOT_FOUND:
			LOG_ERROR("cannot resolve host for %s",
				((tmp = inet_ntoa(sa.sin_addr)) ? tmp : ""));
			flg = TRUE;
			break;

		default:
			LOG_ERROR("an error occurred while resolving hostname of %s (%ld)",
				((tmp = inet_ntoa(sa.sin_addr)) ? tmp : ""), error);
		}
	}

	if (error)
		return 0;

	for (flg=TRUE, findFlg=FALSE; flg; )
	{
		ChannelDataLock.on();
		ChannelData* cd = channelDataTop;

		while(cd){
			if (cd->getChannelId() == id->getChannelId())
			{
				findFlg = TRUE;

				if (cd->findServentData(id->getServentId()))
				{
					if (cd->setName(id->getServentId(), host))
					{
						LOG_DEBUG("successfully resolved(%d)", id->getServentId());
						flg = FALSE;
						break;
					} else
					{
						LOG_ERROR("cannot update servent data with resolved information");
						flg = FALSE;
						break;
					}
				} else
				{
					LOG_DEBUG("servent data has been removed");
					flg = FALSE;
					break;
				}
			}

			cd = cd->getNextData();
		}

//		::delete id;
		ChannelDataLock.off();

		if (!findFlg)
		{
			LOG_DEBUG("servent data has been removed(channel)");
			flg = FALSE;
		}

		sys->sleep(1000);
	}


	return 0;
}
    void AsyncDigitalAnalogPacket::parseSweeps()
    {
        const uint32 TS_OFFSET_LEN = 2;    //timestamp offset is always 2 bytes
        const uint32 DIGITAL_LEN = 2;        //digital data is always 2 bytes

        //read the values from the payload
        uint16 channelMask        = m_payload.read_uint16(PAYLOAD_OFFSET_CHANNEL_MASK);
        uint8 dataType            = m_payload.read_uint8(PAYLOAD_OFFSET_DATA_TYPE);
        uint16 tick                = m_payload.read_uint16(PAYLOAD_OFFSET_TICK);
        uint64 timestampSeconds    = m_payload.read_uint32(PAYLOAD_OFFSET_TS_SEC);        //the timestamp (UTC) seconds part
        uint64 timestampNanos    = m_payload.read_uint32(PAYLOAD_OFFSET_TS_NANOSEC);    //the timestamp (UTC) nanoseconds part

        //build the full nanosecond resolution timestamp from the seconds and nanoseconds values read above
        uint64 packetTimestamp = (timestampSeconds * TimeSpan::NANOSECONDS_PER_SECOND) + timestampNanos;

        //build the ChannelMask from the channel mask
        ChannelMask channels(channelMask);

        //set the data type of the packet
        m_dataType = static_cast<WirelessTypes::DataType>(dataType);

        //create a sample rate for this data
        static const SampleRate digitalRate = SampleRate::Event();

        std::size_t payloadLen = m_payload.size();
        uint16 sweepItr = 0;

        //find the offset into the payload to get the data
        uint32 byteItr = PAYLOAD_OFFSET_CHANNEL_DATA;

        //while there is still more data for us to read
        while(byteItr < payloadLen)
        {
            //build a sweep to add
            DataSweep sweep;
            sweep.samplingType(DataSweep::samplingType_AsyncDigitalAnalog);
            sweep.frequency(m_frequency);
            sweep.tick(tick++);
            sweep.nodeAddress(m_nodeAddress);
            sweep.sampleRate(digitalRate);

            //get this sweep's timestamp offset
            uint64 timeOffset = m_payload.read_uint16(byteItr);
            byteItr += TS_OFFSET_LEN;

            //get this sweep's digital data value
            uint16 digitalData = m_payload.read_uint16(byteItr);
            byteItr += DIGITAL_LEN;

            //build this sweep's timestamp
            sweep.timestamp(Timestamp(packetTimestamp + ((timeOffset * TimeSpan::NANOSECONDS_PER_SECOND) / 32768) ));            

            //get this sweep's node and base rssi values
            sweep.nodeRssi(m_nodeRSSI);
            sweep.baseRssi(m_baseRSSI);
            sweep.calApplied(m_dataType == WirelessTypes::dataType_float32);

            //the digital data is represented as the same structure as a channel mask (16 values, 1 or 0)
            ChannelMask digitalDataMask(digitalData);

            ChannelData chData;

            uint8 lastActiveCh = channels.lastChEnabled();

            //loop through all the channels
            for(uint8 chItr = 1; chItr <= lastActiveCh; ++chItr)
            {
                //if the current channel is enabled
                if(channels.enabled(chItr))
                {
                    //if the digital value is enabled (active) for this channel
                    if(digitalDataMask.enabled(chItr))
                    {
                        //create a WirelessDataPoint from the analog data
                        WirelessDataPoint analogPoint = createAnalogDataPoint(chItr, byteItr);

                        //move the byteItr forward for the amount of bytes we read
                        byteItr += WirelessTypes::dataTypeSize(m_dataType);

                        //add the point to the ChannelData vector
                        chData.push_back(analogPoint);
                    }
                }
            }

            //add the channel data to the sweep
            sweep.data(chData);

            //add the sweep to the container of sweeps
            addSweep(sweep);

            //moving on to the next sweep in the packet
            sweepItr++;
        }

        //if we didn't add any sweeps, there was an error in the packet
        if(sweepItr == 0) { throw Error("Invalid Packet"); }
    }
	void HclSmartBearing_RawPacket::parseSweeps_baseBoard()
	{
		typedef WirelessChannel WC;
		static const uint16 PAYLOAD_OFFSET_MAG_CONVERSION = 13;

		//read the values from the payload
		uint8 sensorErrorMask	= m_payload.read_uint8(PAYLOAD_OFFSET_ERROR_MASK);
		uint8 sampleRate		= m_payload.read_uint8(PAYLOAD_OFFSET_SAMPLE_RATE);
		uint16 tick				= m_payload.read_uint16(PAYLOAD_OFFSET_TICK);
		uint64 timestampSeconds	= m_payload.read_uint32(PAYLOAD_OFFSET_TS_SEC);		//the timestamp (UTC) seconds part
		uint64 timestampNanos	= m_payload.read_uint32(PAYLOAD_OFFSET_TS_NANOSEC);	//the timestamp (UTC) nanoseconds part
		m_magConversionVal		= static_cast<float>(m_payload.read_uint16(PAYLOAD_OFFSET_MAG_CONVERSION));

		//build the full nanosecond resolution timestamp from the seconds and nanoseconds values read above
		uint64 realTimestamp = (timestampSeconds * TimeSpan::NANOSECONDS_PER_SECOND) + timestampNanos;

		//create a SampleRate object from the sampleRate byte
		SampleRate currentRate = SampleUtils::convertToSampleRate(sampleRate);

		//build the single sweep
		DataSweep sweep;
		sweep.samplingType(DataSweep::samplingType_SyncSampling);
		sweep.frequency(m_frequency);
		sweep.tick(tick);
		sweep.nodeAddress(m_nodeAddress);
		sweep.sampleRate(currentRate);
		sweep.timestamp(Timestamp(realTimestamp));
		sweep.nodeRssi(m_nodeRSSI);
		sweep.baseRssi(m_baseRSSI);

		static const uint16 DATA_START = 15;

		ChannelData chData;
		chData.reserve(28);
		chData.emplace_back(WC::channel_error_code, 0, valueType_uint8, anyType(sensorErrorMask));	//Error Mask (not actually in payload)
		chData.emplace_back(WC::channel_hcl_rawBase_mag1_x, 1, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 0)));	//Mag 1 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag1_y, 2, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 2)));	//Mag 1 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag1_z, 3, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 4)));	//Mag 1 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag2_x, 4, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 6)));	//Mag 2 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag2_y, 5, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 8)));	//Mag 2 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag2_z, 6, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 10)));	//Mag 2 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag3_x, 7, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 12)));	//Mag 3 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag3_y, 8, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 14)));	//Mag 3 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag3_z, 9, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 16)));	//Mag 3 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag4_x, 10, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 18)));	//Mag 4 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag4_y, 11, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 20)));	//Mag 4 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag4_z, 12, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 22)));	//Mag 4 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag5_x, 13, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 24)));	//Mag 5 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag5_y, 14, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 26)));	//Mag 5 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag5_z, 15, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 28)));	//Mag 5 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag6_x, 16, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 30)));	//Mag 6 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag6_y, 17, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 32)));	//Mag 6 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag6_z, 18, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 34)));	//Mag 6 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag7_x, 19, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 36)));	//Mag 7 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag7_y, 20, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 38)));	//Mag 7 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag7_z, 21, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 40)));	//Mag 7 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_mag8_x, 22, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 42)));	//Mag 8 - X
		chData.emplace_back(WC::channel_hcl_rawBase_mag8_y, 23, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 44)));	//Mag 8 - Y
		chData.emplace_back(WC::channel_hcl_rawBase_mag8_z, 24, valueType_float, getMagChValue(m_payload.read_uint16(DATA_START + 46)));	//Mag 8 - Z
		chData.emplace_back(WC::channel_hcl_rawBase_gyro_x, 25, valueType_float, anyType(m_payload.read_float(DATA_START + 48)));			//Gyro - X
		chData.emplace_back(WC::channel_hcl_rawBase_gyro_y, 26, valueType_float, anyType(m_payload.read_float(DATA_START + 52)));			//Gyro - Y
		chData.emplace_back(WC::channel_hcl_rawBase_gyro_z, 27, valueType_float, anyType(m_payload.read_float(DATA_START + 56)));			//Gyro - Z

		//add all of the channel data to the sweep
		sweep.data(chData);

		//add the sweep to the container of sweeps
		addSweep(sweep);
	}
Exemple #15
0
    void DiagnosticPacket::addDataPoint(ChannelData& container, DataBuffer& payload, uint8 infoLength, uint8 infoId) const
    {
        switch(infoId)
        {
            //Current State
            case 0:
                container.emplace_back(WirelessChannel::channel_diag_state, 0, valueType_uint8, anyType(payload.read_uint8()));
                break;

            //Run Time
            case 1:
                //idle time
                container.emplace_back(WirelessChannel::channel_diag_runtime_idle, 0, valueType_uint32, anyType(payload.read_uint32()));

                //sleep time
                container.emplace_back(WirelessChannel::channel_diag_runtime_sleep, 0, valueType_uint32, anyType(payload.read_uint32()));

                //active run time
                container.emplace_back(WirelessChannel::channel_diag_runtime_activeRun, 0, valueType_uint32, anyType(payload.read_uint32()));

                //inactive run time
                container.emplace_back(WirelessChannel::channel_diag_runtime_inactiveRun, 0, valueType_uint32, anyType(payload.read_uint32()));
                break;

            //Reset Counter
            case 2:
                container.emplace_back(WirelessChannel::channel_diag_resetCounter, 0, valueType_uint16, anyType(payload.read_uint16()));
                break;

            //Battery flag
            case 3:
                container.emplace_back(WirelessChannel::channel_diag_lowBatteryFlag, 0, valueType_uint8, anyType(payload.read_uint8()));
                break;

            //Sample info
            case 4:
                //sweep index
                container.emplace_back(WirelessChannel::channel_diag_sweepIndex, 0, valueType_uint32, anyType(payload.read_uint32()));

                //bad sweep count
                container.emplace_back(WirelessChannel::channel_diag_badSweepCount, 0, valueType_uint32, anyType(payload.read_uint32()));
                break;

            //Transmit info
            case 5:
                //total transmissions
                container.emplace_back(WirelessChannel::channel_diag_totalTx, 0, valueType_uint32, anyType(payload.read_uint32()));

                //total retransmissions
                container.emplace_back(WirelessChannel::channel_diag_totalReTx, 0, valueType_uint32, anyType(payload.read_uint32()));

                //total dropped packets
                container.emplace_back(WirelessChannel::channel_diag_totalDroppedPackets, 0, valueType_uint32, anyType(payload.read_uint32()));
                break;

            //Built in Test result
            case 6:
                //BIT
                container.emplace_back(WirelessChannel::channel_diag_builtInTestResult, 0, valueType_uint32, anyType(payload.read_uint32()));
                break;

            //Unknown info
            default:
            {
                //read past the bytes we don't know about
                for(uint8 i = 0; i < infoLength; i++)
                {
                    payload.read_uint8();
                }
            }
            break;
        }
    }
    void HclSmartBearing_CalPacket::parseSweeps()
    {
        typedef WirelessChannel WC;

        //read the values from the payload
        uint8 sensorErrorMask = m_payload.read_uint8(PAYLOAD_OFFSET_ERROR_MASK);
        uint8 sampleRate = m_payload.read_uint8(PAYLOAD_OFFSET_SAMPLE_RATE);
        uint16 tick = m_payload.read_uint16(PAYLOAD_OFFSET_TICK);
        uint64 timestampSeconds = m_payload.read_uint32(PAYLOAD_OFFSET_TS_SEC);      //the timestamp (UTC) seconds part
        uint64 timestampNanos = m_payload.read_uint32(PAYLOAD_OFFSET_TS_NANOSEC);    //the timestamp (UTC) nanoseconds part

        //build the full nanosecond resolution timestamp from the seconds and nanoseconds values read above
        uint64 realTimestamp = (timestampSeconds * TimeSpan::NANOSECONDS_PER_SECOND) + timestampNanos;

        //create a SampleRate object from the sampleRate byte
        SampleRate currentRate = SampleUtils::convertToSampleRate(sampleRate);

        //build the single sweep
        DataSweep sweep;
        sweep.samplingType(DataSweep::samplingType_SyncSampling);
        sweep.frequency(m_frequency);
        sweep.tick(tick);
        sweep.nodeAddress(m_nodeAddress);
        sweep.sampleRate(currentRate);
        sweep.timestamp(Timestamp(realTimestamp));
        sweep.nodeRssi(m_nodeRSSI);
        sweep.baseRssi(m_baseRSSI);
        sweep.calApplied(true);

        static const uint16 DATA_START = 13;

        ChannelData chData;
        chData.reserve(12);
        chData.emplace_back(WC::channel_error_code, 0, valueType_uint8, anyType(sensorErrorMask));    //Error Mask (not actually in payload)
        chData.emplace_back(WC::channel_hcl_axialLoadX, 1, valueType_int16, anyType(m_payload.read_int16(DATA_START + 0)));
        chData.emplace_back(WC::channel_hcl_axialLoadY, 2, valueType_int16, anyType(m_payload.read_int16(DATA_START + 2)));
        chData.emplace_back(WC::channel_hcl_axialLoadZ, 3, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 4)) * 10));
        chData.emplace_back(WC::channel_hcl_bendingMomentFlap, 4, valueType_int16, anyType(m_payload.read_int16(DATA_START + 6)));
        chData.emplace_back(WC::channel_hcl_bendingMomentLag, 5, valueType_int16, anyType(m_payload.read_int16(DATA_START + 8)));
        chData.emplace_back(WC::channel_hcl_bendingMomentPitch, 6, valueType_int16, anyType(m_payload.read_int16(DATA_START + 10)));
        chData.emplace_back(WC::channel_hcl_motionFlap_mag, 7, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 12) / 1000.0)));
        chData.emplace_back(WC::channel_hcl_motionLag_mag, 8, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 14) / 1000.0)));
        chData.emplace_back(WC::channel_hcl_motionPitch_mag, 9, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 16) / 1000.0)));
        chData.emplace_back(WC::channel_hcl_motionFlap_inertial, 10, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 18) / 1000.0)));
        chData.emplace_back(WC::channel_hcl_motionLag_inertial, 11, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 20) / 1000.0)));
        chData.emplace_back(WC::channel_hcl_motionPitch_inertial, 12, valueType_float, anyType(static_cast<float>(m_payload.read_int16(DATA_START + 22) / 1000.0)));
        chData.emplace_back(WC::channel_hcl_cockingStiffness_mag, 13, valueType_int16, anyType(m_payload.read_int16(DATA_START + 24)));
        chData.emplace_back(WC::channel_hcl_cockingStiffness_inertial, 14, valueType_int16, anyType(m_payload.read_int16(DATA_START + 26)));
        chData.emplace_back(WC::channel_hcl_temperature, 15, valueType_int16, anyType(static_cast<int16>(m_payload.read_int8(DATA_START + 28))));

        //add all of the channel data to the sweep
        sweep.data(chData);

        //add the sweep to the container of sweeps
        addSweep(sweep);
    }