LTE as an all IP architecture

LTE (Long term evolution) is the latest standard for mobile network technology, specifications are available in the 3GPP standard. LTE is also an all IP architecture supported by major vendors like AT&T, T-Mobile, Verizon and more. Best part of the technology is that it also provides the inter-working for non 3GPP systems like 3GPP2 (CDMA)and WiFi, WiMax etc. Non 3GPP system are divided into trusted and non-trusted, based on that architecture will change. It is also called as 4G technology in mobile network industry. 3GPP release 8 and above specification talks about adapting to LTE. LTE started as a technology which support packet data network, later to support voice over the packet data network.
What is more fascinate about LTE?
- All IP Architecture
- Signaling and Data path separated out using MME and S-GW where PS Core and CS core is merged into single core network
- High data rates
- Decreased latency
- Better spectrum efficiency
- Scalable bandwidth
- Support for paired and unpaired spectrum
- Inter-working with 3GPP and non 3GPP systems

Below is reference architecture and inter-working with existing 3GPP systems (Reference 3GPP specifications: 3gpp.org)

Concerns operators shall have could be
- Cost effective evolution of IMS and LTE
- Spectrum efficiency
- Service quality
- Coverage performance
- CAPEX and OPEX

Target would be to address these concerns. However lot depends on the approaches that would be considered by operators for the architecture. Most of them probably consider overlay architecture and gradual transition.

If you have any questions please try to post the same. I would try to answer the same.

Your Ad Here

Embedded Engineer: integer promotion rule - Programming in C and C++

One thing Embedded engineer should know is integer promotion rule. Declaring the variable in correct makes life lot more easy in debugging and it should a good practice of programming as well.
Below example is for integer promotion rule.

unsigned int uIntVar = 2;
  int intVar = -10;
    (uIntVar+intVar > 2) ? puts("> 2") : puts("<= 2");

Answer is >2. Expression having the signed and unsigned integers, signed integer becomes a large number and evaluates to positive number in above example.
However it becomes a negative number if
int result = intVar  + uIntVar;  Or type cast the result to int

Now let me post questions.
1) What is the return value if invoke malloc with size zero?
2) How do you write a 1's compliment for given number?

Answer for the first question is strange where second one tests whether you are a embedded engineer.

Interrupt Service Routine - ISR

Thumb rule for ISR is : It should be short and sweet.
1) Will not have any parameters or return values.
2) Should avoid performance hit operations like floating point operations.
3) Should not contain non-entrant functions.
If somebody gives you an example code to identify the problems in the ISR routine, these points should be considered to identify the faults.

C and C++ Programming - Best practice for Singleton pattern

Best practice for the singleton class to avoid the mis-usage.

1) Make the constructor as private.
2) Hide the copy constructor
3) Hide the = operator
4) Return the reference of the instance instead of pointer in the instance() method

Below is the example:

class Singleton
{

public:

    /*!
     * @brief Method to retrieve the object (singleton pattern)
     */
    static Singleton & instance();

    /*!
     * @brief Destructor
     */
    virtual ~Singleton();

protected:

private:
    /*!
     * @brief constructor, which can only be accessed by instance() method
     */
    Singleton();

    /**
     * @brief Hide the copy constructor.
     */
    Singleton(const Singleton & p_singleton);

    /**
     * @brief Hide the operator '='.
     */
    Singleton & operator =(const Singleton & p_rhs);

    /*!
     * @brief singleton, can only be accessed by instance()
     */
    static Singleton* c_pInstance;
};

C and C++ Programming - How to do you decide whether to have a variable as class member or static class member

Simple but people often do mistakes!
I have seen people writing code, where some of variables does not fit to be class member still used as class members. If a variable not required during the life of  class instance then it is not required to have it as class member. Remember static class members are per class not per instance.

C and C++ Programming - Constant usage in C/C++

Constant:

Constant means read-only. Answer is not complete but still good. Constant can be declared in various way for various needs.

const int a; //Constant (non-modifiable) integer
int const a; //Constant (non-modifiable) integer
const int *a; //pointer to a Constant (non-modifiable) integer
int * const a; //Constant (non-modifiable) pointer to a integer
int const * a const; //Constant (non-modifiable) pointer to constant integer

You can write a program without using a constant keyword which would work without any problem. But writing a program using constant is good practice and dictates user on how to use them based on its behavior.

Post GSM/GPRS(BTS) Question and Get Answers

You can post question to me on GSM/GPRS/LTE, even C and C++ questions, I will try my best answer

C and C++ Programming - When and where to use volatile keyword

Main usage of volatile seen in embedded space. Practical use is seen in
1) Memory mapped peripheral registers 2) Global variables modified by ISR routine 3) Global variables modified by multi-threaded environment. In these scenarios values of these variable can change unexpectedly.

Watch out for the below behaviours and first thing to look for is assessing  for the need for volatile variables.
 Code stops working when
1) Multithreaded environment but works in single process/threads
2) Enable optimization
3) Enable Interrupts

Volatile qualifier will be used when the variable is declared, which tells the compiler that value of the variable can change without any action taken by code.

volatile int myVolatile;
int volatile myVolatile;
What is the difference between two?
If you do not know the answer let me know.

int * volatile myVolatile;
This means volatile pointer to non volatile variable.
int volatile * volatile myVolatile;
Volatile pointer to Volatile variable.