प्रसंस्करण के साथ धारावाहिक संचार
सीरियल क्लास
धारावाहिक संचार का उपयोग करने के संचालन प्रसंस्करण कक्षा में परिभाषित किया गया है Serialकिसी प्रोग्राम में उनका उपयोग करने के लिए किया जाने वाला पहला ऑपरेशन (स्केच) इसे कोड में शामिल करना होगा import processing.serial.*;.
कक्षा Serial संकेतित मापदंडों के आधार पर इसमें पांच अलग-अलग कंस्ट्रक्टर हैं। एकमात्र आवश्यक पैरामीटर मूल वस्तु है (माता - पिता) जो आमतौर पर कक्षा के मुख्य प्रोग्राम (जैसे, प्रोग्राम विंडो) से मेल खाता है PApplet. जैसा कि आम तौर पर लिखा जा रहा प्रोग्राम पैरेंट होगा (द स्केच current), इस पहले अनिवार्य पैरामीटर का मान होगा this.
अन्य पांच पैरामीटर जो कंस्ट्रक्टर को दिए जा सकते हैं वे हैं ① गति, ② सीरियल पोर्ट का नाम ③ समानता प्रोटोकॉल में उपयोग किया जाता है, ④ डेटा बिट्स और ⑤ स्टॉप बिट्स। आवश्यक मूल ऑब्जेक्ट के अलावा, सबसे अधिक बार पारित पैरामीटर, पोर्ट नाम और गति हैं।
La धारावाहिक संचार गति एक पूर्णांक है (int) कि डिफ़ॉल्ट मान 9600 है यदि यह पैरामीटर कंस्ट्रक्टर को पास नहीं किया गया है।
सीरियल पोर्ट उपलब्ध हैं. सूची विधि
El बंदरगाह का नाम इसका स्वरूप सिस्टम द्वारा इस प्रकार निर्धारित किया जाता है, उदाहरण के लिए लिनक्स वितरण यह कुछ इस तरह होगा /देव/ttyS4 / देव / ttyACM3 o /देव/ट्टीयूएसबी1 (पोर्ट प्रकार के आधार पर), जबकि विंडोज़ पर यह कुछ इस तरह होगा COM12. जब तक कोई पोर्ट किसी डिवाइस के साथ भौतिक रूप से संबद्ध न हो, प्रोग्राम को आमतौर पर यह नहीं पता होगा कि किस पोर्ट का उपयोग करना है। पोर्ट का चयन करने का एक सामान्य तरीका उपलब्ध पोर्ट की एक सूची प्राप्त करना, उसे उपयोगकर्ता को दिखाना और उन्हें वह चुनने की अनुमति देना है जिसका वे उपयोग करना चाहते हैं। प्रक्रिया Serial.list() टेक्स्ट स्ट्रिंग्स का एक वेक्टर लौटाता है (String) सिस्टम पर उपलब्ध पोर्ट के नाम के साथ।
|
1
2
3
4
5
6
7
8
9
|
// Mostrar los puertos serie disponibles en el sistema
import processing.serial.*;
void setup()
{
noLoop(); // No iterar (no llama a draw periódicamente)
println(Serial.list());
}
|
लाइब्रेरी द्वारा डिफ़ॉल्ट रूप से उपयोग किया जाने वाला पोर्ट Serial विधि द्वारा लौटाए गए लोगों में से पहला है list (निश्चित रूप से COM1 विंडोज पर या /देव/ttyS0 en ग्नू / लिनक्स). बहुत सीमित संदर्भों को छोड़कर जिनमें हार्डवेयर के साथ काम किया जा रहा है वह सख्ती से ज्ञात है (जैसे कि कियोस्क मोड में एक सिस्टम), इसे आमतौर पर छोड़ा नहीं जाता है और गंतव्य पोर्ट को स्पष्ट रूप से इंगित किया जाता है।
ऊपर दिया गया स्क्रीनशॉट एक सिस्टम का आउटपुट दिखाता है ग्नू / लिनक्स जिसमें चार सीरियल पोर्ट हैं RS-232 (ट्टीएस0 a ट्टीएस3) और दो प्रकार के पांच एडाप्टर (ttyACM0 a ttyACM1 y टीटीयूएसबी0 a टीटीयूएसबी2).
सीरियल पोर्ट तक पहुंचने के लिए, उपयोगकर्ता को उस समूह से संबंधित होना चाहिए जिसके लिए सिस्टम उन्हें सामान्य रूप से असाइन करता है TTY o डायल करें. उपरोक्त छवि के स्क्रीनशॉट में आप देख सकते हैं कि सीरियल पोर्ट सूचीबद्ध हैं ls /dev/tty[ASU]* -la पेरटेनसेन अल ग्रुपो डायल करें जिन पर पढ़ने और लिखने की पहुंच की अनुमति है।
सीरियल प्रोटोकॉल पैरामीटर
La समानता धारावाहिक संचार का में व्यक्त किया गया है प्रसंस्करण एक पात्र के रूप में (char) जो मान ले सकता है: ① N (कोई नहीं) का पता नहीं लगाने के लिए समानता, ② E (भी) यह इंगित करने के लिए कि समता द्वियक सम है, ③ O (अजीब) यह इंगित करने के लिए कि समता द्वियक अजीब है, ④ M (निशान) हमेशा बनाने के लिए समता द्वियक और ⑤ S (अंतरिक्ष) हमेशा एक बनाने के लिए समता द्वियक. डिफ़ॉल्ट मान, यदि कंस्ट्रक्टर को पैरामीटर के रूप में पास नहीं किया गया है, है N (तब से समानता).
की संख्या डेटा बिट्स, जो डिफ़ॉल्ट रूप से आठ है, उन बिट्स की संख्या को इंगित करता है जो नेट डेटा पेलोड (जिसे एक वर्ण या कभी-कभी एक शब्द कहा जाता है) बनाते हैं जो फ्रेम की प्रत्येक मूल इकाई में प्रसारित होता है। डेटा बिट्स की संख्या दर्शाने वाला पैरामीटर पूर्णांक के रूप में व्यक्त किया गया है (int).
अंत में, पांचवां संभावित पैरामीटर अंतिम चिह्न की अवधि को इंगित करता है, जिसे इस प्रकार व्यक्त किया गया है स्टॉप बिट्स (स्टॉप बिट्स), जिसे एक संख्या के रूप में दर्शाया गया है तैरनेवाला स्थल (float) जो मान ले सकता है 1.0 (डिफ़ॉल्ट मान यदि पैरामीटर कंस्ट्रक्टर को पास नहीं किया गया है), 1.5एक 2.0.
सीरियल वर्ग के निर्माता
निम्नलिखित सूची पैरामीटरों के विभिन्न संयोजनों को दिखाती है जिन्हें क्लास कंस्ट्रक्टर को पास किया जा सकता है Serial:
Serial(padre)Serial(padre,puerto)Serial(padre,velocidad)Serial(padre,puerto,velocidad)Serial(padre,puerto,velocidad,paridad,bits_datos,bits_parada)
धारावाहिक संचार समाप्त करें. रोकने की विधि.
सीरियल पोर्ट जारी करने के लिए, इंस्टेंटियेट करते समय असाइन किया गया Serial, और यह कि अन्य सिस्टम एप्लिकेशन इसका उपयोग कर सकते हैं, संचार विधि के साथ समाप्त हो जाता है stop, जो पैरामीटर प्राप्त नहीं करता है।
|
1
2
3
4
5
6
7
8
9
10
|
import processing.serial.*;
Serial serie;
void setup()
{
noLoop(); // No iterar
serie=new Serial(this,“/dev/ttyUSB0”,9600); // Usar un puerto USB con un adaptador UART
serie.stop(); // Detiene las comunicaciones serie y libera el puerto ttyUSB0 para otros usos
}
|
सीरियल पोर्ट के माध्यम से डेटा भेजें. लिखने की विधि
डेटा भेजने के लिए, क्लास Serial de प्रसंस्करण पद्धति को सम्मिलित करता है write जिसके साथ ① टेक्स्ट स्ट्रिंग्स प्रसारित की जा सकती हैं (String), ② बाइट्स या ③ बाइट वैक्टर (byte[]). यह याद रखना दिलचस्प है byte en प्रसंस्करण (कम जावा) -128 और 127 के बीच एक पूर्णांक का प्रतिनिधित्व करता है और, डिफ़ॉल्ट रूप से, स्ट्रिंग एन्कोडिंग का उपयोग करते हैं utf-16.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
import processing.serial.*;
Serial serie;
String texto=“Ohm”;
void setup()
{
noLoop();
serie=new Serial(this,“/dev/ttyUSB0”,9600); // Usar un puerto USB con un adaptador UART
serie.write(texto); // Envía el texto “Ohm”
serie.write(10); // Envía un fin de línea \n que corresponde con el ASCII 10
serie.write(200); // Envía el valor -56 ¡Es un byte, va de -128 a 127! (200-256=-56)
serie.stop(); // Detiene las comunicaciones serie y libera el puerto ttyUSB0 para otros usos
}
|
सीरियल पोर्ट से डेटा पढ़ें
ताकि सीरियल पोर्ट के माध्यम से डेटा प्राप्त होने पर प्रोग्राम अन्य कार्य कर सके, इसमें स्टोर करना सामान्य है बफर जो डेटा आता है और उपयुक्त होने पर उसे पढ़ता है। हालाँकि आमतौर पर यह बहुत कुशल नहीं है, आप सभी उपलब्ध डेटा को लोड करने के लिए एप्लिकेशन को रोक सकते हैं; हालाँकि, सबसे आम बात यह होगी कि जानकारी आते ही उसे पढ़ें, या तो प्रत्येक पुनरावृत्ति में draw, जब एक निश्चित मात्रा उपलब्ध हो या एक विशेष कोड प्राप्त हुआ हो।
बफ़र में उपलब्ध डेटा की मात्रा. उपलब्ध विधि
यह जानने के लिए कि डेटा आ गया है या नहीं बफर शृंखला, विधि available इसमें पहले से संग्रहीत बाइट्स की संख्या लौटाता है बफर. किसी भी स्थिति में, रीड ऑपरेशंस एक विशेष मान लौटा सकते हैं (जैसे -1 o null) से डेटा लोड करने का प्रयास करते समय बफर खाली होने पर श्रृंखला.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import processing.serial.*;
Serial serie;
void setup()
{
frameRate(1); // Llama a draw una vez por segundo
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
print(“Hay “);
print(serie.available());
println(” bytes en el buffer serie”);
}
|
एक बार में एक बाइट लोड करें. पढने की विधि
कक्षा की मुख्य विधियाँ Serial जिनका उपयोग सीरियल पोर्ट द्वारा प्राप्त जानकारी को पढ़ने के लिए किया जाता है, वे "प्रकार" के होते हैं read» जो उनके बीच भिन्न होता है, मुख्य रूप से, डेटा के प्रकार से जिसमें वे प्राप्त जानकारी प्रदान करते हैं।
read सीरियल पोर्ट द्वारा प्राप्त बाइट्स को 0 और 255 के बीच मान के रूप में वितरित करने के लिए उपयोग किया जाता है। डेटा प्रकार के रूप में byte de प्रसंस्करण -128 और 127 के बीच की सीमा का प्रतिनिधित्व करता है न कि 0 और 255 के बीच, इसका उपयोग करना आवश्यक है int द्वारा लौटाई गई सीमा का प्रतिनिधित्व करने के लिए read. यदि आप साथ पढ़ने का प्रयास करते हैं read और बफर स्ट्रिंग खाली है, मान लौटाता है -1
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import processing.serial.*;
Serial serie;
void setup()
{
frameRate(10); // Llama a draw 10 veces por segundo
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
if(serie.available()>0)
{
println(serie.read());
}
}
|
सीरियल पोर्ट से अक्षर पढ़ें. रीडचार विधि
विधि readChar के समान है read लेकिन यह प्रारूप में एक मान लौटाता है char के बजाय एक int. आंतरिक रूप से, char en प्रसंस्करण (कम जावा) को दो बाइट्स के साथ संग्रहीत किया जाता है, पढ़ने पर लौटने के लिए चुना गया मान readChar द्वारा बफर खाली श्रृंखला है 0xFFFF o -1.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import processing.serial.*;
Serial serie;
void setup()
{
frameRate(10);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
if(serie.available()>0)
{
print(serie.readChar());
}
}
|
एक टेक्स्ट स्ट्रिंग लोड करें. readString और readStringUntil विधियाँ।
विधि readString एक वस्तु लौटाता है String में उपलब्ध सभी डेटा से बना है बफर परामर्श के समय श्रृंखला।
विधि readString यह मानते हुए टेक्स्ट स्ट्रिंग बनाता है कि सीरियल पोर्ट द्वारा प्राप्त बाइट्स प्रारूप में हैं ASCII इसलिए इस पढ़ने की विधि का उपयोग अन्य एन्कोडिंग के लिए नहीं किया जा सकता है।
यदि यह पढ़ने के बारे में है बफर के साथ श्रृंखला readString खाली होने पर, रिटर्न मान होता है null.
विधि readStringUntil इसमें जोड़ें readString में लोड की गई जानकारी वापस करने की क्षमता बफर श्रृंखला इसे एक विशेष वर्ण (कोड) द्वारा विभाजित करती है जिसे एक पैरामीटर के रूप में पारित किया जाता है। प्राप्त जानकारी को पढ़ने का यह तरीका हमें विभाजक और टर्मिनेटर दोनों को अलग करने की अनुमति देता है जो प्राप्त जानकारी की व्याख्या करने में मदद करते हैं।
विधि readStringUntil वापिस लाओ null जब में बफर श्रृंखला को दिए गए तर्क (एक बाइट) में निर्दिष्ट कोड नहीं मिलता है।
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import processing.serial.*;
Serial serie;
String mensaje;
void setup()
{
frameRate(5);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
if(serie.available()>1)
{
mensaje=serie.readStringUntil(9); // Lee los datos del buffer hasta encontrar un tabulador
if(mensaje!=null) // Si la respuesta no es null ya ha llegado el tabulador y el mensaje está completo
{
println(“Mensaje recibido: “+mensaje); // Mostrar el mensaje si ha llegado completo
}
}
}
|
के लिए निम्नलिखित कोड में Arduino सीरियल पोर्ट के माध्यम से तीन संदेश भेजता है। पहले दो एक टैब में समाप्त होते हैं, इसलिए वे कंसोल में दिखाई देंगे। प्रसंस्करण, जबकि तीसरा, हालांकि इसे सीरियल पोर्ट के माध्यम से भेजा जाएगा, इसके साथ पढ़ा नहीं जाएगा readStringUntil(9) चूंकि यह एक टैब (कोड के साथ) में समाप्त नहीं होता है ASCII 9)।
|
1
2
3
4
5
6
7
8
9
10
11
12
|
void setup()
{
Serial.begin(9600);
while(!Serial);
Serial.print(“Primer mensaje\t”);
Serial.print(“Segundo mensaje\t”);
Serial.print(“Tercer mensaje”); // Este mensaje no llega porque no termina en tabulador
}
void loop()
{
}
|
डेटा ब्लॉक पढ़ें. रीडबाइट्स और रीडबाइट्सअनटिल विधियाँ।
ऊपर देखी गई विधियों का उपयोग विशिष्ट प्रारूपों के साथ डेटा को पढ़ने के लिए, कच्चे डेटा के ब्लॉक को पढ़ने के लिए या किसी ऐसे प्रारूप के साथ किया जाता है जो इसमें प्रदान नहीं किया गया है प्रसंस्करण तरीकों का प्रयोग किया जाता है readBytes y readBytesUntil
विधि readBytes में उपलब्ध डेटा को पढ़ने का प्रयास करें बफर शृंखला। यदि विधि में कोई पैरामीटर पास नहीं किया गया है readBytes सभी उपलब्ध डेटा को एक वेक्टर में पढ़ा और लौटाया जाता है (byte[]). यदि एक पूर्णांक को एक पैरामीटर के रूप में पारित किया जाता है, तो इस संख्या द्वारा इंगित बाइट्स की अधिकतम संख्या पढ़ी जाती है और उन्हें एक वेक्टर के रूप में भी लौटाया जाता है।
उपयोग करने का एक तीसरा तरीका है readBytes, अधिक कुशल, जो एक तर्क के रूप में एक बाइट वेक्टर लेता है जिसमें की सामग्री बफर शृंखला। उपयोग करने का यह तरीका readBytes एक पूर्णांक लौटाता है (int) जो पढ़े गए बाइट्स की संख्या को दर्शाता है।
विधि readBytesUntil समान तरीके से काम करता है लेकिन इसमें पहला पैरामीटर शामिल होता है जो बाइट के मान का प्रतिनिधित्व करता है, यदि पाया जाता है बफर, पढ़ने के अंत का संकेत देगा। इस पद्धति में, वह पैरामीटर जो पढ़े जाने वाले बाइट्स की अधिकतम संख्या निर्धारित करता है, उसका कोई मतलब नहीं है क्योंकि मात्रा विशेष कोड द्वारा निर्धारित की जाएगी।
विधि के संचालन का परीक्षण करने के लिए readBytes आइए निम्नलिखित कोड मान लें Arduino जो सीरियल पोर्ट के माध्यम से एक टेक्स्ट भेजता है।
|
1
2
3
4
5
6
7
8
9
10
|
void setup()
{
Serial.begin(9600);
while(!Serial);
Serial.println(“En Viena hay diez muchachas, un hombro donde solloza la muerte y un bosque de palomas disecadas. Hay un fragmento de la mañana en el museo de la escarcha. Hay un salón con mil ventanas.”);
}
void loop()
{
}
|
के लिए निम्नलिखित उदाहरण कार्यक्रम प्रसंस्करण 32-बाइट ब्लॉक में सीरियल पोर्ट से टेक्स्ट पढ़ता है (कुल_बाइट्स). यह सत्यापित करने के लिए कि यह काम करता है, यह इसे कंसोल के माध्यम से वर्णों के रूप में दिखाता है, प्राप्त बाइट्स के प्रकार को मजबूर करता है char.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
import processing.serial.*;
Serial serie;
byte bloque_datos[];
static byte TOTAL_BYTES=32;
void setup()
{
frameRate(10);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
bloque_datos=new byte[TOTAL_BYTES];
}
void draw()
{
if(serie.available()>0)
{
bloque_datos=serie.readBytes(TOTAL_BYTES);
if(bloque_datos!=null)
{
for(byte numero_byte=0;numero_byte<bloque_datos.length;numero_byte++)
{
print((char)bloque_datos[numero_byte]);
}
}
}
}
|
निम्नलिखित स्क्रीनशॉट में आप देख सकते हैं कि वे कंसोल में कैसे प्रदर्शित होते हैं प्रसंस्करण वह डेटा जो (अधिकतम) 32 बाइट्स के ब्लॉक में लोड किया गया है (कुल_बाइट्स) हर बार। लेकिन एक समस्या है जिसके बारे में पहले ही बात की जा चुकी है: Arduino की कविताएँ भेजता रहा हूँ Federico Garcia Lorca उदाहरण के प्रारूप में पाठ के रूप में एन्कोड किया गया UTF-8, जिसका उपयोग नहीं किया गया है प्रसंस्करण (जावा), आप क्या करना चाहते हैं utf-16 इसलिए जो लोग रैंक के अनुरूप नहीं हैं ASCII मुद्रण योग्य की गलत व्याख्या की गई है।
इस समस्या को हल करने के लिए, वर्ण सेट लोड किया जा सकता है (चारसेट) और एक नई वस्तु को परिभाषित करें String इसे एन्कोडिंग के साथ प्रस्तुत करने के लिए बाध्य किया जा रहा है UTF-8 जैसा कि निम्नलिखित उदाहरण कोड में दिखाया गया है।
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import processing.serial.*;
import static java.nio.charset.StandardCharsets.*;
Serial serie;
byte bloque_datos[];
static byte TOTAL_BYTES=32;
void setup()
{
frameRate(10);
serie=new Serial(this,“/dev/ttyUSB0”,9600);
bloque_datos=new byte[TOTAL_BYTES];
}
void draw()
{
if(serie.available()>0)
{
bloque_datos=serie.readBytes(TOTAL_BYTES);
if(bloque_datos!=null)
{
print(new String(bloque_datos,UTF_8));
}
}
}
|
प्राप्त नवीनतम डेटा पढ़ें. अंतिम और अंतिम चार विधियाँ।
जबकि बाकी पढ़ने के तरीके ("प्रकार") read») वे की जानकारी लोड करते हैं बफर श्रृंखला उसी क्रम में है जिस क्रम में यह आई है (फीफो), इन दो तरीकों से आखिरी बाइट जो पहुंच गई है बफर शृंखला। प्रक्रिया last अंतिम बाइट का मान लौटाता है int y lastChar मान को a के रूप में लौटाता है char.
सीरियल बफ़र प्रबंधन
हालाँकि अब तक देखे गए तरीके पूरी तरह कार्यात्मक हैं, वे हमेशा सीरियल पोर्ट तक पहुंच का फायदा उठाने का सबसे अच्छा तरीका नहीं दर्शाते हैं। डेटा लोड करने के लिए, उन्हें समय-समय पर इसकी स्थिति की जांच करनी होगी बफर श्रृंखला बनाएं और कोड के दोहराए जाने वाले भाग में उपलब्ध डेटा पढ़ें। आम तौर पर अधिक प्रभावी तरीका यह है कि डेटा को केवल तभी पढ़ें जब आपको पता हो कि यह उपलब्ध है।
डेटा प्राप्त होने पर सीरियल पोर्ट पढ़ें। धारावाहिक घटना.
तक पहुँचने के लिए बफर सीरियल जब डेटा प्राप्त होता है, तो विधि परिभाषा के माध्यम से इसे प्रबंधित करके सीरियल इवेंट का फायदा उठाया जा सकता है serialEvent. यह विधि सीरियल पोर्ट का उपयोग करती है जो इसे एक तर्क के रूप में लॉन्च करती है।
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import processing.serial.*;
Serial serie;
void setup()
{
serie=new Serial(this,“/dev/ttyUSB0”,9600);
}
void draw()
{
}
void serialEvent(Serial comunicaciones)
{
print(comunicaciones.readChar());
}
|
सीरियल बफ़र को आकार दें. बफ़र विधि.
यदि आप उपयोगी डेटा के ब्लॉक को बनाने वाले बाइट्स की संख्या जानते हैं, तो आप डेटा पढ़ने की इस शैली को और अधिक अनुकूलित कर सकते हैं। बफर के माध्यम से श्रृंखला serialEvent. प्रक्रिया buffer आपको बाइट्स की संख्या निर्धारित करने की अनुमति देता है जिन्हें संग्रहीत किया जाएगा बफर एक सीरियल इवेंट लॉन्च करने से पहले। विधि एक पैरामीटर के रूप में एक पूर्णांक की अपेक्षा करती है जो बाइट्स की संख्या का प्रतिनिधित्व करती है।
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
import processing.serial.*;
Serial serie;
void setup()
{
//noLoop();
serie=new Serial(this,“/dev/ttyUSB0”,9600);
serie.buffer(32); // Esperar a recibir 32 bytes antes de lanzar el evento Serial
}
void draw()
{
}
void serialEvent(Serial comunicaciones)
{
while(comunicaciones.available()>0)
{
print(comunicaciones.readChar());
}
}
|
मान प्राप्त होने तक बफ़र भरें। बफ़रयूनटिल विधि।
विधि कॉल सेट करने के बजाय serialEvent में डेटा की मात्रा के लिए बफरविधि के साथ, bufferUntil आप एक विशेष मान आने तक डेटा संग्रहीत करने के लिए कॉन्फ़िगर कर सकते हैं और फिर सीरियल ईवेंट बढ़ा सकते हैं। इस विधि को पारित पैरामीटर है a int जो कॉल द्वारा उत्पादित मूल्य का प्रतिनिधित्व करता है serialEvent.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import processing.serial.*;
Serial serie;
void setup()
{
serie=new Serial(this,“/dev/ttyUSB0”,9600);
serie.bufferUntil(9); // Espera a recibir un tabulador (ASCII 9) antes de llamar a serialEvent
}
void draw()
{
}
void serialEvent(Serial comunicaciones)
{
println(comunicaciones.readString()); // Imprime en una línea diferente cada valor separado originalmente por tabuladores
}
|
बफ़र में संग्रहीत डेटा हटाएँ। स्पष्ट विधि.
विधि के साथ clear आप उस डेटा को हटा सकते हैं जो वर्तमान में है बफर. इस पद्धति का उपयोग किया जा सकता है, उदाहरण के लिए, पिछले डेटा से शेष डेटा को अनदेखा करते हुए एक नया डेटा रिसेप्शन सत्र शुरू करने के लिए।
सीरियल पोर्ट के माध्यम से डेटा पढ़ने के लिए विशिष्ट प्रसंस्करण अनुप्रयोग
अंत में, वस्तु के संचालन को दोबारा दोहराना सुविधाजनक है Serial de प्रसंस्करण जो आमतौर पर अधिक उपयोग किए जाते हैं, स्टैक्ड क्षेत्रों के इस मामले में, उनके साथ एक ग्राफ़ खींचने के लिए सीरियल पोर्ट के माध्यम से डेटा प्राप्त करने का एक विशिष्ट उदाहरण देखें।
सीरियल लाइब्रेरी आयात करें
|
1
|
import processing.serial.*;
|
डेटा प्रोटोकॉल (विभाजक) निर्धारित करें
|
1
2
|
static final String SEPARADOR=“\t”; // Los datos de cada sensor se separan con un tabulador
static final char TERMINADOR=10; // Cada grupo de datos se termina con un código ASCII 10 → Nueva línea → \n
|
सीरियल क्लास का ऑब्जेक्ट निर्धारित करें
|
1
|
Serial conexion_sensores;
|
उपयोग किए गए सीरियल पोर्ट को सेट करके सीरियल क्लास ऑब्जेक्ट को इंस्टेंट करें
|
1
|
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
|
सीरियल पोर्ट बफ़र कॉन्फ़िगर करें
|
1
|
conexion_sensores.bufferUntil(TERMINADOR);
|
सीरियल इवेंट के लिए एक हैंडलर लागू करें
|
1
|
void serialEvent(Serial serie)
|
सीरियल बफ़र पढ़ें
|
1
|
String[] texto_valor=serie.readString().split(SEPARADOR);
|
प्राप्त डेटा को कंडीशन करें
|
1
2
3
4
5
|
float[] valor=new float[texto_valor.length];
for(int numero_valor=0;numero_valor<texto_valor.length;numero_valor++)
{
valor[numero_valor]=parseFloat(texto_valor[numero_valor]);
}
|
धारावाहिक संचार समाप्त करें
|
1
2
|
conexion_sensores.clear();
conexion_sensores.stop();
|
नीचे दिया गया उदाहरण कोड इस सारांश को एक कार्यात्मक (यद्यपि बहुत सरल) एप्लिकेशन के साथ दिखाता है जो सीरियल पोर्ट के माध्यम से प्राप्त मूल्यों के साथ एक क्षेत्र ग्राफ उत्पन्न करता है, जो कि निम्नलिखित एनीमेशन के समान है।
कार्यक्रम के बाकी हिस्सों में खो जाने से बचने के लिए और क्रमिक संचार पर ध्यान केंद्रित करने के लिए प्रसंस्करण, कोड की पंक्तियाँ जो पिछले ऑपरेशन से मेल खाती हैं, हाइलाइट की गई हैं।
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
import processing.serial.*;
static final byte ROJO=0,VERDE=1,AZUL=2,OPACIDAD=3;
static final int CANTIDAD_SENSORES=3;
static final int CANTIDAD_VALORES=20;
static final String NOMBRE_FONDO=“fondo.png”;
static final int[][] COLOR_LINEA={{0x44,0x88,0xCC,0xFF},{0xFF,0xAA,0x00,0xFF},{0xCC,0x44,0xAA,0xFF}};
static final int[][] COLOR_AREA={{0x44,0x88,0xCC,0x88},{0xFF,0xAA,0x00,0x88},{0xCC,0x44,0xAA,0x88}};
static final int[] COLOR_FONDO={0xFF,0xFF,0XFF};
static final float GROSOR_LINEA=2.0;
static final float DIAMETRO_MARCA=8.0;
static final float VALOR_MINIMO=0.0; // Valor mínimo de la suma de todos los componentes
static final float VALOR_MAXIMO=100.0; // Valor máximo de la suma de valores
static final String SEPARADOR=“\t”; // Los datos de cada sensor se separan con un tabulador
static final char TERMINADOR=10; // Cada grupo de datos se termina con un código ASCII 10 → Nueva línea → \n
Serial conexion_sensores;
float[][] valor_sensor=new float[CANTIDAD_SENSORES][CANTIDAD_VALORES];
float coeficiente_valor;
float[] vertical_area=new float[CANTIDAD_VALORES];
float[] vertical_marca=new float[CANTIDAD_VALORES];
PImage fondo;
void setup()
{
size(792,396,P2D); // El tamaño de la ventana no se puede establecer con variables en setup (usar settings)
surface.setResizable(false);
surface.setTitle(“consumo relativo comparado”);
noLoop();
smooth(4);
conexion_sensores=new Serial(this,“/dev/ttyUSB1”,9600);
conexion_sensores.bufferUntil(TERMINADOR);
for(int numero_sensor=0;numero_sensor<CANTIDAD_SENSORES;numero_sensor++)
{
for(int numero_valor=0;numero_valor<CANTIDAD_VALORES;numero_valor++)
{
valor_sensor[numero_sensor][numero_valor]=0.0;
}
}
fondo=loadImage(NOMBRE_FONDO);
coeficiente_valor=height/(VALOR_MAXIMO–VALOR_MINIMO);
//strokeCap(ROUND); // El modo del final de líneas por defecto es redondeado
//ellipseMode(CENTER); // Por defecto el modo de elipse es desde el centro
if(DIAMETRO_MARCA>GROSOR_LINEA) // Si la marca no es visible hay que configurar el tipo de esquina
{
strokeJoin(ROUND); // El modo de esquina por defecto es en ángulo
}
}
void draw()
{
for(int numero_valor=0;numero_valor<valor_sensor[0].length;numero_valor++)
{
vertical_area[numero_valor]=height;
for(int numero_sensor=0;numero_sensor<valor_sensor.length;numero_sensor++)
{
vertical_area[numero_valor]-=(valor_sensor[numero_sensor][numero_valor]–VALOR_MINIMO)*coeficiente_valor;
}
vertical_marca[numero_valor]=vertical_area[numero_valor];
}
if(fondo==null)
{
background(COLOR_FONDO[ROJO],COLOR_FONDO[VERDE],COLOR_FONDO[AZUL]);
}
else
{
image(fondo,0,0);
}
strokeWeight(GROSOR_LINEA);
for(int numero_sensor=0;numero_sensor<valor_sensor.length;numero_sensor++)
{
stroke
(
COLOR_LINEA[numero_sensor][ROJO],
COLOR_LINEA[numero_sensor][VERDE],
COLOR_LINEA[numero_sensor][AZUL],
COLOR_LINEA[numero_sensor][OPACIDAD]
);
fill
(
COLOR_AREA[numero_sensor][ROJO],
COLOR_AREA[numero_sensor][VERDE],
COLOR_AREA[numero_sensor][AZUL],
COLOR_AREA[numero_sensor][OPACIDAD]
);
beginShape();
for(int numero_valor=valor_sensor[numero_sensor].length–1;numero_valor>=0;numero_valor—)
{
vertex(numero_valor*width/(valor_sensor[numero_sensor].length–1),vertical_area[numero_valor]);
}
for(int numero_valor=0;numero_valor<valor_sensor[numero_sensor].length;numero_valor++)
{
vertical_area[numero_valor]+=(valor_sensor[numero_sensor][numero_valor]–VALOR_MINIMO)*coeficiente_valor;
vertex(numero_valor*width/(valor_sensor[numero_sensor].length–1),vertical_area[numero_valor]);
}
endShape(CLOSE);
if(DIAMETRO_MARCA>0)
{
noStroke();
fill
(
COLOR_LINEA[numero_sensor][ROJO],
COLOR_LINEA[numero_sensor][VERDE],
COLOR_LINEA[numero_sensor][AZUL],
COLOR_LINEA[numero_sensor][OPACIDAD]
);
for(int numero_valor=0;numero_valor<valor_sensor[numero_sensor].length;numero_valor++)
{
ellipse
(
numero_valor*width/(valor_sensor[numero_sensor].length–1),
vertical_marca[numero_valor],
DIAMETRO_MARCA,
DIAMETRO_MARCA
);
vertical_marca[numero_valor]=vertical_area[numero_valor];
}
}
}
}
void stop() // Al terminar un Applet. No hay garantía de que se ejecute y, como estas operaciones se realizan al terminar, en realidad no son necesarias y solo se incluyen para recordar el uso de clear y stop
{
conexion_sensores.clear(); // Solo para ilustrar la posibilidad de borrar los datos que queden en el buffer
conexion_sensores.stop(); // Solo para ilustrar la posibilidad de terminar las comunicaciones serie y liberar el puerto que se está usando
}
void serialEvent(Serial serie)
{
String[] texto_valor=serie.readString().split(SEPARADOR);
float[] valor=new float[texto_valor.length];
for(int numero_valor=0;numero_valor<texto_valor.length;numero_valor++)
{
valor[numero_valor]=parseFloat(texto_valor[numero_valor]);
}
nuevo_valor(valor_sensor,valor);
redraw();
}
void nuevo_valor(float[][] valor_sensor, float[] valor)
{
for(int numero_sensor=0;numero_sensor<valor_sensor.length;numero_sensor++)
{
for(int numero_valor=1;numero_valor<valor_sensor[0].length;numero_valor++)
{
valor_sensor[numero_sensor][numero_valor–1]=valor_sensor[numero_sensor][numero_valor];
}
valor_sensor[numero_sensor][valor_sensor[0].length–1]=valor[numero_sensor];
}
}
|
टिप्पणी पोस्ट