void NaoMarkServiceDetection::callback(const std::string &key, const AL::ALValue &value, const AL::ALValue &msg)
{
AL::ALValue marks = fMemoryProxy.getData("LandmarkDetected");
if(marks.getSize() > 0 && !_isMarkFound)
{
int TimeStampField = marks[0][1];
if((int)marks[1][0][1][0] == _markToFind)
{
if((float)marks[1][0][0][3] < 0.2f)
{
if(_isAllowedToMove)
motionProxy->moveToward(0.5f,0,marks[1][0][0][1]);
_naoMarkDetected = true;
}
else
{
motionProxy->moveToward(0,0,0);
_isMarkFound = true;
}
}
else
motionProxy->moveToward(0,0,0);
}
}
void NaoMarkServiceDetection::init() {
try
{
fMemoryProxy.subscribeToEvent("LandmarkDetected", "Events", "userDataToIdentifyEvent", "callback");
}
catch (const AL::ALError& e) {
qiLogError("module.example") << e.what() << std::endl;
}
}
void Bumper::init() {
try {
/** Create a proxy to ALMemory.
*/
fMemoryProxy = AL::ALMemoryProxy(getParentBroker());
fState = fMemoryProxy.getData("RightBumperPressed");
/** Subscribe to event LeftBumperPressed
* Arguments:
* - name of the event
* - name of the module to be called for the callback
* - name of the bound method to be called on event
*/
fMemoryProxy.subscribeToEvent("RightBumperPressed", "Bumper",
"onRightBumperPressed");
}
catch (const AL::ALError& e) {
qiLogError("module.example") << e.what() << std::endl;
}
}
void Bumper::onRightBumperPressed() {
qiLogInfo("module.example") << "Executing callback method on right bumper event" << std::endl;
/**
* As long as this is defined, the code is thread-safe.
*/
AL::ALCriticalSection section(fCallbackMutex);
/**
* Check that the bumper is pressed.
*/
fState = fMemoryProxy.getData("RightBumperPressed");
if (fState > 0.5f) {
return;
}
try {
fTtsProxy = AL::ALTextToSpeechProxy(getParentBroker());
fTtsProxy.say("Right bumper pressed");
}
catch (const AL::ALError& e) {
qiLogError("module.example") << e.what() << std::endl;
}
}
/**
* The constructor sets up the structures required to communicate with NAOqi.
* @param pBroker A NAOqi broker that allows accessing other NAOqi modules.
*/
GameCtrl(boost::shared_ptr<AL::ALBroker> pBroker)
: ALModule(pBroker, "GameCtrl"),
proxy(0),
memory(0),
udp(0),
teamNumber(0)
{
setModuleDescription("A module that provides packets from the GameController.");
assert(numOfButtons == sizeof(buttonNames) / sizeof(*buttonNames));
assert(numOfLEDs == sizeof(ledNames) / sizeof(*ledNames));
init();
try
{
memory = new AL::ALMemoryProxy(pBroker);
proxy = new AL::DCMProxy(pBroker);
AL::ALValue params;
AL::ALValue result;
params.arraySetSize(1);
params.arraySetSize(2);
params[0] = std::string("leds");
params[1].arraySetSize(numOfLEDs);
for(int i = 0; i < numOfLEDs; ++i)
params[1][i] = std::string(ledNames[i]);
result = proxy->createAlias(params);
assert(result == params);
ledRequest.arraySetSize(6);
ledRequest[0] = std::string("leds");
ledRequest[1] = std::string("ClearAll");
ledRequest[2] = std::string("time-separate");
ledRequest[3] = 0;
ledRequest[4].arraySetSize(1);
ledRequest[5].arraySetSize(numOfLEDs);
for(int i = 0; i < numOfLEDs; ++i)
ledRequest[5][i].arraySetSize(1);
for(int i = 0; i < numOfButtons; ++i)
buttons[i] = (float*) memory->getDataPtr(buttonNames[i]);
// If no color was set, set it to black (no LED).
// This actually has a race condition.
if(memory->getDataList("GameCtrl/teamColour").empty())
memory->insertData("GameCtrl/teamColour", TEAM_BLACK);
playerNumber = (int*) memory->getDataPtr("GameCtrl/playerNumber");
teamNumberPtr = (int*) memory->getDataPtr("GameCtrl/teamNumber");
defaultTeamColour = (int*) memory->getDataPtr("GameCtrl/teamColour");
// register "onPreProcess" and "onPostProcess" callbacks
theInstance = this;
proxy->getGenericProxy()->getModule()->atPreProcess(&onPreProcess);
proxy->getGenericProxy()->getModule()->atPostProcess(&onPostProcess);
udp = new UdpComm();
if(!udp->setBlocking(false) ||
!udp->setBroadcast(true) ||
!udp->bind("0.0.0.0", GAMECONTROLLER_DATA_PORT) ||
!udp->setLoopback(false))
{
fprintf(stderr, "libgamectrl: Could not open UDP port\n");
delete udp;
udp = 0;
// continue, because button interface will still work
}
publish();
}
catch(AL::ALError& e)
{
fprintf(stderr, "libgamectrl: %s\n", e.what());
close();
}
}
/**
* Publishes the current state of the GameController packet in ALMemory.
*/
void publish()
{
AL::ALValue value((const char*) &gameCtrlData, sizeof(gameCtrlData));
memory->insertData("GameCtrl/RoboCupGameControlData", value);
}
/**
* Handles the button interface.
* Resets the internal state when a new team number was set.
* Receives packets from the GameController.
* Initializes gameCtrlData when teamNumber and playerNumber are available.
*/
void handleInput()
{
unsigned now = (unsigned) proxy->getTime(0);
if(*teamNumberPtr != 0)
{
// new team number was set -> reset internal structure
teamNumber = *teamNumberPtr;
memory->insertData("GameCtrl/teamNumber", 0);
init();
}
if(receive())
{
if(!whenPacketWasReceived)
previousState = (uint8_t) -1; // force LED update on first packet received
whenPacketWasReceived = now;
publish();
}
if(teamNumber && *playerNumber)
{
// init gameCtrlData if invalid
if(gameCtrlData.teams[0].teamNumber != teamNumber &&
gameCtrlData.teams[1].teamNumber != teamNumber)
{
uint8_t teamColour = (uint8_t) *defaultTeamColour;
if(teamColour != TEAM_BLUE && teamColour != TEAM_RED && teamColour != TEAM_YELLOW &&
teamColour != TEAM_WHITE && teamColour != TEAM_GREEN && teamColour != TEAM_ORANGE &&
teamColour != TEAM_PURPLE && teamColour != TEAM_BROWN && teamColour != TEAM_GRAY)
teamColour = TEAM_BLACK;
gameCtrlData.teams[0].teamNumber = (uint8_t) teamNumber;
gameCtrlData.teams[0].teamColour = teamColour;
gameCtrlData.teams[1].teamColour = teamColour ^ 1; // we don't know better
if(!gameCtrlData.playersPerTeam)
gameCtrlData.playersPerTeam = (uint8_t) *playerNumber; // we don't know better
publish();
}
TeamInfo& team = gameCtrlData.teams[gameCtrlData.teams[0].teamNumber == teamNumber ? 0 : 1];
if(*playerNumber <= gameCtrlData.playersPerTeam)
{
bool chestButtonPressed = *buttons[chest] != 0.f;
if(chestButtonPressed != previousChestButtonPressed && now - whenChestButtonStateChanged >= BUTTON_DELAY)
{
if(chestButtonPressed && whenChestButtonStateChanged && now - whenPacketWasReceived >= GAMECONTROLLER_TIMEOUT) // ignore first press, e.g. for getting up
{
RobotInfo& player = team.players[*playerNumber - 1];
if(player.penalty == PENALTY_NONE)
{
player.penalty = PENALTY_MANUAL;
}
else
{
player.penalty = PENALTY_NONE;
gameCtrlData.state = STATE_PLAYING;
}
publish();
}
previousChestButtonPressed = chestButtonPressed;
whenChestButtonStateChanged = now;
}
if(gameCtrlData.state == STATE_INITIAL)
{
bool leftFootButtonPressed = *buttons[leftFootLeft] != 0.f || *buttons[leftFootRight] != 0.f;
if(leftFootButtonPressed != previousLeftFootButtonPressed && now - whenLeftFootButtonStateChanged >= BUTTON_DELAY)
{
if(leftFootButtonPressed)
{
team.teamColour = (team.teamColour + 1) % 10; // cycle between TEAM_BLUE .. TEAM_GRAY
publish();
}
previousLeftFootButtonPressed = leftFootButtonPressed;
whenLeftFootButtonStateChanged = now;
}
bool rightFootButtonPressed = *buttons[rightFootLeft] != 0.f || *buttons[rightFootRight] != 0.f;
if(rightFootButtonPressed != previousRightFootButtonPressed && now - whenRightFootButtonStateChanged >= BUTTON_DELAY)
{
if(rightFootButtonPressed)
{
if(gameCtrlData.gamePhase == GAME_PHASE_NORMAL)
{
gameCtrlData.gamePhase = GAME_PHASE_PENALTYSHOOT;
gameCtrlData.kickingTeam = team.teamNumber;
}
else if(gameCtrlData.kickingTeam == team.teamNumber)
gameCtrlData.kickingTeam = 0;
else
gameCtrlData.gamePhase = GAME_PHASE_NORMAL;
publish();
}
previousRightFootButtonPressed = rightFootButtonPressed;
whenRightFootButtonStateChanged = now;
}
}
}
else
fprintf(stderr, "Player number %d too big. Maximum number is %d.\n", *playerNumber, gameCtrlData.playersPerTeam);
}
}
/**
* The constructor initializes the shared memory for communicating with bhuman.
* It also establishes a communication with NaoQi and prepares all data structures
* required for this communication.
* @param pBroker A NaoQi broker that allows accessing other NaoQi modules.
*/
BHuman(boost::shared_ptr<AL::ALBroker> pBroker) :
ALModule(pBroker, "BHuman"),
data((LBHData*) MAP_FAILED),
sem(SEM_FAILED),
proxy(0),
memory(0),
dcmTime(0),
lastReadingActuators(-1),
actuatorDrops(0),
frameDrops(allowedFrameDrops + 1),
state(sitting),
phase(0.f),
ledIndex(0),
rightEarLEDsChangedTime(0),
startPressedTime(0),
lastBHumanStartTime(0)
{
setModuleDescription("A module that provides basic ipc NaoQi DCM access using shared memory.");
fprintf(stderr, "libbhuman: Starting.\n");
assert(lbhNumOfSensorIds == sizeof(sensorNames) / sizeof(*sensorNames));
assert(lbhNumOfActuatorIds == sizeof(actuatorNames) / sizeof(*actuatorNames));
assert(lbhNumOfTeamInfoIds == sizeof(teamInfoNames) / sizeof(*teamInfoNames));
// create shared memory
memoryHandle = shm_open(LBH_MEM_NAME, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
if(memoryHandle == -1)
perror("libbhuman: shm_open");
else if(ftruncate(memoryHandle, sizeof(LBHData)) == -1)
perror("libbhuman: ftruncate");
else
{
// map the shared memory
data = (LBHData*) mmap(NULL, sizeof(LBHData), PROT_READ | PROT_WRITE, MAP_SHARED, memoryHandle, 0);
if(data == MAP_FAILED)
perror("libbhuman: mmap");
else
{
memset(data, 0, sizeof(LBHData));
// open semaphore
sem = sem_open(LBH_SEM_NAME, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR, 0);
if(sem == SEM_FAILED)
perror("libbhuman: sem_open");
else
try
{
// get the robot name
memory = new AL::ALMemoryProxy(pBroker);
std::string robotName = (std::string) memory->getData("Device/DeviceList/ChestBoard/BodyNickName", 0);
strncpy(data->robotName, robotName.c_str(), sizeof(data->robotName));
// create "positionRequest" and "hardnessRequest" alias
proxy = new AL::DCMProxy(pBroker);
AL::ALValue params;
AL::ALValue result;
params.arraySetSize(1);
params.arraySetSize(2);
params[0] = std::string("positionActuators");
params[1].arraySetSize(lbhNumOfPositionActuatorIds);
for(int i = 0; i < lbhNumOfPositionActuatorIds; ++i)
params[1][i] = std::string(actuatorNames[i]);
result = proxy->createAlias(params);
params[0] = std::string("hardnessActuators");
params[1].arraySetSize(lbhNumOfHardnessActuatorIds);
for(int i = 0; i < lbhNumOfHardnessActuatorIds; ++i)
params[1][i] = std::string(actuatorNames[headYawHardnessActuator + i]);
result = proxy->createAlias(params);
params[0] = std::string("usRequest");
params[1].arraySetSize(1);
params[1][0] = std::string(actuatorNames[usActuator]);
result = proxy->createAlias(params);
// prepare positionRequest
positionRequest.arraySetSize(6);
positionRequest[0] = std::string("positionActuators");
positionRequest[1] = std::string("ClearAll");
positionRequest[2] = std::string("time-separate");
positionRequest[3] = 0;
positionRequest[4].arraySetSize(1);
positionRequest[5].arraySetSize(lbhNumOfPositionActuatorIds);
for(int i = 0; i < lbhNumOfPositionActuatorIds; ++i)
positionRequest[5][i].arraySetSize(1);
// prepare hardnessRequest
hardnessRequest.arraySetSize(6);
hardnessRequest[0] = std::string("hardnessActuators");
hardnessRequest[1] = std::string("ClearAll");
hardnessRequest[2] = std::string("time-separate");
hardnessRequest[3] = 0;
hardnessRequest[4].arraySetSize(1);
hardnessRequest[5].arraySetSize(lbhNumOfHardnessActuatorIds);
for(int i = 0; i < lbhNumOfHardnessActuatorIds; ++i)
hardnessRequest[5][i].arraySetSize(1);
// prepare usRequest
usRequest.arraySetSize(6);
usRequest[0] = std::string("usRequest");
usRequest[1] = std::string("Merge"); // doesn't work with "ClearAll"
usRequest[2] = std::string("time-separate");
usRequest[3] = 0;
usRequest[4].arraySetSize(1);
usRequest[5].arraySetSize(1);
usRequest[5][0].arraySetSize(1);
// prepare ledRequest
ledRequest.arraySetSize(3);
ledRequest[1] = std::string("ClearAll");
ledRequest[2].arraySetSize(1);
ledRequest[2][0].arraySetSize(2);
ledRequest[2][0][1] = 0;
// prepare sensor pointers
for(int i = 0; i < lbhNumOfSensorIds; ++i)
sensorPtrs[i] = (float*) memory->getDataPtr(sensorNames[i]);
resetUsMeasurements();
// initialize requested actuators
memset(requestedActuators, 0, sizeof(requestedActuators));
for(int i = faceLedRedLeft0DegActuator; i < chestBoardLedRedActuator; ++i)
requestedActuators[i] = -1.f;
// register "onPreProcess" and "onPostProcess" callbacks
theInstance = this;
proxy->getGenericProxy()->getModule()->atPreProcess(&onPreProcess);
proxy->getGenericProxy()->getModule()->atPostProcess(&onPostProcess);
fprintf(stderr, "libbhuman: Started!\n");
return; // success
}
catch(AL::ALError& e)
{
fprintf(stderr, "libbhuman: %s\n", e.toString().c_str());
}
}
}
close(); // error
}
/**
* The method reads all sensors. It also detects if the chest button was pressed
* for at least three seconds. In that case, it shuts down the robot.
*/
void readSensors()
{
// get new sensor values and copy them to the shared memory block
try
{
// copy sensor values into the shared memory block
int writingSensors = 0;
if(writingSensors == data->newestSensors)
++writingSensors;
if(writingSensors == data->readingSensors)
if(++writingSensors == data->newestSensors)
++writingSensors;
assert(writingSensors != data->newestSensors);
assert(writingSensors != data->readingSensors);
float* sensors = data->sensors[writingSensors];
for(int i = 0; i < lbhNumOfSensorIds; ++i)
sensors[i] = *sensorPtrs[i];
AL::ALValue value = memory->getData("GameCtrl/RoboCupGameControlData");
if(value.isBinary() && value.getSize() == sizeof(RoboCup::RoboCupGameControlData))
memcpy(&data->gameControlData[writingSensors], value, sizeof(RoboCup::RoboCupGameControlData));
data->newestSensors = writingSensors;
// detect shutdown request via chest-button
if(*sensorPtrs[chestButtonSensor] == 0.f)
startPressedTime = dcmTime;
else if(state != shuttingDown && startPressedTime && dcmTime - startPressedTime > 3000)
{
if(*sensorPtrs[rBumperRightSensor] != 0.f || *sensorPtrs[rBumperLeftSensor] != 0.f ||
*sensorPtrs[lBumperRightSensor] != 0.f || *sensorPtrs[lBumperLeftSensor] != 0.f)
(void) !system("( /home/nao/bin/bhumand stop && sudo shutdown -r now ) &");
else
(void) !system("( /home/nao/bin/bhumand stop && sudo shutdown -h now ) &");
state = preShuttingDown;
}
}
catch(AL::ALError& e)
{
fprintf(stderr, "libbhuman: %s\n", e.toString().c_str());
}
// raise the semaphore
if(sem != SEM_FAILED)
{
int sval;
if(sem_getvalue(sem, &sval) == 0)
{
if(sval < 1)
{
sem_post(sem);
frameDrops = 0;
}
else
{
if(frameDrops == 0)
fprintf(stderr, "libbhuman: dropped sensor data.\n");
++frameDrops;
}
}
}
}
/** The method sets all actuators. */
void setActuators()
{
// set all actuator values according to the values in the shared memory block
try
{
dcmTime = proxy->getTime(0);
data->readingActuators = data->newestActuators;
if(data->readingActuators == lastReadingActuators)
{
if(actuatorDrops == 0)
fprintf(stderr, "libbhuman: missed actuator request.\n");
++actuatorDrops;
}
else
actuatorDrops = 0;
lastReadingActuators = data->readingActuators;
float* readingActuators = data->actuators[data->readingActuators];
float* actuators = handleState(readingActuators);
if(state != standing)
{
if(frameDrops > 0 || state == shuttingDown)
setEyeLeds(actuators);
else
copyNonServos(readingActuators, actuators);
}
setBatteryLeds(actuators);
// set position actuators
positionRequest[4][0] = dcmTime; // 0 delay!
for(int i = 0; i < lbhNumOfPositionActuatorIds; ++i)
positionRequest[5][i][0] = actuators[i];
proxy->setAlias(positionRequest);
// set hardness actuators
bool requestedHardness = false;
for(int i = headYawHardnessActuator; i < headYawHardnessActuator + lbhNumOfHardnessActuatorIds; ++i)
if(actuators[i] != requestedActuators[i])
{
hardnessRequest[4][0] = dcmTime; // 0 delay!
for(int j = 0; j < lbhNumOfHardnessActuatorIds; ++j)
hardnessRequest[5][j][0] = requestedActuators[headYawHardnessActuator + j] = actuators[headYawHardnessActuator + j];
proxy->setAlias(hardnessRequest);
requestedHardness = true;
break;
}
// set us actuator
bool requestedUs = false;
if(requestedActuators[usActuator] != actuators[usActuator])
{
requestedActuators[usActuator] = actuators[usActuator];
if(actuators[usActuator] >= 0.f)
{
resetUsMeasurements();
usRequest[4][0] = dcmTime;
usRequest[5][0][0] = actuators[usActuator];
proxy->setAlias(usRequest);
requestedUs = true;
}
}
// set led
if(!requestedHardness && !requestedUs)
for(int i = 0; i < lbhNumOfLedActuatorIds; ++i)
{
int index = faceLedRedLeft0DegActuator + ledIndex;
if(++ledIndex == lbhNumOfLedActuatorIds)
ledIndex = 0;
if(actuators[index] != requestedActuators[index])
{
ledRequest[0] = std::string(actuatorNames[index]);
ledRequest[2][0][0] = requestedActuators[index] = actuators[index];
ledRequest[2][0][1] = dcmTime;
proxy->set(ledRequest);
break;
}
}
// set team info
// since this should very rarely, we don't use a proxy here
if(data->bhumanStartTime != lastBHumanStartTime)
{
for(int i = 0; i < lbhNumOfTeamInfoIds; ++i)
memory->insertData(teamInfoNames[i], data->teamInfo[i]);
lastBHumanStartTime = data->bhumanStartTime;
}
}
catch(AL::ALError& e)
{
fprintf(stderr, "libbhuman: %s\n", e.toString().c_str());
}
}
/**
* Handles the button interface.
* Resets the internal state when a new team number was set.
* Receives packets from the GameController.
* Initializes gameCtrlData when teamNumber and playerNumber are available.
*/
void handleInput()
{
unsigned now = (unsigned) proxy->getTime(0);
if(*teamNumberPtr != 0)
{ // new team number was set -> reset internal structure
teamNumber = *teamNumberPtr;
memory->insertData("GameCtrl/teamNumber", 0);
init();
}
if(receive())
{
if(!whenPacketWasReceived)
previousState = (uint8_t) -1; // force LED update on first packet received
whenPacketWasReceived = now;
publish();
}
if(teamNumber && *playerNumber)
{
// init gameCtrlData if invalid
if(gameCtrlData.teams[0].teamNumber != teamNumber &&
gameCtrlData.teams[1].teamNumber != teamNumber)
{
uint8_t teamColour = *defaultTeamColour == TEAM_RED ? 1 : 0;
gameCtrlData.teams[teamColour].teamNumber = (uint8_t) teamNumber;
gameCtrlData.teams[teamColour].teamColour = teamColour;
gameCtrlData.teams[1 - teamColour].teamColour = 1 - teamColour;
if(!gameCtrlData.playersPerTeam)
gameCtrlData.playersPerTeam = (uint8_t) *playerNumber; // we don't know better
publish();
}
TeamInfo& team = gameCtrlData.teams[gameCtrlData.teams[0].teamNumber == teamNumber ? 0 : 1];
if(*playerNumber <= gameCtrlData.playersPerTeam)
{
bool chestButtonPressed = *buttons[chest] != 0.f;
if(chestButtonPressed != previousChestButtonPressed && now - whenChestButtonStateChanged >= BUTTON_DELAY)
{
if(chestButtonPressed && whenChestButtonStateChanged) // ignore first press, e.g. for getting up
{
RobotInfo& player = team.players[*playerNumber - 1];
if(player.penalty == PENALTY_NONE)
{
player.penalty = PENALTY_MANUAL;
if(now - whenPacketWasReceived < GAMECONTROLLER_TIMEOUT &&
send(GAMECONTROLLER_RETURN_MSG_MAN_PENALISE))
whenPacketWasSent = now;
}
else
{
player.penalty = PENALTY_NONE;
gameCtrlData.state = STATE_PLAYING;
if(now - whenPacketWasReceived < GAMECONTROLLER_TIMEOUT &&
send(GAMECONTROLLER_RETURN_MSG_MAN_UNPENALISE))
whenPacketWasSent = now;
}
publish();
}
previousChestButtonPressed = chestButtonPressed;
whenChestButtonStateChanged = now;
}
if(gameCtrlData.state == STATE_INITIAL)
{
bool leftFootButtonPressed = *buttons[leftFootLeft] != 0.f || *buttons[leftFootRight] != 0.f;
if(leftFootButtonPressed != previousLeftFootButtonPressed && now - whenLeftFootButtonStateChanged >= BUTTON_DELAY)
{
if(leftFootButtonPressed)
{
team.teamColour ^= 1;
gameCtrlData.kickOffTeam ^= 1;
publish();
}
previousLeftFootButtonPressed = leftFootButtonPressed;
whenLeftFootButtonStateChanged = now;
}
bool rightFootButtonPressed = *buttons[rightFootLeft] != 0.f || *buttons[rightFootRight] != 0.f;
if(rightFootButtonPressed != previousRightFootButtonPressed && now - whenRightFootButtonStateChanged >= BUTTON_DELAY)
{
if(rightFootButtonPressed)
{
if(gameCtrlData.secondaryState == STATE2_NORMAL)
{
gameCtrlData.secondaryState = STATE2_PENALTYSHOOT;
gameCtrlData.kickOffTeam = team.teamColour;
}
else if(gameCtrlData.kickOffTeam == team.teamColour)
gameCtrlData.kickOffTeam ^= 1;
else
gameCtrlData.secondaryState = STATE2_NORMAL;
publish();
}
previousRightFootButtonPressed = rightFootButtonPressed;
whenRightFootButtonStateChanged = now;
}
}
}
else
fprintf(stderr, "Player number %d too big. Maximum number is %d.\n", *playerNumber, gameCtrlData.playersPerTeam);
}
}