Arduino Serial.println将在android文本框中发送

你好！我真的不知道如何提出正确的问题，但我会尽力彻底解释情况

我正在尝试为android手机制作一个12键的键盘，我使用了arduino Atmeg168的迷你克隆版本，一个3x4键盘和一个蓝牙屏蔽，老实说，我还没有真正成功地显示所有的字母表。我正在使用一个名为Bluetooth SPP的Android应用程序来接收通过Bluetooth传输的串行数据，我想要实现的是能够放置字符或将要发送的字符发送到Android的文本框。可能吗？这是我一直在使用的代码

#include <Keypad.h>
#include <SoftwareSerial.h>
#include <ctype.h>

SoftwareSerial mySerial(2, 3);
const byte ROWS = 4; 
const byte COLS = 3; 
int digitsEntered = 0; //number of digits entered

char alphaKeys[ROWS][COLS] = {
    { '.','a','d' },
    { 'g','j','m' },
    { 'p','t','w' },
    { '*',' ','#' }
};

char alpha2Keys[ROWS][COLS] = {
    { ',','b','e' },
    { 'h','k','n' },
    { 'q','u','x' },
    { '*','s','#' }
};

char alpha3Keys[ROWS][COLS] = {
    { '?','c','f' },
    { 'i','l','o' },
    { 'r','v','y' },
    { '*','z','#' }
};

char numberKeys[ROWS][COLS] = {
    { '1','2','3' },
    { '4','5','6' },
    { '7','8','9' },
    { '*','0','#' }
};

boolean alpha = false; 
boolean alpha2 = false;
boolean alpha3 = false;


byte rowPins[ROWS] = { 5, 10, 9, 7 };
byte colPins[COLS] = {6, 4, 8 };

Keypad numpad( makeKeymap(numberKeys), rowPins, colPins, sizeof(rowPins), sizeof(colPins) );
Keypad ltrpad( makeKeymap(alphaKeys), rowPins, colPins, sizeof(rowPins), sizeof(colPins) );
Keypad ltr( makeKeymap(alpha2Keys), rowPins, colPins, sizeof(rowPins), sizeof(colPins) );
Keypad letters( makeKeymap(alpha3Keys), rowPins, colPins, sizeof(rowPins), sizeof(colPins) );


unsigned long startTime;
const byte ledPin = 13;        
const byte led = 12;
void setup() {

pinMode (4, INPUT);//Column 1
pinMode (6, INPUT);//Column 2
pinMode (8, INPUT);//Column 3
digitalWrite(4, HIGH);//Pull up resistor of Arduino
digitalWrite(6, HIGH);// Pull up resistor of Arduino
digitalWrite(8, HIGH);// Pull up resistor of Arduino

   Serial.begin(9600);
   Serial.println("Testing...."); 
   mySerial.begin(9600);
   mySerial.println("Successful!");
    pinMode(ledPin, OUTPUT);
    pinMode(led, OUTPUT);
    digitalWrite(ledPin, LOW);
    ltr.begin( makeKeymap(alpha2Keys) );
    letters.begin( makeKeymap(alpha3Keys) );
    ltrpad.begin( makeKeymap(alphaKeys) );
    numpad.begin( makeKeymap(numberKeys) );
    letters.addEventListener(keypadEvent_ltr3);
    ltr.addEventListener(keypadEvent_ltr2); 
    ltrpad.addEventListener(keypadEvent_ltr);  
    letters.setHoldTime(300);  
    ltr.setHoldTime(300);   
    ltrpad.setHoldTime(300);                   
    numpad.addEventListener(keypadEvent_num);  
    numpad.setHoldTime(300);                   
}

char key;

void loop() {

    if( alpha )
        key = ltrpad.getKey( );
    else if( alpha2 )
        key = ltr.getKey( );
    else if( alpha3 )
        key = letters.getKey( );
    else
        key = numpad.getKey( );

    if (alpha && millis()-startTime>100) {  
      digitalWrite(ledPin,!digitalRead(ledPin));
        startTime = millis();
    }
    else if (alpha2 && millis()-startTime>100) {  
      digitalWrite(ledPin,!digitalRead(ledPin));
        startTime = millis();
    }
    else if (alpha3 && millis()-startTime>100) {  
      digitalWrite(ledPin,!digitalRead(ledPin));
        startTime = millis();
    }
    if (key != NO_KEY)
{
digitsEntered++;
mySerial.begin(9600);
mySerial.print(key);
delay(100);
}
}

static char virtKey = NO_KEY;   
static char physKey = NO_KEY;
static char buildStr[12];
static byte buildCount;
static byte pressCount;

static byte kpadState;


void keypadEvent_ltr(KeypadEvent key) {
    kpadState = ltrpad.getState( );
    swOnState( key );
}
void keypadEvent_ltr2(KeypadEvent key) {
    kpadState = ltr.getState( );
    swOnState( key );
} 
void keypadEvent_num( KeypadEvent key ) {
    kpadState = numpad.getState( );
    swOnState( key );
}

void keypadEvent_ltr3(KeypadEvent key) {
    kpadState = letters.getState( );
    swOnState( key );
} 

void swOnState( char key ) {
    switch( kpadState ) {
        case PRESSED:
            if (isalpha(key)) {             
                if (physKey != key) {        
                    pressCount = 0;
                    virtKey = key;
                    physKey = key;
                }
                else {                       
                    virtKey++;                   
                    pressCount++;                
                }
                    if (pressCount > 2) {    
                        pressCount = 0;
                        virtKey = key;
                    }
                    Serial.print(virtKey);   
                }

                if (isdigit(key) || key == ' ' || key == '.')
                    Serial.print(key);
                if (key == '#')
                    Serial.println();

        case HOLD:
            if (key == '#')  {               
                if (alpha == true)  {        
                    alpha = false;           
                    digitalWrite(ledPin, LOW);
                    digitalWrite(led, LOW);
                }
                else  {                      
                    alpha = true;            
                }

            }
            else if (key == '*')  {               
                if (alpha2 == true)  {        
                    alpha2 = false;           
                    digitalWrite(ledPin, HIGH);           
                    digitalWrite(led, HIGH);

                }
                else  {                      
                    alpha2 = true;            
                }

            }
            else if (key == '*')  {               
                if (alpha3 == true)  {        
                    alpha3 = false;           
                    digitalWrite(ledPin, HIGH);           
                    digitalWrite(led, HIGH);

                }
                else  {                      
                    alpha3 = true;            
                }

            }   

            else  {                          
                buildStr[buildCount++] = (isalpha(key)) ? virtKey : key;
                buildStr[buildCount] = '\0';
                Serial.println();
                Serial.println(buildStr);
            }
            break;

        case RELEASED:
            if (buildCount >= sizeof(buildStr))  buildCount = 0;  
            break;

    }  
}

#包括
#包括
#包括
软件序列mySerial（2,3）；
常量字节行=4；
常量字节COLS=3；
int digitsEntered=0//输入的位数
字符字母键[行][列]={
{'.'，a'，d'}，
{'g'，'j'，'m'}，
{'p'，'t'，'w'}，
{ '*',' ','#' }
};
字符alpha2Keys[行][列]={
{'，'，b'，e}，
{'h'，'k'，'n'}，
{'q'，'u'，'x'}，
{'*'，'s'，'#'}
};
字符alpha3Keys[行][列]={
{'？'，'c'，'f'}，
{'i'，'l'，'o'}，
{'r'，'v'，'y'}，
{'*'，'z'，'#'}
};
char numberKeys[行][COLS]={
{ '1','2','3' },
{ '4','5','6' },
{ '7','8','9' },
{ '*','0','#' }
};
布尔α=假；
布尔字母2=假；
布尔字母3=假；
字节rowPins[行]={5,10,9,7}；
字节colPins[COLS]={6,4,8}；
键盘numpad（makeKeymap（numberKeys）、行针、列针、sizeof（行针）、sizeof（列针））；
键盘ltrpad（makeyMap（字母键）、行针、列针、sizeof（行针）、sizeof（列针））；
键盘ltr（makeKeymap（alpha2Keys）、行针、列针、sizeof（行针）、sizeof（列针））；
键盘字母（makeKeymap（alpha3Keys）、rowPins、colPins、sizeof（rowPins）、sizeof（colPins））；
无符号长起始时间；
常量字节ledPin=13；
常量字节led=12；
无效设置（）{
pinMode（4，输入）；//第1列
pinMode（6，输入）；//第2列
pinMode（8，输入）；//第3列
digitalWrite（4，高）；//Arduino的上拉电阻器
digitalWrite（6，高）；//Arduino的上拉电阻器
digitalWrite（8，高）；//Arduino的上拉电阻器
Serial.begin（9600）；
Serial.println（“测试…”）；
mySerial.begin（9600）；
println（“成功！”）；
引脚模式（LED引脚，输出）；
引脚模式（led，输出）；
数字写入（ledPin，低电平）；
ltr.begin（makeKeymap（alpha2Keys））；
字母开始（makeymap（alpha3Keys））；
ltrpad.begin（makeKeymap（alphaKeys））；
numpad.begin（makeKeymap（numberKeys））；
字母。addEventListener（keypadEvent_ltr3）；
ltr.addEventListener（键盘事件\u ltr2）；
ltrpad.addEventListener（键盘事件）；
字母。设置保持时间（300）；
ltr.setHoldTime（300）；
ltrpad.setHoldTime（300）；
numpad.addEventListener（keypadEvent_num）；
numpad.setHoldTime（300）；
}
字符键；
void循环（）{
if（alpha）
key=ltrpad.getKey（）；
else if（字母2）
key=ltr.getKey（）；
else if（字母3）
key=letters.getKey（）；
其他的
key=numpad.getKey（）；
如果（alpha&&millis（）-startTime>100）{
数字写入（ledPin，！数字读取（ledPin））；
开始时间=毫秒（）；
}
如果（alpha2&&millis（）-startTime>100）{
数字写入（ledPin，！数字读取（ledPin））；
开始时间=毫秒（）；
}
如果（alpha3&&millis（）-startTime>100）{
数字写入（ledPin，！数字读取（ledPin））；
开始时间=毫秒（）；
}
如果（键！=无键）
{
数字输入++；
mySerial.begin（9600）；
mySerial.print（键）；
延迟（100）；
}
}
static char virtKey=NO_KEY；
static char physKey=NO_键；
静态charbuildstr[12]；
静态字节计数；
静态字节计数；
静态字节kpadState；
无效键盘事件（键盘事件键）{
kpadState=ltrpad.getState（）；
斯旺斯特（钥匙）；
}
无效keypadEvent_ltr2（keypadEvent键）{
kpadState=ltr.getState（）；
斯旺斯特（钥匙）；
} 
void keypadEvent_num（keypadEvent键）{
kpadState=numpad.getState（）；
斯旺斯特（钥匙）；
}
无效键盘事件\u ltr3（键盘事件键）{
kpadState=letters.getState（）；
斯旺斯特（钥匙）；
} 
void swOnState（字符键）{
开关（kpadState）{
案件已审结：
如果（isalpha（键））{
如果（physKey！=key）{
按count=0；
virtKey=key；
physKey=key；
}
否则{
virtKey++；
按Count++；
}
如果（按Count>2）{
按count=0；
virtKey=key；
}
串行打印（virtKey）；
}
如果（isdigit（键）| |键=“”| |键=“”）
串行打印（密钥）；
如果（键=='#'）
Serial.println（）；
案件审理：
如果（键=='#'）{
如果（alpha==true）{
α=假；
数字写入（ledPin，低电平）；
数字写入（led，低电平）；
}
否则{
α=真；
}
}
如果（键=='*'）{
如果（alpha2==true）{
alpha2=假；
数字写入（ledPin，高电平）；
数字写入（led，高电平）；
}
否则{
alpha2=真；
}
}
如果（键=='*'）{
如果（alpha3==true）{
alpha3=假；
数字写入（ledPin，高电平）；