Digital Signal Recognition using C and C++

In this article I explain the details behind signal recognition and the implementation of these applications in C and C++ on Linux. The DSP articles presented on this website are not intended to be comprehensive in there explanation of DSP. The information found on this site is intended to be a brief introduction to processing a digital signal and things to consider. My article on signal detection was not written to explain how to recognize a signal. The title could have easily been mistaken for recognition. A statistical change in a signal is recognized and acted upon. When the change in statistics is detected we can collect the data needed to recognize the signal. Some recognition systems are more complex than others so, the means by which you recognize a particular signal will be determined by the requirements of your application. I would also like to say that I was motivated to write this program after reading an CUJ article written by Joey Rogers some years ago. Before I go into signal recognition I go over some C++ pointer techniques used in the code.

C and C++ Pointers

Pointers are very important to understand, even after years of development you can still make a mistake if your not careful. After programming in C++ for some years I made the mistake below:

char arr[] = “ This is a string of characters “;

puts(arr); // This is equivalent to printing &arr

puts(&arr); // This is equal to printing arr

// ( arr == &arr ) is a true expression because, arr is an array not a pointer

This makes some sense, but leaves the variable arr not very well defined. Is arr a pointer also, and if it is how can arr equal &arr if the address operator takes its address. arr must be something else besides a pointer to a string. It's also an array, but this still does not explain arr == &arr because &arr[0] equals arr and &arr equals &arr[0], but *arr is clearly the first byte of the string which is arr[0], and we can't take arr's address as &arr. So if &arr equals &arr[0] then arr should equal arr[0], but it does not, it's also equal to &arr. This is not well defined behavior and I would even say unacceptable

Although the code above is accepted by the C++ complier, it's bad practice and appears to be a logical error in the specification.

More Pointers

I think it's appropiate to go over some more advanced pointer arithmatic since I used so much of it in the next program. This program was writtten before I started using the STL exstensively. We can just cover some details so things won't look too confusing to some people.

This is a dynamically allocated array of pointers to pointer-to-pointers that I use as an array of matrices after being initialized:

double ***weights;

weights = new double**[network_params::MAX_LAYERS ];

for(i=0; i<network_params::MAX_LAYERS; i++)

weights[i] = new double*[network_params::MAX_ROWS];

for(i=0; i<network_params::MAX_LAYERS; i++)

for(j=0; j<network_params::MAX_ROWS; j++)

weights[i][j]=new double[network_params::MAX_COLS];

This gives a convenient interface to the following C++ class operators:

operator double***() ;

operator double**() ;

operator double*() ;

operator double() ;

double** operator[](int index) ;

Implemeted to give the C++ class objects of type weights the ability to handle the 3-diminsional index [x][y][z] is operator [], which returns weights[index] which is a pointer to a pointer. By using weights[x][y][z] we get ***weights which is the value at that address location:

NN_Weights::operator double***() { return weights; }
NN_Weights::operator double**() { return *weights; }
NN_Weights::operator double*() { return **weights; }
NN_Weights::operator double() { return ***weights; }
double** NN_Weights::operator[] (int index) { return weights[index]; }

We can initialize the array of matrices to a range of random values like this :

double val;
/* initialize random seed: */
srand ( time(NULL) );

for(int i=0; i<network_params::MAX_LAYERS; i++)
          for(int j=0; j<network_params::MAX_ROWS; j++)
                     for(int k=0; k<network_params::MAX_COLS; k++)    {
                              val = 0.1*(rand() % 255 + 1); /* generate secret number: */
                              weights[i][j][k]=val;
                     }

That's it for the pointers techniques. The source code above assigns random values to the matrix weights. These random values assigned to the weights are used as a starting point for creating templates used to recognize one or more signals. This is a complex system. There are books that explain in more detail the techniques used in this atricle. Some related books will be listed on this site. A signal pattern is presented to the weight values through another matrix and processed. The signal to be recognized is stored in the pattern matrix. The weights matrix is searched for each value in the pattern for a weight value that resembles the pattern value the most. In other words the difference is taken and compared for each value in the pattern to determine the weight value that is the closest match to a specific pattern value, this weight is called the winning node. Once this is determined all of the weights in a predetermined area around the wining node called the winning node's neighborhood are brought closer to the pattern value by another predetermined value called the learning rate. This is repeated for each node in the pattern a predetermined number of times called the number of iterations. The mathamatics that describes this is complex, but not hard to understand at a high level. The source code below is not text book, it finds the winning node in the weights matrix. Notice how the difference taken is something llike the standard deviations. This technique is also used to get the Kohonen node value from the weighted values explained later.

The function above finds the winning node in the weights matrix. This function is called on each iteration of the training of the network. There is another function that decrement the winning nodes neighborhood on each iteration, it is also common to decrement the lerning rate also, but I did not decrement the learning rate in this program. The learning rate was kept small and I iterated differently over the network as you can tell from the modulus operator used when searching for the winning node. Also the number of itrations I used was kept pretty high. This is the actual training phase of the network. Given a signal it learns about the pattern of the signal through generalization. A number of different strategies can be employed to compensate for the limitations encountered while attempting to recognize a signal the network was trained to detect. Time shifts of the signal can cause the system to not recognize a pattern that it was actually trained to detect. Shifting the signal across the network can increase the probability of the system finding a match for the incoming signal. After the winning node is found it is necessary to update the network using the learning rate. The function that does this is listed next:

Home