int parse_ctc(char s[])
{
	char ctc[11];
	unsigned char i = 3, j = 0;

	while( (s[i] != '\0') && (j <= 11) ) 
	{
	
		if( (s[i] >= '0') && (s[i] <= '9') )
		{
			ctc[j++] = s[i++];
		}
		else
		{
			sendFString(ERROR_NONINT);
			sendChar(s[i]);
			sendChar('\r');
			return 0;
		}
	}
	
	ctc[j] = '\0';
	
	if(j>4)// must be < 256
	{
		sendFString(ERROR_NUMTOLARGE);
		return 0;
	}
	else
	{
		set_ctc(atoi(ctc));
	}
		
	return 1;
}

bool InterfaceAvr::sendString(QString string, QString callingClassName)
{
//	QString debugstring;

//	emit message(">>> sendString");

	// send starter
	if (sendChar(starter, callingClassName) == true)
	{
		// send 'content' of string
//		debugstring = "*";
		for (int i=0; i<string.length(); i++)
		{
			// char by char
			if (sendChar(string.at(i).toAscii(), callingClassName) == false)
			{
				return false;
			}
//			debugstring.append(string.at(i));
		}

		// send terminator
		if (sendChar(terminator, callingClassName) == true)
		{
			// success
//			debugstring.append("#");
//			emit message(debugstring);
			return true;
		}
	}

	return false;
}

//======================================================================
//	Get a header record.  If its not an empty one, open the output
//	file.
//======================================================================
static int
header(SerialPort& port)
{
    // Get a header sector (sector 0)
    sendChar(port, NAK);
    int block = getBlock(port, blockBuf);
    if (block == ERROR)
        return ERROR;
    if (block != 0) {
        exitCode = 3;
	return ERROR;
    }
    sendChar(port, ACK);

    // If its a empty header, just return
    if (blockBuf[0] == 0)
	return OK;

    // Get the number of bytes in the file
    bytesLeft = 2000000000L;
    char* ptr = blockBuf + 1 + strlen(blockBuf);
    if (*ptr)
	sscanf(ptr, "%ld", &bytesLeft);

    // Try to open the filename
    outputFile = fopen(blockBuf, "w");
    if (outputFile == NULL) {
        exitCode = 4;
	return ERROR;
    }

    printf("Receiving %s (%ld)\n", blockBuf, bytesLeft);

    return OK;
}

/* -------------------------------------------------------------------- */
void stmSendTrajectory(float elevatorTrajectory[5], float aileronTrajectory[5]) {
	
	char crc = 0;
	
	sendChar(usart_buffer_stm, 'a', &crc);		// this character initiates the transmission
	
	sendChar(usart_buffer_stm, 1 + 5*4 + 5*4, &crc);	// this will be the size of the message
	sendChar(usart_buffer_stm, 't', &crc);		// id of the message
	
	int i;
	
	// send the elevator trajectory
	for (i = 0; i < 5; i++) {
		
		sendFloat(usart_buffer_stm, elevatorTrajectory[i], &crc);	
	}
	
	// send the aileron trajectory
	for (i = 0; i < 5; i++) {
		
		sendFloat(usart_buffer_stm, aileronTrajectory[i], &crc);
	}
	
	// at last send the crc, ends the transmission
	sendChar(usart_buffer_stm, crc, &crc);	
}

void TxUART::sendNumber(unsigned int sendMe){
	sendChar(((sendMe / 10000)%10)+48);
	sendChar(((sendMe / 1000)%10)+48);
	sendChar(((sendMe / 100)%10)+48);
	sendChar(((sendMe / 10)%10)+48);
	sendChar(((sendMe)%10)+48);
}

void muckle_over(int awardQP) {
    CharData *i;
    int reward = 0;

    for(i = character_list; i; i = i->next) {
        sendChar(i, "The quest is over.\r\n");
        REMOVE_BIT_AR(PRF_FLAGS(i), PRF_QUEST);

        if(!awardQP)
            break;

        reward = i->muckleTime/60 + (i->muckleTime % 60 > 0 ? 1:0);
        if(i->muckleTime == muckle_duration * 60)
            reward += 2;

        if(!IS_NPC(i) && reward) {
            sendChar(i, "You have been awarded %d quest points for your effort.\r\n", reward);
            GET_QP(i) += reward;
            mudlog(BRF, LVL_IMMORT, TRUE, "%s has received %d quest points for %s efforts in muckle.",
                    GET_NAME(i), reward, HSHR(i));
        }
        
        i->muckleTime = 0;
    }

    CONFIG_QUEST_ACTIVE = 0;
}

void ansi_me(void)
{
	// ANSI turn off all attribute: me=\E[0m
	sendChar(27);
	sendChar('[');
	sendChar('0');
	sendChar('m');
}

void TiBasicEditor::sendKey(SDL_keysym k1)
{
    SDLKey k=k1.sym;
    if (keyParser::isChar(k1))
    {
        sendChar(keyParser::getChar(k1));
        return;
    }

    if (_isInSpecialCommandsMenu)
    {
        switch (k)
        {
        case SDLK_RETURN:
           sendChar( _specialsCommandsMenu->getSelectedString()[0]);
            _isInSpecialCommandsMenu=false;
            reDisplay();
            return;
        case SDLK_DELETE:
            _isInSpecialCommandsMenu=false;
            reDisplay();
            return;
        default:
            _specialsCommandsMenu->sendKey(k1);
        }
    }
    else
    {
        switch (k)
        {
        case SDLK_DELETE:
            rmChar();
            break;
        case SDLK_UP:
            changeLine(true);
            break;
        case SDLK_DOWN:
            changeLine(false);
            break;
        case SDLK_LEFT:
            changeCursorPos(true);
            break;
        case SDLK_RIGHT:
            changeCursorPos(false);
            break;
        case SDLK_RETURN:
            addLine();
            break;
        case SDLK_LALT:
            _isInSpecialCommandsMenu=true;
            _specialsCommandsMenu->reDisplay();
            break;
        }
    }
}

void menu ( void )
{
    sendChar ( '\r' );
    sendString ( "Menu\r" );
    sendString ( "a. Add\r" );
    sendString ( "b. Sub\r" );
    sendString ( "c. Mult\r" );
    sendString ( "d. Integer division\r" );
    sendString ( "e. Decimal division\r" );
    sendChar ( '\r' );
}

//======================================================================
//	Get a whole block.  Handles checksums, ...
//======================================================================
static int
getBlock(SerialPort& port, char* block)
{
    int checksum;
    int ch;
    int blockNum;

    for (int errorCnt = 0; errorCnt < RETRY_MAX; errorCnt++) {
	ch = recvChar(port, 2);
	if (ch == EOT) {
	    sendChar(port, ACK);
	    return GOT_EOT;
	}

	if (ch == CAN) {
	    exitCode = 7;
	    return ERROR;
	}

	if (ch == SOH || ch == STX) {
	    if (ch == SOH)
	        blockLen = 128;
	    else
	        blockLen = 1024;

	    blockNum = recvChar(port, 2);
	    ch = recvChar(port, 2);
	    if (blockNum + ch == 0377) {
		checksum = 0;
		char* p = block;
		for (int cnt = 0; cnt < blockLen; cnt++) {
		    ch = recvChar(port, 2);
		    checksum += (*p++ = ch);
		}

		ch = recvChar(port, 2);
		if (((checksum - ch) & 0377) == 0)
		    return blockNum;
		exitCode = 8;
	    }
	}

	if (ch == TIMEOUT)
	    exitCode = 9;

	flushInput(port);
	sendChar(port, NAK);
    }

    return ERROR;
}

/* -------------------------------------------------------------------- */
void stmSetKalmanPosition(float elevatorPos, float aileronPos) {
	
	char crc = 0;
	
	sendChar(usart_buffer_stm, 'a', &crc);		// this character initiates the transmission
	sendChar(usart_buffer_stm, 1 + 2*4, &crc);		// this will be the size of the message
	
	sendChar(usart_buffer_stm, '3', &crc);		// id of the message
	
	sendFloat(usart_buffer_stm, elevatorPos, &crc);
	sendFloat(usart_buffer_stm, aileronPos, &crc);

	// at last send the crc, ends the transmission
	sendChar(usart_buffer_stm, crc, &crc);
}

/* -------------------------------------------------------------------- */
void stmResetKalman(float initElevator, float initAileron) {
	
	char crc = 0;
	
	sendChar(usart_buffer_stm, 'a', &crc);		// this character initiates the transmission
	sendChar(usart_buffer_stm, 1 + 2*4, &crc);		// this will be the size of the message
				
	sendChar(usart_buffer_stm, '2', &crc);		// id of the message
	
	sendFloat(usart_buffer_stm, initElevator, &crc);
	sendFloat(usart_buffer_stm, initAileron, &crc);

	// at last send the crc, ends the transmission
	sendChar(usart_buffer_stm, crc, &crc);
}

void LCD1602::sendString (const char str[])
{
	uint8_t i;

	for(i = 0; str[i] != '\0'; i++)
		sendChar(str[i]);
}

void sendString(char* string, u8 len)
{
  u8 i;
  for (i=0;i<len;i++)
    sendChar(string[i]);

}

/* -------------------------------------------------------------------- */
void stmSendSetpoint(float elevatorSetpoint, float aileronSetpoint) {
	
	char crc = 0;
	
	sendChar(usart_buffer_stm, 'a', &crc);		// this character initiates the transmission
	
	sendChar(usart_buffer_stm, 1 + 2*4, &crc);		// this will be the size of the message
	sendChar(usart_buffer_stm, 's', &crc);		// id of the message
	
	// sends the payload
	sendFloat(usart_buffer_stm, elevatorSetpoint, &crc);
	sendFloat(usart_buffer_stm, aileronSetpoint, &crc);
	
	// at last send the crc, ends the transmission
	sendChar(usart_buffer_stm, crc, &crc);
}

/*****************************************************************************
	DISCRIPTION	: 文字列送信
	ARGUMENT	: pConsReg	= コンソールバッファ
				  pcStr		= 送信文字列
				  iLen		= 送信する文字列の長さ
	RETURN		: -
	NOTE		: 割込処理とスレッドから呼ばれるが送信バッファを操作しており
				  再入不可のため、スレッドから呼び出す場合は排他のため
				  割込禁止状態で呼ぶこと。
	UPDATED		: 2014-06-22
*****************************************************************************/
static void sendString(CONS_DRV_REG* pConsReg, char* pcStr, int iLen)
{
	int	i;
	
	for(i = 0; i < iLen; i++){
		pConsReg->pcSendBuf[pConsReg->iSendLen] = pcStr[i];
		pConsReg->iSendLen++;
	}
	
	/*
		送信割込無効ならば、送信開始されていないので送信開始する。
		送信割込有効ならば、送信開始されており、送信割込の延長で
		送信バッファ内のデータが順次送信されるので、何もしなくて良い。
	*/
	if(pConsReg->iSendLen != 0){	/* 送信サイズが0でない */
		/* 割込無効である */
		if(srlIntrIsSendEnable(pConsReg->iIdx) == FALSE){
			srlIntrSetSendEnable(pConsReg->iIdx);
			/*
				送信割込を有効化して先頭の1文字を出力する。
				後続の文字は、送信完了後に送信割込の延長で
				送信される。
			*/
			sendChar(pConsReg);
		}
	}
	
	return;
}

/**
 * Clear the display and print the character c at (0,0)
 * @param c Character to be printed
 */
void LCD5110::printChar(byte c){

  clearScreen();
  setOrigin();
  sendChar(c);

}

task main()
{
  // Setup the two UART ports

  //configureSerialPort(uartOne, uartUserControl);
  //configureSerialPort(uartTwo, uartUserControl);
  setBaudRate(uartOne, baudRate115200);
  setBaudRate(uartTwo, baudRate115200);

  while (getChar(uartTwo) != -1) // Purge existing chars from buffer
  {}

  StartTask(UARTReceive);

  while (true)
  {
    // Loop forever transmitting the characters 0, 1, 2, ..., 255, 0, 1, 2, ....

    for (int i = 0; i < 20; ++i)
    {
      ++nTotalXmitChars;
	    xmitChar = nTotalXmitChars % 256;
	    sendChar(uartOne, xmitChar);
	  }

    while (!bXmitComplete(uartOne))
    {
      wait1Msec(1);
    }
  }
}

void TarryTown::p_sendText(QScriptValue target,QString text) {
    int i;
    for (i = 0; i < text.length(); i++) {
        QChar c = text.at(i);
        sendChar(c.toAscii());
    }
}

bool handleLayer1SpecialCases(KBDLLHOOKSTRUCT keyInfo)
{
	switch(keyInfo.scanCode) {
		case 13:
			sendChar(L'`', keyInfo);
			keybd_event(VK_SPACE, 0, 0, 0); 
			return true;
		case 27:
			sendChar(L'´', keyInfo);
			keybd_event(VK_SPACE, 0, 0, 0); 
			return true;
		default:
			return false;
	}	

}