A question about pwm pwmSetRange/pwmWrite

[yxdming]

Now i am developing a tool in my pi 3b+, that play a 16-bit WAV file with PWM, reference to the wiki https://github.com/RichardChambers/raspberrypi/wiki/Notes-on:-Pulse-Width-Modulation-(PWM)---Discussion, i read the data from the WAV file, and write it to 32 pins with api pwmWrite.

I have been confused for few days, that the parameter of range in pwmSetRange is 0-4096, but my wav file is 16-bit, and it's range is -32768~32767, can i write it directly with pwmWrite.
Do i need to convert the 16-bit value to 8-bit value.

Looking forword to receive your answers.

[RichardChambers]

The range for the Pulse Width Modulation (PWM) on the Raspberry Pi 3 is normally used for controlling the speed of devices such as motors such as fans. So the intent is to have a motor control from 0 which is off to a max value, 4096 in this case, that is top speed.

So to do what you are wanting to do, it would seem to me that each 16 bit value of the .wav file would need to go through two transformations. The first is to convert the signed 16 bit value, -32768 through +32767, to an unsigned 16 bit value with the same range, 0 to 65535. The next step would be to scale the 16 bit value from a range of 0 to 65535 to a range of 0 to 4096 by dividing the transformed 16 bit value by 16 or by doing a right shift of 4 bits.

However I have not tried this so I do not know what the hardware would look like or how it would sound. At a minimum I would expect it to sound tinny and 1980s 2D video game electronic.

I would like to hear a description of what your hardware looks like and how you are doing this.

Good luck.

[yxdming]

Thank you so much for your reply.
Now i had write a code to output the value by pwm, but i heard only a noise not a music.
It seam that the problem in the progress convert 16 bit value to 8 bit value.

#include <stdio.h>
#include <stdlib.h>
#include "wiringPi.h"
#include "utils.h"
#define PWM_PIN 26 
typedef char int16;
#define RANGE 256
typedef struct WavHeader_
{
    char        riff[4];        // RIFF
    int         chunkSize;      // Should be equal to: 4 + (8 + SubChunk1Size) + (8 + SubChunk2Size)
    char        format[4];      // WAVE
    char        subChunk1Id[4]; // Contains "fmt "
    int         subChunk1Size;  // 16 for PCM.
    short int   audioFormat;    // PCM = 1
    short int   channels;       // Mono = 1, Stereo = 2
    int         sampleRate;     // 8000, 16000, 44100, etc
    int         byteRate;       // sampleRate * channels * bitsPerSample / 8
    short int   blockAlign;     // channels * bitsPerSample / 8
    short int   bitsPerSample;  // 8 bits = 8, 16 bits = 16
    char        subChunk2Id[4]; // Contains "data"
    int         subChunk2Size;
}WavHeader;


void WavPrintHeader(WavHeader *pHeader);
void WavPlay(WavHeader *pHeader, int16 *aData, int iDataLength,int divisor, int range);

void WavPrintHeader(WavHeader *pHeader)
{
    printf("\nWAV header Information:\n");
    printf("RIFF            : %c%c%c%c\n", pHeader->riff[0], pHeader->riff[1], pHeader->riff[2], pHeader->riff[3]);
    printf("Chunk Size      : %d\n", pHeader->chunkSize);
    printf("Format          : %c%c%c%c\n", pHeader->format[0], pHeader->format[1], pHeader->format[2], pHeader->format[3]);
    printf("\nSub-Chunk 1 Information:\n");
    printf("Sub-Chunk 1 ID  : %c%c%c%c\n", pHeader->subChunk1Id[0], pHeader->subChunk1Id[1], pHeader->subChunk1Id[2], pHeader->subChunk1Id[3]);
    printf("Sub-Chunk Size  : %d\n", pHeader->subChunk1Size);
    printf("Audio Format    : %d (PCM = 1)\n", pHeader->audioFormat);
    printf("Channels        : %d (MONO = 1, STERIO = 2)\n", pHeader->channels);
    printf("Sampling Rate   : %d Hz\n", pHeader->sampleRate);
    printf("Byte Rate       : %d (%d)\n", pHeader->byteRate, (pHeader->sampleRate * pHeader->channels * pHeader->bitsPerSample) / 8);
    printf("block Alignment : %d (%d)\n", pHeader->blockAlign, (pHeader->channels * pHeader->bitsPerSample) / 8);
    printf("Bits Per Sample : %d bits\n", pHeader->bitsPerSample);
    printf("\nSub-Chunk 2 Information:\n");
    printf("Sub-Chunk 2 ID  : %c%c%c%c\n", pHeader->subChunk2Id[0], pHeader->subChunk2Id[1], pHeader->subChunk2Id[2], pHeader->subChunk2Id[3]);
    printf("Sub-Chunk Size  : %d\n", pHeader->subChunk2Size);

    printf("\nGeneral Information:\n");
    printf("Audio Length    : %d seconds\n\n", pHeader->subChunk2Size / pHeader->byteRate);
}

void WavPlay(WavHeader *pHeader, int16 *aData, int iDataLength,int divisor, int range)
{
    int16 *pDataEnd = aData + iDataLength;

    // Initialize the library.
    if (wiringPiSetup() != 0)
    {
        printf("Error initializing wiringPi library.");
        return;
    }
    pinMode(PWM_PIN, PWM_OUTPUT);
    pwmSetMode(PWM_MODE_BAL);
    pwmSetRange(range);
    pwmSetClock(divisor);


    // Loop through the data and modulate accordingly.
    short *p = (short *)aData;
    while (aData< pDataEnd)
    {
        char value = 0;
        switch (pHeader->bitsPerSample)
        {
               case 16:
               {
                     char netByteValue = *(aData+1);
                     value = ((short int)(nextByteValue) << 8) + (*aData)
               }
               case 8:
               {
                    value = *aData;
                    break;
               }
         }
        pwmWrite(PWM_PIN,value); 
        if(pHeader->channels>1)
        {   // if has 2 channels, skip right channel, because i just have only one speaker.
            p = p+2;
            aData = aData+4;
        }
        else
        {
            p++;
            aData=aData+2;     
        }

        delayMicroseconds( 1000000/ pHeader->sampleRate);
    }
    pwmWrite(PWM_PIN, 0);
    pinMode(PWM_PIN, INPUT);
}


int main(int iArgumentCount,char *aArgumens[])
{
    FILE *pWavFile;
    WavHeader oWavHeader;

    int16 *aData;       // Holds the PCM WAV data read from the file.
    int iDataLength;
    //Ensure we have enough arguments to start.
    if(iArgumentCount < 2) { printf("\nYou forgot a wave input file name...\n"); exit(1); }

    // Open file wave file, read the header first then data later.
    if( (pWavFile = fopen(aArgumens[1], "r")) == 0) { printf("Ops, unable to open the given wave file!\n"); exit(2); }

    fread(&oWavHeader, sizeof(WavHeader), 1, pWavFile);
    WavPrintHeader(&oWavHeader);

    printf("begin to read data from file;\n");

    // Read the data.
    aData = malloc(oWavHeader.subChunk2Size);
    iDataLength = (int)fread(aData, 1, oWavHeader.subChunk2Size, pWavFile);

    printf("\nRead data length from file: %d (%d)\n", iDataLength, oWavHeader.subChunk2Size);
    if ( iArgumentCount > 3 )
    {    
         int range = atoi(aArgumens[3]);
         int divisor = atoi(aArgumens[2]);
         WavPlay(&oWavHeader, aData, iDataLength, divisor, range);
    }
    // Clean up and return.
    fclose(pWavFile);
    free(aData);

    return 0;
}

[RichardChambers]

My impression is that what you are wanting to do is going to be difficult with a Raspberry Pi.

The first consideration is that Raspbian is a Linux distro which means that your process is not the only process running. Because there are other processes sharing the CPU you probably are not going to have dependable timings.

I found documentation on the .wav file format at http://soundfile.sapp.org/doc/WaveFormat/ though I am not sure if this really matches your particular wave file. See also https://stackoverflow.com/questions/19991405/how-can-i-detect-whether-a-wav-file-has-a-44-or-46-byte-header as well as https://stackoverflow.com/questions/13660777/c-reading-the-data-part-of-a-wav-file

Comparing the header to your struct, one question is whether the endian (how bits and bytes that form the data is sequenced) and whether the members of your struct are on the proper alignment to the data members of the header. Typically with something like this header you need to specify the exact data types (indicating number of bytes) and the members are packed on byte boundaries.

Music is basically a series of tones that are played with each tone being played for some specified amount of time. In your case you are playing a particular tone by vibrating a speaker cone at a particular frequency, using PWM to program the output pin to turn on and off at a particular rate for a given time then changing the PWM parameters of the output pin to change the frequency and then let that run for a given time.

I do not know if you have done the following prototype program to first try out the method you are using. However what I suggest is that you first write a program that will do a scale of tones from low to high and then high to low, repeated several times in order to test that your approach will actually create something approaching music.

Take a look at the following. Some of these are Arduino related but the material should still help. Arduino may be a better platform because it is a bare microcontroller and doesn't have the CPU timesharing that the Raspberry Pi with Raspbian has.

https://stackoverflow.com/questions/33853714/generating-a-tone-with-pwm-signal-to-a-speaker-on-a-pic32-microcontroller

https://www.engineersgarage.com/embedded/pic-microcontroller-projects/How-to-Generate-Sound-Using-PWM-With-PIC-Microcontroller

https://electronics.stackexchange.com/questions/239442/audio-using-pwm-what-is-the-principle-behind-it

https://www.deviceplus.com/how-tos/arduino-guide/entry019/

https://www.deviceplus.com/how-tos/arduino-guide/entry020/

https://www.instructables.com/id/Arduino-Basics-Making-Sound/

[yxdming]

Thank you so much! @RichardChambers .
When i use the program mentioned above in my pi 3b+. it can pay a 8-bit and 2 channels .wav music well. It is really music, not a noise. But when i play a 16-bit music, i got a noise. That's my progress. I will do more experiments as your suggestion.

[fatmingwang]

How about convert 16 bit data to 8 bit,this would be easier.
case 16: { char netByteValue = *(aData+1); unsigned short l_usValue = ((short int)(nextByteValue) << 8) + (*aData) value = UnsignedShortToUnsignedChar(l_usValue); }
unsigned char UnsignedShortToUnsignedChar(unsigned short e_usValue) { float l_fScale = e_usValue/65536.f; return (unsigned char)(l_fScale*255); }