uart_driver.c

win2000下的与下位机UART的串口通信程序

#include "stdio.h"
#include "stdlib.h"
#include <string.h>
#include "command.h"

extern void set_baud_rate(int baud);
extern void wait(int time);
const unsigned char	PT[16] = {0,1,1,0, 1,0,0,1, 1,0,0,1, 0,1,1,0};
char parity(char Byte)
{
	if ( ((PT[(Byte>>4)&0xf] + PT[(Byte & 0xF)]) & 1) )
		return	Byte;
	else
		return (Byte | 1);
}


int baud_rate_table[8] = {2400,4800,9600,19200,38400,57600,115200,230400};
int set_uart_baud_rate(int baud_rate)
{
    int i,num;
    char byte;
    num = -1;
    for(i=0;i<8;i++)
    {
        if(baud_rate == baud_rate_table[i])
        {
            num = i;
            break;
        }
    }
    if(num == -1)
        return ERROR;
	send_one_byte(parity((char)(CMD_UART_SBR|((num<<1)&0xe))));
    if(receive_one_byte(&byte) != OK)
         return ERROR;
    if(byte != 0x57)
         return ERROR;
    set_baud_rate(baud_rate);     //change baud rate
    send_one_byte(CMD_VERIFICTION);
    if(receive_one_byte(&byte) != OK)
         return ERROR;
    if(byte != (~CMD_VERIFICTION))
         return ERROR;
    return OK;
}

int req_status(void)
{
	char byte;
    send_one_byte(CMD_REQ_STATUS);
    if(receive_one_byte(&byte) != OK)
         return ERROR;
    return byte;

}
int whole_control(int com)
{
    if(com == 0)
        send_one_byte(CMD_STOP_ALL);
    else if(com == 1)
        send_one_byte(CMD_PLAY_ALL);
    else
         return ERROR;
    return OK;
}

int speech_control(int com)
{
    if(com == 0)
        send_one_byte(CMD_STOP_SPEECH);
    else if(com == 1)
        send_one_byte(CMD_PLAY_SPEECH);
    else if(com == 2)
        send_one_byte(CMD_PAUSE_SPEECH);
    else if(com == 3)
        send_one_byte(CMD_MUTE_SPEECH);
    else
         return ERROR;
    return OK;
}

int midi_control(int com)
{
    if(com == 0)
        send_one_byte(CMD_STOP_MIDI);
    else if(com == 1)
        send_one_byte(CMD_PLAY_MIDI);
    else if(com == 2)
        send_one_byte(CMD_PAUSE_MIDI);
    else if(com == 3)
        send_one_byte(CMD_MUTE_MIDI);
    else
         return ERROR;
    return OK;
}

int set_volume(int volume)
{
    if((volume > 0x7ff) || (volume < 0x00))
         return ERROR;
    send_one_byte(parity((char)(CMD_SET_VOLUME|((volume>>7)&0x1e))));
    send_one_byte((char)(volume&0xff));
    return OK;
}

int clear_dbe(void)
{
    send_one_byte(CMD_CLEAR_DBE);
    return OK;
}

int set_bit_rates(int bit_rates)
{
    if((bit_rates > 10) || (bit_rates < 1))
        return ERROR;
    send_one_byte(parity((char)(CMD_SPEECH_BIT_RATES|((bit_rates<<1)&0x1e))));
    return OK;
}

int speech_channel_select(int sel)
{
    if(sel == 0)
        send_one_byte(CMD_SPEECH_SELECT_LBR);
    else if(sel == 1)
        send_one_byte(CMD_SPEECH_SELECT_HBR);
    else
        return ERROR;
    return OK;
}

int speech_filter_control(int com)
{
    if(com == 0)
        send_one_byte(CMD_FILTER_DISABLE);
    else if(com == 1)
        send_one_byte(CMD_FILTER_ENABLE);
    else
        return ERROR;
    return OK;
}

int set_lbr_speed(int speed)
{
    if((speed > 15) || (speed < 0))
        return ERROR;
    send_one_byte(parity((char)(CMD_SET_LBRSPEED|((speed<<1)&0x1e))));
    return OK;
}

int set_midi_volume(int volume)
{
    send_one_byte((char)CMD_MIDI_VOL0);
    send_one_byte((char)((volume>>24)&0xff));
    send_one_byte((char)CMD_MIDI_VOL1);
    send_one_byte((char)((volume>>16)&0xff));
    send_one_byte((char)CMD_MIDI_VOL2);
    send_one_byte((char)((volume>>8)&0xff));
    send_one_byte((char)CMD_MIDI_VOL3);
    send_one_byte((char)((volume)&0xff));
    return OK;
}

int clear_input_buffer(int com)
{
    if(com == 0)
        send_one_byte((char)CMD_CLEAR_ALL);
    else if(com == 1)
        send_one_byte((char)CMD_CLEAR_VOICE);
    else if(com == 2)
        send_one_byte((char)CMD_CLEAR_MIDI);
    else
        return ERROR;
    return OK;
}

int read_ram(char *pOut, int start_address, int size)
{
	int i;
    if(start_address >= 2048 || start_address < 0 || size>=2048 || size < 0)
        return ERROR;

    send_one_byte((char)CMD_SET_RAM_ADD);
    send_one_byte((char)((start_address>>8) & 0xff));
    send_one_byte((char)(start_address & 0xff));

    for(i=0;i<size;i++)
    {
        send_one_byte((char)CMD_READ_RAM);
        if(receive_one_byte(pOut++) != OK)
            return ERROR;
    }
    return OK;
}

int write_ram(char *pIn, int start_address, int size)
{
    int i;
	if(start_address >= 2048 || start_address < 0 || size>=2048 || size < 0)
        return ERROR;

    send_one_byte((char)CMD_SET_RAM_ADD);
    send_one_byte((char)((start_address>>8) & 0xff));
    send_one_byte((char)(start_address & 0xff));

    for(i=0;i<size;i++)
    {
        send_one_byte((char)CMD_WRITE_RAM);
        send_one_byte(*pIn++);
    }
    return OK;
}

int set_gpio_dir(int sel, int dir)
{
    if(sel == 0)
    {
        send_one_byte((char)CMD_SET_GPIOL_DIR);
        send_one_byte((char)(dir&0xff));
    }
    else if(sel == 1)
    {
        send_one_byte((char)CMD_SET_GPIOH_DIR);
        send_one_byte((char)(dir&0xff));
    }
    else
        return ERROR;
    return OK;
}

int read_gpio_data(int sel, char* data)
{
    if(sel == 0)
    {
        send_one_byte((char)CMD_READ_GPIOL);
        if(receive_one_byte(data) != OK)
            return ERROR;
    }
    else if(sel == 1)
    {
        send_one_byte((char)CMD_READ_GPIOH);
        if(receive_one_byte(data) != OK)
            return ERROR;
    }
    else
        return ERROR;
    return OK;
}

int write_gpio_data(int sel, char data)
{
    if(sel == 0)
    {
        send_one_byte((char)CMD_WRITE_GPIOL);
        send_one_byte((char)(data&0xff));
    }
    else if(sel == 1)
    {
        send_one_byte((char)CMD_WRITE_GPIOH);
        send_one_byte((char)(data&0xff));
    }
    else
        return ERROR;
    return OK;
}

const int speech_data_len_tbl[] = {0, 1, 4, 8, 16, 32, 64, 128};
const int music_data_len_tbl[] = {0, 1, 4, 8, 16, 32, 64, 128};
int send_speech_data(char* pIn, int size)
{
    char byte;
    if(size < 0)
        return ERROR;
    while(size != 0)
    {
        if(size >= 128)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x7<<1)));
            send_bytes(pIn,128);
			pIn += 128;
            size -= 128;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
       }
        else if(size >= 64)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x6<<1)));
            send_bytes(pIn,64);
			pIn += 64;
			size -= 64;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
        }
        else if(size >= 32)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x5<<1)));
            send_bytes(pIn,32);
			pIn += 32;
            size -= 32;
			if(receive_one_byte(&byte) != OK)
                return ERROR;
        }
        else if(size >= 16)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x4<<1)));
            send_bytes(pIn,16);
			pIn += 16;
            size -= 16;
			if(receive_one_byte(&byte) != OK)
                return ERROR;
        }
        else if(size >= 8)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x3<<1)));
            send_bytes(pIn,8);
			pIn += 8;
            size -= 8;
			if(receive_one_byte(&byte) != OK)
                return ERROR;
        }
        else if(size >= 4)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x2<<1)));
            send_bytes(pIn,4);
			pIn += 4;
            size -= 4;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
        }
        else if(size >= 1)
        {
            send_one_byte(parity((char)CMD_SPEECH_DATA_TRANSFER|(0x1<<1)));
            send_bytes(pIn,1);
			pIn += 1;
            size -= 1;
			if(receive_one_byte(&byte) != OK)
                return ERROR;
        }


    }
	return OK;
}

int send_midi_data(char* pIn, int size)
{
    int i;
    char byte;
    if(size < 0)
        return ERROR;
    while(size != 0)
    {
        if(size >= 128)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x7<<1)));
            for(i=0;i<128;i++)
                send_one_byte(*pIn++);
            size -= 128;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
       }
        else if(size >= 64)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x6<<1)));
            for(i=0;i<64;i++)
                send_one_byte(*pIn++);
            size -= 64;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
            if(byte < size)
                return ERROR;
        }
        else if(size >= 32)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x5<<1)));
            for(i=0;i<32;i++)
                send_one_byte(*pIn++);
            size -= 32;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
            if(byte < size)
                return ERROR;
        }
        else if(size >= 16)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x4<<1)));
            for(i=0;i<16;i++)
                send_one_byte(*pIn++);
            size -= 16;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
            if(byte < size)
                return ERROR;
        }
        else if(size >= 8)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x3<<1)));
            for(i=0;i<8;i++)
                send_one_byte(*pIn++);
            size -= 8;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
            if(byte < size)
                return ERROR;
        }
        else if(size >= 4)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x2<<1)));
            for(i=0;i<4;i++)
                send_one_byte(*pIn++);
            size -= 4;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
            if(byte < size)
                return ERROR;
        }
        else if(size >= 1)
        {
            send_one_byte(parity((char)CMD_MIDI_DATA_TRANSFER|(0x1<<1)));
            send_one_byte(*pIn++);
            size -= 1;
            if(receive_one_byte(&byte) != OK)
                return ERROR;
            if(byte < size)
                return ERROR;
        }


    }
	return OK;
}

int check_speech_buffer(void)
{
    char byte;
    send_one_byte((char)CMD_CHECK_SPEECH_BUF);
    if(receive_one_byte(&byte) != OK)
        return ERROR;
    return((int)(byte&0xff));
}

int check_midi_buffer(void)
{
    char byte;
    send_one_byte((char)CMD_CHECK_MIDI_BUF);
    if(receive_one_byte(&byte) != OK)
        return ERROR;
    return((int)(byte&0xff));
}