OMNET++ LTE SIMULATION

OMNET++ LTE SIMULATION designed to increase the capacity and speed of mobile telephone networks. LTE (Long Term Evolution) is the high performance air interface for cellular mobile communication systems.

Requirements of LTE:

  • Simplified architecture, open interfaces.
  • Increased service provisioning this means more services at lower cost with better user experience.
  • Reduced cost per bit.
  • Flexibility of use of existing and new frequency bands.
  • Allow for reasonable terminal power consumption.

Technologies used in LTE:

  • SAE (System Architecture Evolution).
  • MIMO (Multi Input Multi Output).
  • OFDM (Orthogonal Frequency Division Multiplexing).

Advantages of LTE:

  • Achieve higher speeds in two ways.
  • Makes quick connections when changing cells and also it does not drop connections.
  • Transmit and receive data very quickly in operating side.
  • Bandwidth is high when compared with existing and also they transmit and receive multi input and multi output.
Architecture of LTE
Architecture of LTE

Research scope of LTE:

  • Channel/carrier aggregation.
  • Handover mechanisms.
  • To support higher speed mobility.
  • Interference management in heterogeneous cell overly.

 

Sample code for OMNET++ LTE SIMULATION:

int LteDeployer::deployRelays(double startAngle, int i, int num, double *xPos,
    double *yPos)
{
    double startingAngle = startAngle;
    *xPos = 0;
    *yPos = 0;
    unsigned int nRelays = num;
    int relayNodeId = 0;
    calculateNodePosition(nodeX_, nodeY_, i, nRelays, relayDistance_,
        startingAngle, xPos, yPos);
    EV << "Deployer: Relay " << i << " will be deployed at (x,y): " << *xPos
       << ", " << *yPos << endl;
    relayNodeId = createRelayAt(*xPos, *yPos);

    return relayNodeId;
}

cModule* LteDeployer::deployUes(double centerX, double centerY, int Ue,
    int totalNumOfUes, std::string mobType, int range, uint16_t masterId,
    double speed)
{
    double x = 0;
    double y = 0;
    calculateNodePosition(centerX, centerY, Ue, totalNumOfUes, range, 0, &x, &y);

    EV << NOW << " LteDeployer::deployUes deploying Ues: centerX " << centerX
       << " centerY " << centerY << " Ue " << Ue << " total "
       << totalNumOfUes << " x " << x << " y " << y << endl;

    cModule* p = createUeAt(x, y, mobType, centerX, centerY, masterId, speed);
    return p;
}
void LteDeployer::calculateNodePosition(double centerX, double centerY, int nTh,
    int totalNodes, int range, double startingAngle, double *xPos,
    double *yPos)
{
    if (totalNodes == 0)
        error("LteDeployer::calculateNodePosition: divide by 0");    
    double theta = -startingAngle * PI / 180;
    double thetaSpacing = (2 * PI) / totalNodes;
    // angle of n-th node
    theta += nTh * thetaSpacing;
    double x = centerX + (range * cos(theta));
    double y = centerY + (range * sin(theta));
    *xPos = (x < pgnMinX_) ? pgnMinX_ : (x > pgnMaxX_) ? pgnMaxX_ : x;
    *yPos = (y < pgnMinY_) ? pgnMinY_ : (y > pgnMaxY_) ? pgnMaxY_ : y;
    EV << NOW << " LteDeployer::calculateNodePosition: Computed node position "
       << *xPos << " , " << *yPos << endl;
    return;
}