Large array programming in PIC

Question

I would like to play musical notes using a PIC microcontroller 16F887. I want to store the frequency of 109 musical notes in an array of type float, then call the needed frequency to play.

The problem is that when I have created the array as follows using mikroC, the compiler says: not enough RAM:

float notes_freq[109] = 
{
16.35,17.32,18.35,19.45,20.60,21.83,23.12,24.50,25.96,27.50,29.14,30.87,32.70,34.65,36.71,38.89,                  
41.20,43.65,46.25,49.00,51.91,55.00,58.27,61.74,65.41,69.30,73.42,77.78,82.41,87.31,92.50,98.00,                  
103.83,110.00,116.54,123.47,130.81,138.59,146.83,155.56,164.81,174.61,185.00,196.00,207.65,220.00,                  
233.08,246.94,261.63,277.18,293.66,311.13,329.63,349.23,369.99,392.00,415.30,440.00,466.16,493.88,                   
523.25,554.37,587.33,622.25,659.25,698.46,739.99,783.99,830.61,880.00,932.33,987.77,1046.50,1108.73,                 
1174.66,1244.51,1318.51,1396.91,1479.98,1567.98,1661.22,1760.00,1864.66,1975.53,2093.00,2217.46,2349.32,            
2489.02,2637.02,2793.83,2959.96,3135.96,3322.44,3520.00,3729.31,3951.07,4186.01,4434.92,4698.63,4978.03,5274.04,5587.65,5919.91,6271.93,6644.8
8,7040.00,7458.62,7902.13
};

I understand that the PIC RAM is full. How can I overcome this issue? Can I store the array in EEPROM? If so, how can I do it at compile time?

Answer 1

You need to do two things:

1. Make the array constant with the modifier const, as you only need to read the values.

2. Add the compiler specific keyword code to locate the array in (flash) ROM.

const float code notes_freq[] = { 16.35, /* ... */ };

Note: You don't need to specify the size of the array, which is error prone as you will count the values manually. Let the compiler count them.

Answer 2

Even if you say so, you actually don't want or need to store 109 floats.

First of all, each octave is 12 notes only and next and previous octaves are gotten by doubling or halving the frequencies.

And they don't need to be floats either, just pick 12 highest notes you want to support and use the frequencies as integers. If you want higher than 1 Hz precision then use the octave that scales between 32768 and 65535 Hz and shift it down to any octave you want as there will likely be more precision you can ever use to generate a tone. Depends on how you generate the tone though, with frequency divider or DDS.

If you want to avoid math with frequencies then it might be better to not store the frequencies at all but the precalculated values you actually need to produce those frequencies.

If you don't use floats you have more room storing intermediate notes for sliding and finetuning between the 12 notes of an octave.

Answer 3

This is just answering a comment from the OP.

Justme rightfully wrote:

each octave is 12 notes only and next and previous octaves are gotten by doubling or halving the frequencies.

learn design replied:

Can explaine it more, or give me a reference or example code to do that, because I did not grasp the point.

If you format your array with 12 frequencies per source line, it should look like this:

float notes_freq[109] = {
    16.35, 17.32, 18.35, 19.45, 20.60, 21.83, 23.12, 24.50, ...
    32.70, 34.65, 36.71, 38.89, 41.20, 43.65, 46.25, 49.00, ...
    65.41, 69.30, 73.42, 77.78, 82.41, 87.31, 92.50, 98.00, ...
    ...
};

Each row of 12 notes is called an “octave”. Note that from one octave to the next, the frequencies are multiplied by two. Then, you do not need to store the whole array: you can store just the first octave, and then compute any other frequency by multiplying the appropriate note (from the first octave) by a suitable power of two.

Example code:

float notes_freq[12] = { 16.351598, 17.323914, ... };

float note_frequency(int note)
{
    int multiplier = 1;
    while (note >= 12) {
        note -= 12;
        multiplier <<= 1;
    }
    return notes_freq[note] * multiplier;
}

You may want to add some bound checks.

Answer 4

I think this answer actually offers the best solution to your specific problem.

However, for the more general case, you can often save a lot of space and a lot of CPU cycles in microcontroller programming by completely bypassing the need for float variables and instead storing your values in Q/Fixed Point format.

The long and short of it is that you take your fractional number and store it in an integer, left shifted by some amount (the amount is a trade off between space needed and precision). You then do your calculations with these integer values (you need to adjust the shift for certain operations) which is far faster than with floats. Then when you want your result, you right shift your integer right back out.

For reasonably low precisions, like yours, this saves on both the RAM requirements and CPU cycles. If you needed higher precision, the RAM requirements have less of a saving but the CPU saving of doing integer operations is almost always worth it on an MCU without an FPU even if you end up using huge integers.