#ifndef SOUNDS_DIGITAL_BUS_H_INCLUDED
#define SOUNDS_DIGITAL_BUS_H_INCLUDED

#define SDB_WAV_FILE_NAME "sdb_output.wav"
#define SDB_UART_BIT 8
#define SDB_UART_PARITY 0
#define SDB_UART_STOP_BIT 1
#define SDB_UART_BAUDRATE 9600
#define SDB_UART_BAUDRATE_MAX 921600

/// максимальное значение (амплитуда) сэмпла аудио
#define SDB_MAX_DATA 30000
/// каналов в аудио
#define SDB_CANNEL 1
/// кол-во бит (разрешение) аудио
#define SDB_BIT 16
/// частота дискретизации аудио
#define SDB_FREQUENCY 96000
/// Количество буферов в очереди OpenAL
#define OPENAL_NUM_OF_DYNBUF 32
/// Настройки OpenAL
#define SDB_OPENAL_BIT SDB_BIT
#define SDB_OPENAL_CANNEL SDB_CANNEL
#define SDB_OPENAL_FREQUENCY SDB_FREQUENCY
#define SDB_OPENAL_FORMAT AL_FORMAT_MONO16
/// Количество байт в буфере
#define SDB_BUFFER_MAX 4800


/// использовать OpenAL для вывода аудио (если Да, то выставить 1)
#define SDB_WITH_OPENAL 1
/// режим отладки (если Да, то выставить 1)
#define SDB_WITH_DEBUG_MODE 0

#if SDB_WITH_OPENAL == 1
// Подключение библиотеки OpenAL Для вывода звука
#include <openal/al.h>
#include <openal/alc.h>
#endif

#if SDB_WITH_DEBUG_MODE == 1
// Для режима отладки
#include <stdio.h>
#include <locale.h>
#endif

//для работы с файлами
#include <stdio.h>
//для работы со строками
#include <string.h>



class sdb {
private:
#if SDB_WITH_OPENAL == 1
    // работа с openAl взята из библиотеки
    // синтезатора речи speesy
    ALCdevice* openAlDevice;
    ALCcontext* openAlContext;
    ALuint openAlSource;
    signed char openAlnBuf; //количество буферов
#endif
    // ----------------------------------------
    // для записи в WAV файл
    FILE *fpSave;
    unsigned short wavBlockAlign;
    unsigned long wavSubchunk2Size;
    unsigned long wavChunkSize;
    unsigned char wavLenDataType;
    // ----------------------------------------
    // для генерирования звуков шин данных
    double dTime; // длина времени одного сэмпла, в с.
    double allTime; // общее время трека
    short busState; // состояние шины (уровень сигнала)
    short busDataOne[SDB_BUFFER_MAX]; // буферы, куда пишем wav
    short busDataTwo[SDB_BUFFER_MAX];
    unsigned char switchBuffer; // переключатель между буферами
    unsigned int posBufferOne, posBufferTwo; // позиция в буферах
    unsigned int posAllBuffer; // общая позиция
    char wavFileName[512]; // имя wav файла
    char isCreateWavFileFlag; // флаг, что wav файл был создан
    char isBufferOneFlag; // флаг, что готов первый буфер
    char isBufferTwoFlag;
    unsigned int uartBaudrate; // скорость UART в бод
    unsigned int uartT;
    unsigned char uartBit; // количество бит
    unsigned char uartStopBit; // количество стоп бит
    unsigned char uartParityBit;
    unsigned char isAudioOutput;
    unsigned char isWavFileOutput;
#if SDB_WITH_OPENAL == 1
    ALboolean CheckALCError(void);
    ALboolean CheckALError(void);
    char initOpenAL(void);
    void destroyOpenAL(void);
    void playOpenAlSound(void);
    void stopOpenAlSound(void);
    void closeOpenAlSound(void);
    int getBufferStatusOpenAl(void);
    void setBufferOpenAl(signed short *buf,unsigned long siz);
    char updateOpenAl(void);
#endif
    char createWavFile(char * filename,unsigned long sampleRate,unsigned short bitsPerSample, unsigned short numChannels);
    void writeSampleWavFile(void *data);
    void writeDataBlockWavFile(void *data,unsigned long len);
    void closeWavFile(void);
    void busDelay(unsigned short us);

public:
    sdb(void);
    ~sdb(void);
    /** @brief функция генерирует звук одного байта шины 1-wire
        @param[in] data байт для отправки по 1-wire
    */
    void oneWireSendByte(unsigned char data);
    /** @brief генерирует звук сброса шины 1-wire
    */
    void oneWireReset(void);

    /** @brief останаливает работу шины 1- wire
    */
    void oneWireStop(void);

    /** @brief передает один байт по шине UART
        @param[in] data один символ шины UART
    */
    void uartSendByte(unsigned char data);

    /** @brief передает данные по шине UART
        @param[in] data один символ шины UART
    */
    void uartSend(unsigned long data);

    /** @brief устанавливает скорость UART
        @param[in] baudrate скорость шины UART
    */
    void uartSetBaudrate(unsigned long baudrate);

    /** @brief устанавливает количество отправляемых бит
        @param[in] bit количество бит, отправляемых шиной UART за один раз
    */
    void uartSetBit(unsigned char bit);

    /** @brief устанавливает количество стоп битов
        Данная функция устаналивает количество стоп битов.
        Минимальное значение стоп бита 1.
        @param[in] bit количество стоп битов
    */
    void uartSetStopBit(unsigned char bit);

    /** @brief устанавливает бит четности
        Данная функция устанавливает флаг использования в UART бита четности.
        Если передать 1, то бит четности будет задействован, если передать 0, то
        передача данных по UART будет идти без бита четности.
        @param[in] state флаг, включающий бит четности.
    */
    void uartSetParityBit(unsigned char state);

    /** @brief функция останавливает передачу UART
        Данная функция завершает работу UART, сохраняет или воспроизводит оставшиеся байты.
        Функцию вызывать обязательно в конце передачи данных по шине.
    */
    void uartStop(void);

    /** @brief функция устанавливает имя wav файла
        @param[in] filename имя wav файла
    */
    void setWavFileName(char* filename);

    /** @brief включить вывод аудио через OpenAL
    */
    void playAudioOn(void);

    /** @brief выключить вывод аудио через OpenAL
    */
    void playAudioOff(void);

    /** @brief включить запись аудио в wav файл
    */
    void recordOn(void);

    /** @brief выключить запись аудио в wav файл
    */
    void recordOff(void);
};


#endif // MUSICDIGITALBUS_H_INCLUDED

#include "SoundsDigitalBus.h"
#if SDB_WITH_OPENAL == 1
    // обработчики ошибок
    ALboolean sdb::CheckALCError(void) {
        ALenum ErrCode;
        ErrCode = alcGetError(openAlDevice);
        if (ErrCode != ALC_NO_ERROR) {
            return AL_FALSE;
        }
        return AL_TRUE;
    }
    ALboolean sdb::CheckALError(void) {
        ALenum ErrCode;
        if ((ErrCode = alGetError()) != AL_NO_ERROR) {
            return AL_FALSE;
        }
        return AL_TRUE;
    }

    // инициализация OpenAL
    char sdb::initOpenAL(void) {
        ALfloat SourcePos[] = {0.0, 0.0, 0.0};
        ALfloat SourceVel[] = {0.0, 0.0, 0.0};
        // Позиция слушателя.
        ALfloat ListenerPos[] = { 0.0, 0.0, 0.0 };
        // Скорость слушателя.
        ALfloat ListenerVel[] = { 0.0, 0.0, 0.0 };
        // Ориентация слушателя. (Первые 3 элемента – направление «на», последние 3 – «вверх»)
        ALfloat ListenerOri[] = { 0.0, 0.0, -1.0,  0.0, 1.0, 0.0 };
        #if SDB_WITH_DEBUG_MODE == 1
        printf("alcOpenDevice\n");
        #endif

        openAlDevice = alcOpenDevice(0); // open default device
        if (openAlDevice != 0) {
            openAlContext = alcCreateContext(openAlDevice,0); // create context
            if (openAlContext != 0) {
                #if SDB_WITH_DEBUG_MODE == 1
                printf("alcMakeContextCurrent\n");
                #endif
                alcMakeContextCurrent(openAlContext); // set active context
            } else  {
                #if SDB_WITH_DEBUG_MODE == 1
                printf("Error context\n");
                #endif
                return 0;
            }
        } else {
            #if SDB_WITH_DEBUG_MODE == 1
            printf("Error Open Device\n");
            #endif
            return 0;
        }

        // Позиция
        alListenerfv(AL_POSITION,    ListenerPos);
        // Скорость
        alListenerfv(AL_VELOCITY,    ListenerVel);
        // Ориентация
        alListenerfv(AL_ORIENTATION, ListenerOri);

        alGenSources(1, &openAlSource);
        if (!CheckALError())
            return false;

        alSourcef (openAlSource, AL_PITCH,    1.0f);
        alSourcef (openAlSource, AL_GAIN,    1.0f);
        alSourcefv(openAlSource, AL_POSITION,  SourcePos);
        alSourcefv(openAlSource, AL_VELOCITY,  SourceVel);
        alSourcei (openAlSource, AL_LOOPING,  AL_FALSE);

        alSourcei(openAlSource, AL_LOOPING, AL_FALSE);
        openAlnBuf = 0;
        return 1;
    }

    void sdb::destroyOpenAL(void) {
        alSourceStop(openAlSource);
        // Выключаем текущий контекст
        alcMakeContextCurrent(0);
        // Уничтожаем контекст
        alcDestroyContext(openAlContext);
        // Закрываем звуковое устройство
        alcCloseDevice(openAlDevice);
    }

    void sdb::playOpenAlSound(void) {
        alSourcePlay(openAlSource);
    }

    void sdb::stopOpenAlSound(void) {
        alSourceStop(openAlSource);
    }

    void sdb::closeOpenAlSound(void) {
        alSourceStop(openAlSource);
        if (alIsSource(openAlSource))
            alDeleteSources(1, &openAlSource);
    }

    int sdb::getBufferStatusOpenAl(void) {
        int processed = 0;
        if (openAlnBuf == 0)
            return 1;
        alGetSourcei(openAlSource, AL_BUFFERS_PROCESSED, &processed);
        CheckALError();
        #if SDB_WITH_DEBUG_MODE == 1
            printf("getBufferStatus: %d\n",processed);
        #endif
        if (processed != 0) {
            return processed;
        }
        return 0;
    }

    void sdb::setBufferOpenAl(signed short* buf, unsigned long siz) {
        int processed = 0;
        ALuint BufID = 0;
        #if _OPENAL_FORMAT == AL_FORMAT_MONO16
        siz = siz*2;
        #endif // _OPENAL_FORMAT
        #if _OPENAL_FORMAT == AL_FORMAT_STEREO16
        siz = siz*4;
        #endif // _OPENAL_FORMAT
        #if _OPENAL_FORMAT == AL_FORMAT_STEREO8
        siz = siz*2;
        #endif // _OPENAL_FORMAT
        // Получаем количество отработанных буферов
        alGetSourcei(openAlSource, AL_BUFFERS_PROCESSED, &processed);
        CheckALError();
        //если отработанных буферов нет, есть новые данные и число буферов не превысило максимума
        if ((processed == 0) && (openAlnBuf < OPENAL_NUM_OF_DYNBUF)) {
            openAlnBuf++; //увеличиваем число буферов
            alGenBuffers(1, &BufID); //создаем новый буфер
            alBufferData(BufID,SDB_OPENAL_FORMAT,buf,siz,SDB_OPENAL_FREQUENCY); //загружаем данные в новый буфер
            alSourceQueueBuffers(openAlSource, 1, &BufID); //добавляем буфер в очередь
            if (openAlnBuf == 1)
                alSourcePlay(openAlSource);
        } else {
            #if SDB_WITH_DEBUG_MODE == 1
                printf("processed: %d openAlnBuf: %d\n",processed,openAlnBuf);
            #endif
            // ждем, когда будет обработан хотя бы один буфер
            while (getBufferStatusOpenAl() == 0);
            // убираем из очереди буфер
            alSourceUnqueueBuffers(openAlSource, 1, &BufID);
            CheckALError();
            // загружаем новый буфер
            alBufferData(BufID,SDB_OPENAL_FORMAT,buf,siz,SDB_OPENAL_FREQUENCY);
            CheckALError();
            alSourceQueueBuffers(openAlSource, 1, &BufID);
            CheckALError();
        }
    }
    // функция очищяет все буферы по мере их опустошения, и останавливает проигрывание
    // возвращает 1 если еще есть не пустые буферы
    char sdb::updateOpenAl(void) {
        int processed = 0;
        ALuint      BufID;
        // Получаем количество отработанных буферов
        alGetSourcei(openAlSource, AL_BUFFERS_PROCESSED, &processed);
        #if SDB_WITH_DEBUG_MODE == 1
            printf("updateOpenAl: %d\n",processed);
        #endif
        // если обработаны все буферы
        if (openAlnBuf == processed) {
            // Если таковые существуют то
            while (processed--) {
                // Исключаем их из очереди
                alSourceUnqueueBuffers(openAlSource, 1, &BufID);
                if (!CheckALError())
                    return 0;
                alDeleteBuffers(1, &BufID);
                openAlnBuf--;
            }
            alSourceStop(openAlSource);
            #if SDB_WITH_DEBUG_MODE == 1
                printf("alSourceStop: %d\n",openAlnBuf);
            #endif
            return 0;
        }
        return 1;
    }
#endif

    // задержка для шин данных. тут генерируется звук
    void sdb::busDelay(unsigned short us) {
        double Time = (double)us/1000000.0;
        double locTime = allTime;
        char isFlag = 0;
        // создаем wav файл, если он не был создан ранее
        if (isCreateWavFileFlag == 0) {
            if (isWavFileOutput == 1) {
                isFlag = createWavFile(wavFileName,SDB_FREQUENCY,SDB_BIT,SDB_CANNEL);
                // если файл был успешно открыт, то ставим флаг
                if (isFlag == 1)
                    isCreateWavFileFlag = 1;
            }
            if (isAudioOutput == 1) {
                initOpenAL();
                if (isWavFileOutput == 0)
                    isCreateWavFileFlag = 1;
            }
        }
        allTime = allTime + Time;
        // если файл был открыт
        if (isCreateWavFileFlag == 1)
            // начинаем делать сэмплы аудиоданных
            while(locTime < allTime) {
                if (switchBuffer == 0) {
                    if (posBufferOne >= SDB_BUFFER_MAX) {
                        posBufferOne = 0;
                        posBufferTwo = 0;
                        busDataTwo[posBufferTwo++] = busState;
                        isBufferOneFlag = 1;
                        switchBuffer = 1;
                        if (isWavFileOutput == 1)
                            writeDataBlockWavFile(busDataOne,SDB_BUFFER_MAX);
                        #if SDB_WITH_OPENAL == 1
                            if (isAudioOutput == 1)
                                setBufferOpenAl(busDataOne,SDB_BUFFER_MAX);
                        #endif
                    } else {
                        busDataOne[posBufferOne++] = busState;
                    }
                } else
                if (switchBuffer == 1) {
                    if (posBufferTwo >= SDB_BUFFER_MAX) {
                        posBufferOne = 0;
                        posBufferTwo = 0;
                        busDataOne[posBufferOne++] = busState;
                        isBufferTwoFlag = 1;
                        switchBuffer = 0;
                        if (isWavFileOutput == 1)
                            writeDataBlockWavFile(busDataTwo,SDB_BUFFER_MAX);
                        #if SDB_WITH_OPENAL == 1
                            if (isAudioOutput == 1)
                                setBufferOpenAl(busDataTwo,SDB_BUFFER_MAX);
                        #endif
                    } else {
                        busDataTwo[posBufferTwo++] = busState;
                    }
                }
                posAllBuffer++;
                locTime = locTime + dTime;
            }
    }


    char sdb::createWavFile(char * filename,unsigned long sampleRate,unsigned short bitsPerSample, unsigned short numChannels) {
        char type[4];
        const unsigned long subchunk1Size = 16;
        unsigned long byteRate;
        const unsigned short audioFormat = 1;
        unsigned short len_str = 0;
        char str_filename[512] = {0};
        unsigned short i;
        // количество байт в одном сэмле одного канала
        wavLenDataType = bitsPerSample/8;

        wavSubchunk2Size = 0;
        wavChunkSize = wavSubchunk2Size + 44 - 8;
        // Количество байт на одну выборку
        wavBlockAlign = bitsPerSample / (8 * numChannels);
        //Количество байт, переданных за секунду воспроизведения.
        byteRate = sampleRate * wavBlockAlign;

        strcpy(str_filename,filename);
        len_str = strlen(str_filename);
        if (len_str < 4)
            return 0;
        // проверка имени файла на наличие расширения .wav
        i = 0;
        while(i < len_str) {
            if (filename[i] == '.' && (i + 3) < len_str) {
                if (((filename[i + 1] == 'w')
                    && (filename[i + 2] == 'a')
                    && (filename[i + 3] == 'v'))
                    ||
                    ((filename[i + 1] == 'W')
                    && (filename[i + 2] == 'A')
                    && (filename[i + 3] == 'V'))) {
                    // если имя имеет расширение wav
                    break;
                } else {
                    if ((i + 3) >= 512)
                        return 0;
                    filename[i + 1] = 'w';
                    filename[i + 2] = 'a';
                    filename[i + 3] = 'v';
                    len_str = i + 4;
                    break;
                }
            } else
            if ((i + 1) == len_str) {
                if ((i + 3) >= 512)
                    return 0;
                filename[i + 1] = '.';
                filename[i + 2] = 'w';
                filename[i + 3] = 'a';
                filename[i + 4] = 'v';
                len_str = i + 5;
                break;
            }
            i++;
        }

        type[0] = filename[len_str - 4];
        type[1] = filename[len_str - 3];
        type[2] = filename[len_str - 2];
        type[3] = filename[len_str - 1];
        if (type[0]!='.'||type[1]!='w'||type[2]!='a'||type[3]!='v') {
            if (type[0]!='.'||type[1]!='W'||type[2]!='A'||type[3]!='V') {
                return 0;
            }
        }
        fpSave=fopen(str_filename,"wb");
        type[0]='R';
        type[1]='I';
        type[2]='F';
        type[3]='F';
        fwrite(&type,sizeof(char),4,fpSave);
        fwrite(&wavChunkSize,sizeof(unsigned long),1,fpSave);

        type[0]='W';
        type[1]='A';
        type[2]='V';
        type[3]='E';
        fwrite(&type,sizeof(char),4,fpSave);

        type[0]='f';
        type[1]='m';
        type[2]='t';
        type[3]=' ';
        fwrite(&type,sizeof(char),4,fpSave);
        fwrite(&subchunk1Size,sizeof(unsigned long),1,fpSave);
        fwrite(&audioFormat,sizeof(unsigned short),1,fpSave);
        fwrite(&numChannels,sizeof(unsigned short),1,fpSave);
        fwrite(&sampleRate,sizeof(unsigned long),1,fpSave);
        fwrite(&byteRate,sizeof(unsigned long),1,fpSave);
        fwrite(&wavBlockAlign,sizeof(unsigned short),1,fpSave);
        // Количество бит в сэмпле. Так называемая “глубина” или точность звучания. 8 бит, 16 бит и т.д.
        fwrite(&bitsPerSample,sizeof(unsigned short),1,fpSave);

        type[0]='d';
        type[1]='a';
        type[2]='t';
        type[3]='a';
        // subchunk2Id
        // Содержит символы “data” (0x64617461 в big-endian представлении)
        fwrite(&type, sizeof(char), 4,fpSave);
        wavSubchunk2Size = 0;
        //Количество байт в области данных.
        fwrite(&wavSubchunk2Size, sizeof(unsigned long), 1,fpSave);
        return 1;
    }

    void sdb::writeSampleWavFile(void* data) {
        fwrite(data, wavLenDataType, wavBlockAlign, fpSave);
        wavSubchunk2Size = wavSubchunk2Size + wavLenDataType*wavBlockAlign;
    }

    void sdb::writeDataBlockWavFile(void* data, unsigned long len) {
        fwrite(data, wavLenDataType, len, fpSave);
        wavSubchunk2Size = wavSubchunk2Size + len*wavLenDataType;
    }
    // данная функция закрывает аудиофайл и записывает количесвто байт данных.
    void sdb::closeWavFile(void) {
        wavChunkSize = wavSubchunk2Size + 44 - 8;
        fseek(fpSave,4,SEEK_SET);
        fwrite(&wavChunkSize,4,1,fpSave);
        fseek(fpSave,40,SEEK_SET);
        fwrite(&wavSubchunk2Size,4,1,fpSave);
        fclose(fpSave);
    }

    // конструктор
    sdb::sdb(void) {
        openAlnBuf = 0;
        wavBlockAlign = 0;
        wavSubchunk2Size = 0;
        wavChunkSize = 0;
        wavLenDataType = 0;
        fpSave = NULL;
        strcat(wavFileName,SDB_WAV_FILE_NAME);
        dTime = 1.0/(double)SDB_OPENAL_FREQUENCY;
        allTime = 0.0;
        // переключатель буферов на первом буфере
        switchBuffer = 0;
        // позиция в буферах (сумма)
        posAllBuffer = 0;
        // позиции в буфере обнуляем
        posBufferOne = 0;
        posBufferTwo = 0;
        isBufferOneFlag = 0;
        isBufferTwoFlag = 0;
        isCreateWavFileFlag = 0;
        busState = SDB_MAX_DATA;
        uartSetBaudrate(SDB_UART_BAUDRATE);
        uartSetBit(SDB_UART_BIT);
        uartSetStopBit(SDB_UART_STOP_BIT);
        uartSetParityBit(SDB_UART_PARITY);
        recordOn();
        playAudioOn();
    }

    // деструктор
    sdb::~sdb() {
        if (isCreateWavFileFlag == 1) {
            if (posBufferOne > 0) {
                if (isWavFileOutput == 1)
                    writeDataBlockWavFile(busDataOne,posBufferOne);
                #if SDB_WITH_OPENAL == 1
                    if (isAudioOutput == 1)
                        setBufferOpenAl(busDataOne,posBufferTwo);
                #endif

            } else
            if (posBufferTwo > 0) {
                if (isWavFileOutput == 1)
                    writeDataBlockWavFile(busDataTwo,posBufferTwo);
                #if SDB_WITH_OPENAL == 1
                    if (isAudioOutput == 1)
                        setBufferOpenAl(busDataTwo,posBufferTwo);
                #endif
            }
            if (isWavFileOutput == 1)
                closeWavFile();
            isCreateWavFileFlag = 0;
            #if SDB_WITH_OPENAL == 1
                if (isAudioOutput == 1) {
                    while (1) {
                        // Ждем, когда звук проиграет до конца
                        if (updateOpenAl() == 0)
                            break;
                    }
                    closeOpenAlSound();
                    destroyOpenAL();
                }
            #endif
        }
    }

    // функция передает данные по шине one wire
    void sdb::oneWireSendByte(unsigned char data) {
        for (register unsigned char i = 0; i < 8; i++) {
            if((data & (1 << i)) == 1 << i) {
                busState = 0;
                busDelay(12);
                busState = SDB_MAX_DATA;
                busDelay(65);
            } else {
                busState = 0;
                busDelay(65);
                busState = SDB_MAX_DATA;
                busDelay(12);
            }
        }
        busState = SDB_MAX_DATA;
    }

    // функция передает один байт по шине uart
    void sdb::uartSendByte(unsigned char data) {
        unsigned short pBit = 0; // переменная для бита четности
        // старт бит
        busState = SDB_MAX_DATA;
        busDelay(uartT);
        busState = -SDB_MAX_DATA;
        // данные
        for (register unsigned char i = 0; i < 8; i++) {
            if((data & (1<<i)) == 1<<i) {
                busState = -SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
                pBit++;
            } else {
                busState = SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            }
        }
        // бит честности
        if (uartParityBit != 0) {
            if ((pBit & 0x0001) == 0) {
                busState = -SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            } else {
                busState = SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            }
        }
        // стоп бит
        busState = -SDB_MAX_DATA;
        for (register unsigned char i = 0; i < uartStopBit; i++)
            busDelay(uartT);
        busState = -SDB_MAX_DATA;
    }

    // функция передает данные по шине uart
    void sdb::uartSend(unsigned long data) {
        unsigned short pBit = 0; // переменная для бита четности
        // старт бит
        busState = SDB_MAX_DATA;
        busDelay(uartT);
        busState = -SDB_MAX_DATA;
        // данные
        for (register unsigned char i = 0; i < uartBit; i++) {
            if((data & (1<<i)) == 1<<i) {
                busState = -SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            } else {
                busState = SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            }
        }
        // бит честности
        if (uartParityBit != 0) {
            if ((pBit & 0x0001) == 0) {
                busState = -SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            } else {
                busState = SDB_MAX_DATA;
                busDelay(uartT);
                busState = -SDB_MAX_DATA;
            }
        }
        // стоп бит
        busState = -SDB_MAX_DATA;
        for (register unsigned char i = 0; i < uartStopBit; i++)
            busDelay(uartT);
        busState = -SDB_MAX_DATA;
    }

    // функция устанавливает скорость UART
    void sdb::uartSetBaudrate(unsigned long baudrate) {
        if (baudrate > SDB_UART_BAUDRATE_MAX)
            baudrate = SDB_UART_BAUDRATE_MAX;
        uartBaudrate = baudrate;
        uartT = 1000000 / baudrate;
    }

    void sdb::uartSetBit(unsigned char bit) {
        if (bit > 32)
            bit = 32;
        if (bit == 0)
            bit = 1;
        if (bit < 8)
            bit = 8;
        uartBit = bit;
    }

    void sdb::uartSetStopBit(unsigned char bit) {
        if (bit == 0)
            bit = 1;
        uartStopBit = bit;
    }

    void sdb::uartSetParityBit(unsigned char state) {
        if (state > 1)
            state = 1;
        uartParityBit = state;
    }

    //функция определяет есть ли устройство на шине
    void sdb::oneWireReset(void) {
        busState = SDB_MAX_DATA;
        busDelay(100);
        busState = 0;//логический "0"
        busDelay(485);//ждем минимум 480мкс
        busState = SDB_MAX_DATA;
        busDelay(65);//ждем минимум 60мкс и смотрим что на шине
        busState = 0;//логический "0"
        busDelay(400);
        busState = SDB_MAX_DATA;
        busDelay(100);
    }

    // функция останавливает шину 1-wire
    void sdb::oneWireStop(void) {
        if (isCreateWavFileFlag == 1) {
            if (posBufferOne > 0) {
                if (isWavFileOutput == 1)
                    writeDataBlockWavFile(busDataOne,posBufferOne);
                #if SDB_WITH_OPENAL == 1
                    if (isAudioOutput == 1)
                        setBufferOpenAl(busDataOne,posBufferOne);
                #endif
            } else
            if (posBufferTwo > 0) {
                if (isWavFileOutput == 1)
                    writeDataBlockWavFile(busDataTwo,posBufferTwo);
                #if SDB_WITH_OPENAL == 1
                    if (isAudioOutput == 1)
                        setBufferOpenAl(busDataTwo,posBufferTwo);
                #endif
            }
            #if SDB_WITH_OPENAL == 1
                while (1) {
                    // Ждем, когда звук проиграет до конца
                    if (updateOpenAl() == 0)
                        break;
                }
                closeOpenAlSound();
                destroyOpenAL();
            #endif
            if (isWavFileOutput == 1)
                closeWavFile();
            isCreateWavFileFlag = 0;
        }
    }

    void sdb::uartStop(void) {
        if (isCreateWavFileFlag == 1) {
            if (posBufferOne > 0) {
                if (isWavFileOutput == 1)
                    writeDataBlockWavFile(busDataOne,posBufferOne);
                #if SDB_WITH_OPENAL == 1
                    if (isAudioOutput == 1)
                        setBufferOpenAl(busDataOne,posBufferOne);
                #endif
            } else
            if (posBufferTwo > 0) {
                if (isWavFileOutput == 1)
                    writeDataBlockWavFile(busDataTwo,posBufferTwo);
                #if SDB_WITH_OPENAL == 1
                    if (isAudioOutput == 1)
                        setBufferOpenAl(busDataTwo,posBufferTwo);
                #endif
            }
            #if SDB_WITH_OPENAL == 1
                if (isAudioOutput == 1) {
                    while (1) {
                        // Ждем, когда звук проиграет до конца
                        if (updateOpenAl() == 0)
                            break;
                    }
                    closeOpenAlSound();
                    destroyOpenAL();
                }
            #endif
            if (isWavFileOutput == 1)
                closeWavFile();
            isCreateWavFileFlag = 0;
        }
    }

    void sdb::setWavFileName(char* filename) {
        strcat(wavFileName,filename);
    }

    void sdb::playAudioOn(void) {
        if (isCreateWavFileFlag == 0)
            isAudioOutput = 1;
    }

    void sdb::playAudioOff(void) {
        if (isCreateWavFileFlag == 0)
            isAudioOutput = 0;
    }

    void sdb::recordOn(void) {
        if (isCreateWavFileFlag == 0)
            isWavFileOutput = 1;
    }

    void sdb::recordOff(void) {
        if (isCreateWavFileFlag == 0) {
            if (isAudioOutput == 1)
                isWavFileOutput = 0;
            else
                isWavFileOutput = 1;
        }
    }

#ifndef MAIN_H_INCLUDED
#define MAIN_H_INCLUDED

#define LINUX 0x00
#define WINDOWS 0x01

#define RU 0x00
#define EN 0x01

/// Тип операционой системы
#define TYPE_OS WINDOWS

/// Язык программы
#define LANGUAGE_PROGRAM RU

#define UART_BUS 0x01
#define ONE_WIRE_BUS 0x02

#include <iostream>
#include "SoundsDigitalBus.h"
#include "stdlib.h"
#include <stdio.h>

#endif // MAIN_H_INCLUDED

#include "main.h"

sdb soundsDigitalBus;

int main() {
    static FILE *fp = NULL; // файл с данными
    char strData[512]; // буфер для строк
    char strChar = 0; // символ
    unsigned char busType; // тип цифровой шины
    int strPos = 0; // позиция в строке
    int uartBaudrate = 0; // скорость UART
    int uartBit = 8;
    int uartStopBit = 0;
    //int uartParityBit = 0;

    #if TYPE_OS==WINDOWS and LANGUAGE_PROGRAM==RU
    setlocale(LC_ALL, "Russian");
    printf("Введите скорость UART в бод, или укажите 0, если хотите 1-wire.\n");
    #else
    printf("Enter the UART baud rate, or specify 0 if you want 1-wire.\n");
    #endif
    printf("UART Baudrate: ");
    memset(strData,0,512);
    while(1) {
        strChar = getchar();
        if ((strChar >= '0') && (strChar <= '9')) {
            strData[strPos++] = strChar;
        } else
            break;
    }
    uartBaudrate = atoi(strData);
    if (uartBaudrate == 0) {
        busType = ONE_WIRE_BUS;
    } else {
        busType = UART_BUS;
        soundsDigitalBus.uartSetBaudrate(uartBaudrate);
    }
    printf("\n");
    if (busType == UART_BUS) {
        #if TYPE_OS==WINDOWS and LANGUAGE_PROGRAM==RU
        printf("Введите количество бит UART\n");
        #else
        printf("Enter the number of bits UART.\n");
        #endif
        printf("UART bit: ");
        memset(strData,0,512);
        while(1) {
            strChar = getchar();
            if ((strChar >= '0') && (strChar <= '9')) {
                strData[strPos++] = strChar;
            } else
                break;
        }
        uartBit = atoi(strData);
        soundsDigitalBus.uartSetBit(uartBit);
        printf("\n");
        #if TYPE_OS==WINDOWS and LANGUAGE_PROGRAM==RU
        printf("Введите количество стоп бит UART\n");
        #else
        printf("Enter the number of stop bits UART.\n");
        #endif
        printf("UART stop bit: ");
        memset(strData,0,512);
        while(1) {
            strChar = getchar();
            if ((strChar >= '0') && (strChar <= '9')) {
                strData[strPos++] = strChar;
            } else
                break;
        }
        uartStopBit = atoi(strData);
        soundsDigitalBus.uartSetStopBit(uartStopBit);
        printf("\n");
        #if TYPE_OS==WINDOWS and LANGUAGE_PROGRAM==RU
        printf("Использовать бит четности в UART? (Y/n)\n");
        #else
        printf("Use the parity bit in the UART? (Y/n)\n");
        #endif
        strChar = getchar();
        if ((strChar == 'n')
            || (strChar == 'N')
            || (strChar == 'т')
            || (strChar == 'Т')) {
            soundsDigitalBus.uartSetParityBit(0);
            printf("not used\n");
        } else {
            soundsDigitalBus.uartSetParityBit(1);
            printf("Yes, use\n");
        }
        getchar();
        printf("\n");
    }


    FILE_M:
    printf("\n");
    #if TYPE_OS==WINDOWS
    printf("Укажите файл для преобразования его в запись цифровой шины.\n");
    printf("Например: D: \\ Games \\ SR2 \\ Rangers.txt\n");
    printf("Файл: ");
    #else
    printf("Specify the file to convert it to record digital bus.\n");
    printf("For example: D: \\ Games \\ SR2 \\ Rangers.txt\n");
    printf("File: ");
    #endif
    memset(strData,0,512);
    strPos = 0;
    while(1) {
        strChar = getchar();
        if (strChar != '\n') {
            strData[strPos++] = strChar;
        } else
            break;
    }
    fp = fopen(strData,"rb");
    if (fp == NULL) {
        printf("\n");
        #if TYPE_OS==WINDOWS
        printf("Ошибка! Файл %s не найден!\n",strData);
        printf("Поробуйте правильно указать путь до файла.\n");
        printf("...\n");
        #else
        printf("Error! File %s not found!\n",strData);
        printf("Try to correctly specify the path to the file.\n");
        printf("...\n");
        #endif
        getchar();
        goto FILE_M;
    }
    //soundsDigitalBus.setWavFileName(strData);
    printf("\n");
#if SDB_WITH_OPENAL == 1
    #if TYPE_OS==WINDOWS
    printf("Воспроизводить аудио во время работы цифровой шины? (Y/n)\n");
    #else
    printf("Play audio while working digital bus? (Y/n)\n");
    #endif
    strChar = getchar();
    if ((strChar == 'n')
        || (strChar == 'N')
        || (strChar == 'т')
        || (strChar == 'Т')) {
        soundsDigitalBus.playAudioOff();
        printf("not used\n");
    } else {
        soundsDigitalBus.playAudioOn();
        printf("Yes, use\n");
    }
    getchar();
    printf("\n");
    #if TYPE_OS==WINDOWS
    printf("Записывать аудио во время работы цифровой шины? (Y/n)\n");
    #else
    printf("Record audio while working digital bus? (Y/n)\n");
    #endif
    strChar = getchar();
    if ((strChar == 'n')
        || (strChar == 'N')
        || (strChar == 'т')
        || (strChar == 'Т')) {
        soundsDigitalBus.recordOff();
        printf("not used\n");
    } else {
        soundsDigitalBus.recordOn();
        printf("Yes, use\n");
    }
    getchar();
#else
    soundsDigitalBus.recordOn();
#endif
    printf("\n");
    #if TYPE_OS==WINDOWS
    printf("Преобразование начато.\n");
    #else
    printf("The transformation started.\n");
    #endif
    unsigned char uartData[8];
    if (busType == ONE_WIRE_BUS) {
        soundsDigitalBus.oneWireReset();
    }
    while(1) {
        if (fread(uartData,sizeof(unsigned char),1,fp) > 0) {
            if (busType == UART_BUS) {
                if (uartBit == 8) {
                    soundsDigitalBus.uartSendByte(uartData[0]);
                } else {
                    soundsDigitalBus.uartSend(uartData[0]);
                }
            } else
            if (busType == ONE_WIRE_BUS) {
                soundsDigitalBus.oneWireSendByte(uartData[0]);
            }
        } else
            break;
    }
    fclose(fp);
    if (busType == ONE_WIRE_BUS) {
        soundsDigitalBus.oneWireStop();
    } else
    if (busType == UART_BUS) {
        soundsDigitalBus.uartStop();
    }
    #if TYPE_OS==WINDOWS
    printf("Преобразование завершено.\n");
    #else
    printf("Conversion completed.\n");
    #endif
    return 0;
    //soundsDigitalBus.oneWireReset();
    soundsDigitalBus.uartSetBaudrate(1200);
    for (int i = 0; i < 256; i ++) {
        for (int len = 0; len < 8; len++) {
            soundsDigitalBus.uartSendByte(i);
        }
        printf("%d\n",i);
    }
    soundsDigitalBus.oneWireStop();
    return 0;
}