sam_arduino.h

Go to the documentation of this file.

 
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include "sam_arduino_out.h"
#include "SamData.h"
 
 
class SAM {
 
    public:
        enum Voice {
            Elf,
            LittleRobot,
            StuffyGuy,
            LittleOldLaydy,
            ExtraTerrestrial,
            Sam,      
        };
 
        SAM(){
            SAM_LOG("SAM");
            setOutput(new SAMPrintStream(Serial));
            setVoice(Sam);
        }
 
        SAM(sam_callback cb){
            SAM_LOG("SAM callback");
            setOutput(new SAMOutputCallback(cb));
            setVoice(Sam);
        }
 
        SAM(Print &stream, bool as_text=false){
            SAM_LOG("SAM Stream");
            if (as_text){
                setOutput(new SAMPrintStream(stream));
            } else {
                setOutput(new SAMOutputStream(stream));
            }
            setVoice(Sam);
        }
 
        SAM(SAMOutputBase &out){
            SAM_LOG("SAM SAMOutputBase");
            setOutput(&out);
            setVoice(Sam);
        }
 
        SAM(SAMOutputBase *out){
            SAM_LOG("SAM SAMOutputBase");
            setOutput(out);
            setVoice(Sam);
        }
 
#if defined(ESP32) && LEGACY_ESP_I2S
        SAM(i2s_port_t i2s_num){
            SAM_LOG("SAM i2s");
            setOutput(new SAMOutputI2S(i2s_num));
            setVoice(Sam);
        }
#endif
 
        ~SAM(){
            SAM_LOG("~SAM");
            end();
        }
 
        void setPitch(uint8_t pitch) {
            SetPitch(pitch);
        }
 
        void setSpeed(uint8_t speed) {
            SetSpeed(speed);
        }
 
        void setMouth(uint8_t mouth) {
            SetMouth(mouth);
        }
 
        void setThroat(uint8_t th) {
            SetThroat(th);
        }
 
        void setSingMode(bool sing){
            EnableSingmode(sing);
        }
 
        void setVoice(Voice voice) {
            SAM_LOG("setVoice: %d", voice);
            switch(voice) {
                case Elf:
                    setSpeed(72);
                    setPitch(64);
                    setThroat(110);
                    setMouth(160);
                    break;
                case LittleRobot:
                    setSpeed(92);
                    setPitch(60);
                    setThroat(190);
                    setMouth(190);
                    break;
                case StuffyGuy:
                    setSpeed(82);
                    setPitch(72);
                    setThroat(110);
                    setMouth(105);
                    break;
                case LittleOldLaydy:
                    setSpeed(82);
                    setPitch(32);
                    setThroat(145);
                    setMouth(145);
                    break;
                case ExtraTerrestrial:
                    setSpeed(100);
                    setPitch(64);
                    setThroat(150);
                    setMouth(200);
                    break;
                case Sam:
                    setSpeed(72);
                    setPitch(64);
                    setThroat(128);
                    setMouth(128);
                    break;
            }
        };
 
        bool say(const char* text){
            SAM_LOG("say: %s",text);
            return textToSpeach(text, false);
        }
 
        bool sayPhone(const char* text){
            SAM_LOG("sayPhone: %s",text);
            return textToSpeach(text, true);
        }
 
        SAMOutputBase* getOutput() {
            return arduino_output;
        }
 
        void end() {
            SAM_LOG("end");
            if(arduino_output!=nullptr && arduino_output->isOpen()){
                arduino_output->close();
            }
        }
 
        void setOutputChannels(int channel_count){
            SAM_LOG("setOutputChannels: %d", channel_count);
            if (channel_count > 0){
                // fixed channels are not enforced
                this->channel_count = channel_count;
                arduino_output->setChannels(channel_count);
            } else {
                SAM_LOG("Channels is not supported for this output type");
            }
        }
 
 
        static int sampleRate() {
            return SAMOutputBase::sampleRate();
        }
 
        int bitsPerSample() {
            return bits_per_sample;
        }
 
        int channels() {
            return channel_count;
        }
 
        void setVolume(uint8_t volPercent){
            volume = static_cast<float>(volPercent) / 100.0;
            if (volPercent> 100) volume = 1.0;
        }
 
    protected:
        SAMOutputBase *arduino_output=nullptr;
        int bits_per_sample = 16;
        int channel_count = 1;
        float volume = 1.0;
 
        static void outputByteCallback(void *cbdata, unsigned char b) {
            SAM_LOG("outputByteCallback: %d", b);
 
            SAM *sam = static_cast<SAM*>(cbdata);
            sam->write(b);
        }
 
        void setOutput(SAMOutputBase *out){
            SAM_LOG("setOutput");
            arduino_output = out;    
 
            // synchronize channels definition with arduino_output: I2S must be 2 therefore we try to get it from arduino_output first
            if (arduino_output->channels()!=-1){
                this->channel_count = arduino_output->channels();
            } else {
                arduino_output->setChannels(channel_count);
            }
            SAM_LOG("-> channel_count: %d",this->channel_count);
            SAM_LOG("-> bits_per_sample: %d",this->bits_per_sample);
        }
 
        void write(uint8_t in) {            
            SAM_LOG("SAM::write bps:%d / channels:%d",bits_per_sample, channel_count);
            int16_t data[channel_count];
            int16_t sample = in;
            // convert unsinged 8 bit to signed 16 bits
            sample -= 128; 
            sample *= 128;
            // apply volume 
            sample = sample * volume;
            // mono to stereo
            for (int j = 0; j<channel_count; j++){
                data[j] = sample;
            }
            arduino_output->write((byte*)data, sizeof(data));
            // SAM_LOG("writing to %s", arduino_output->name());
        }
 
        bool textToSpeach(const char *str, bool is_phonetic) {
            SAM_LOG("textToSpeach: %s",str);
     
            if (!str || strlen(str)>254) return false; // Only can speak up to 1 page worth of data...
            samdata = new SamData();
            if (samdata == nullptr){
                // allocation failed!
                return false;
            }            
            arduino_output->open();
 
            // Input massaging
            char input[256];
            for (int i=0; str[i]; i++)
                input[i] = toupper((int)str[i]);
            input[strlen(str)] = 0;
            SAM_LOG("input copied");
 
            // To phonemes
            if (is_phonetic) {
                strncat(input, "\x9b", 255);
            } else {
                SAM_LOG("TextToPhonemes");
                strncat(input, "[", 255);
                if (!TextToPhonemes(input)) return false; // ERROR
            }
            // Say it!
            SAM_LOG("SetInput: %s", input);
            SetInput(input);
 
            SAM_LOG("SAMMain");
            SAMMain(outputByteCallback, (void*)this);
            SAM_LOG("SAMMain - done");
 
            // close the processing
            SAM_LOG("SAM done!");
            arduino_output->close();
 
            // Release SamData
            delete samdata;
 
            return true;
        }
};
 
void printLog(char* msg){
    Serial.println(msg);
}
 
struct PitchedStr {
    int pitch;
    char* str;
};