radio_nonoise.pc

simulator for ad hoc

                }

                GLOMO_MsgSetInstanceId(msg, radioNum);
                GLOMO_MsgSetEvent(msg, MSG_RADIO_FromChannelEnd);
                GLOMO_MsgSend(node, msg, txDuration);

                nonoise->numSignals++;
                assert(nonoise->numSignals >= 1);
            }
            else {
                assert(nonoise->mode != RADIO_IDLE);

                if (propInfo->rxPower_mW >= (nonoise->rxMsgPower_mW *
                                             nonoise->radioRxSnrThreshold))
                {
                    RadioNonoiseUnlockPacket(nonoise);
                    RadioNonoiseLockPacket(nonoise, msg);

                    if (nonoise->mode == RADIO_RECEIVING) {
                        nonoise->previousMode = nonoise->mode;
                        nonoise->mode = RADIO_RECEIVING;

                        RadioNonoiseReportExtendedStatusToMac(
                            node,
                            radioNum,
                            RADIO_RECEIVING,
                            txDuration,
                            msg);
                    }                        
                    else {
                        assert(nonoise->mode == RADIO_TRANSMITTING);
                    }

                    GLOMO_MsgSetInstanceId(msg, radioNum);
                    GLOMO_MsgSetEvent(msg, MSG_RADIO_FromChannelEnd);
                    GLOMO_MsgSend(node, msg, txDuration);

                    nonoise->numSignals++;
                    assert(nonoise->numSignals >= 1);
                }
                else if (nonoise->rxMsgPower_mW < (propInfo->rxPower_mW *
                                              nonoise->radioRxSnrThreshold))
                {
                    if (nonoise->rxMsg->error == FALSE) {
                        nonoise->stats.totalCollisions++;
                    }

                    if (nonoise->rxStartTime + nonoise->rxMsgTxDuration <
                        simclock() + txDuration)
                    {
                        RadioNonoiseUnlockPacket(nonoise);
                        RadioNonoiseLockPacket(nonoise, msg);

                        if (nonoise->mode == RADIO_RECEIVING) {
                            nonoise->previousMode = nonoise->mode;
                            nonoise->mode = RADIO_RECEIVING;

                            RadioNonoiseReportExtendedStatusToMac(
                                node,
                                radioNum,
                                RADIO_RECEIVING,
                                txDuration,
                                msg);
                        }
                        else {
                            assert(nonoise->mode == RADIO_TRANSMITTING);
                        }

                        GLOMO_MsgSetInstanceId(msg, radioNum);
                        GLOMO_MsgSetEvent(msg, MSG_RADIO_FromChannelEnd);
                        GLOMO_MsgSend(node, msg, txDuration);

                        nonoise->numSignals++;
                        assert(nonoise->numSignals >= 1);
                    }
                    else {
                        GLOMO_MsgFree(node, msg);
                    }

                    nonoise->rxMsg->error = TRUE;
                }
                else {
                    GLOMO_MsgFree(node, msg);
                }
            }

            //
            // Statistics
            //
            if (propInfo->rxPower_mW >= thisRadio->rxThreshold_mW) {
                nonoise->stats.totalRxSignalsAboveRX++;
            }

            break;
        }

        //
        // Radio signal end
        //
        case MSG_RADIO_FromChannelEnd: {
            PropInfo *propInfo = (PropInfo *)GLOMO_MsgReturnInfo(msg);

            if (nonoise->rxMsg == msg) {
                assert(nonoise->mode != RADIO_IDLE);
                assert(nonoise->rxStartTime + nonoise->rxMsgTxDuration == simclock());

                RadioNonoiseUnlockPacket(nonoise);

                if (nonoise->mode == RADIO_RECEIVING) {
                    nonoise->previousMode = nonoise->mode;
                    nonoise->mode = RADIO_IDLE;

                    if (msg->error != TRUE) {
                        GLOMO_MacReceivePacketFromRadio(
                            node, 
                            node->radioData[radioNum]->macInterfaceIndex, 
                            msg);

                        nonoise->stats.totalRxSignalsToMac++;
                    }
                    else {
                        RadioNonoiseReportStatusToMac(
                            node,
                            radioNum,
                            RADIO_IDLE);
                        GLOMO_MsgFree(node, msg);
                    }
                }
                else {
                    assert(nonoise->mode == RADIO_TRANSMITTING);
                    assert(msg->error == TRUE);

                    GLOMO_MsgFree(node, msg);
                }
            }
            else {
                GLOMO_MsgFree(node, msg);
            }

            //
            // Decrement the number of packets being sensed.
            //
            nonoise->numSignals--;
            assert(nonoise->numSignals >= 0);

            break;
        }

        case MSG_RADIO_StartPropagation: {
            PropInfo *propInfo = (PropInfo *)GLOMO_MsgReturnInfo(msg);

            assert(nonoise->mode == RADIO_TRANSMITTING);

            GLOMO_MsgSetInstanceId(msg, radioNum);
            GLOMO_MsgSetLayer(msg, GLOMO_RADIO_LAYER, 0);
            GLOMO_MsgSetEvent(msg, MSG_RADIO_SwitchToIdle);
            GLOMO_MsgSend(node, msg, propInfo->txDuration);

            GLOMO_PropBroadcast(node->partitionData, msg);
            break;
        }


        case MSG_RADIO_SwitchToIdle: {
            assert(nonoise->mode == RADIO_TRANSMITTING);

            if (nonoise->rxMsg == NULL) {
                nonoise->previousMode = nonoise->mode;
                nonoise->mode = RADIO_IDLE;
                RadioNonoiseReportStatusToMac(node, radioNum, RADIO_IDLE);
            }
            else {
                nonoise->previousMode = nonoise->mode;
                nonoise->mode = RADIO_RECEIVING;
                RadioNonoiseReportExtendedStatusToMac(
                    node,
                    radioNum,
                    RADIO_RECEIVING,
                    (nonoise->rxStartTime + nonoise->rxMsgTxDuration - simclock()),
                    nonoise->rxMsg);
            }

            GLOMO_MsgFree(node, msg);

            break;
        }

        /*
         * Mac Layer asking radio to check channel status
         * (Carrier Sensing)
         */
        case MSG_RADIO_CheckChannelStatus: {
            GLOMO_MsgFree(node, msg);

            RadioNonoiseReportStatusToMac(node, radioNum, nonoise->mode);
            break;
        }

        default: {
            char clockStr[GLOMO_MAX_STRING_LENGTH];
            ctoa(simclock(), clockStr);
            printf("Time %s: Node %u received message of unknown type %d.\n",
                    clockStr, node->nodeAddr, msg->eventType);
            assert(FALSE);
        }
    }
}

void RadioNonoiseFinalize(GlomoNode *node, const int radioNum) {
    GlomoRadio* thisRadio = node->radioData[radioNum];
    GlomoRadioNonoise* nonoise = thisRadio->radioVar;
    char buf[100];

    if (thisRadio->radioStats == FALSE) {
        return;
    }

    assert(thisRadio->radioStats == TRUE);

    sprintf(buf, "Signals transmitted: %d",
            nonoise->stats.totalTxSignals);
    GLOMO_PrintStat(node, "RadioNonoise", buf);

    sprintf(buf, "Signals arrived with power above RX sensitivity: %d",
            nonoise->stats.totalRxSignalsAboveCS);
    GLOMO_PrintStat(node, "RadioNonoise", buf);

    sprintf(buf, "Signals arrived with power above RX threshold: %d",
            nonoise->stats.totalRxSignalsAboveRX);
    GLOMO_PrintStat(node, "RadioNonoise", buf);

    sprintf(buf, "Signals received and forwarded to MAC: %d",
            nonoise->stats.totalRxSignalsToMac);
    GLOMO_PrintStat(node, "RadioNonoise", buf);

    sprintf(buf, "Collisions: %d",
            nonoise->stats.totalCollisions);
    GLOMO_PrintStat(node, "RadioNonoise", buf);

    nonoise->stats.energyConsumed
        += BATTERY_RX_POWER * (simclock() - nonoise->stats.turnOnTime);

    sprintf(buf, "Energy consumption (in mWhr): %.3f",
            nonoise->stats.energyConsumed / 3600.0);
    GLOMO_PrintStat(node, "RadioNonoise", buf);
}

void RadioNonoiseLockPacket(GlomoRadioNonoise *nonoise, Message *msg) {
    PropInfo *propInfo = (PropInfo *)GLOMO_MsgReturnInfo(msg);

    nonoise->rxMsg = msg;
    nonoise->rxMsgPower_mW = propInfo->rxPower_mW;
    nonoise->rxMsgTxDuration = propInfo->txDuration;
    nonoise->rxStartTime = simclock();
}

void RadioNonoiseUnlockPacket(GlomoRadioNonoise *nonoise) {
    nonoise->rxMsg = NULL;
    nonoise->rxMsgPower_mW = 0.0;
    nonoise->rxMsgTxDuration = 0;
    nonoise->rxStartTime = 0;
}

void RadioNonoiseGuiDrawLine(NODE_ADDR sourceAddr, NODE_ADDR destAddr, BOOL success) {
    JGUI_COLOR failTxColor, successTxColor;
    char simTime[50];
                    
    ctoa(simclock(), simTime);
    failTxColor = JGUI_RED;
    successTxColor = JGUI_GREEN;

    JGUI_EraseLink(sourceAddr, destAddr, simTime);

    if (success == TRUE) {
        JGUI_DrawLine(sourceAddr, destAddr, simTime, successTxColor);
    }
    else {
        JGUI_DrawLine(sourceAddr, destAddr, simTime, failTxColor);
    }
}