ปัญหาทั่วไป
Javacomm และ RXTX มีสิ่งต่าง ๆ เมื่อติดตั้ง ขอแนะนำอย่างยิ่งให้ติดตั้งการติดตั้งเล็กน้อยตามคำแนะนำการติดตั้ง หากคำแนะนำในการติดตั้งต้องการไฟล์ JAR หรือไลบรารีที่ใช้ร่วมกันจะต้องอยู่ภายใต้โฟลเดอร์เฉพาะซึ่งหมายความว่าจะต้องดำเนินการอย่างจริงจัง หากไฟล์หรืออุปกรณ์เฉพาะจำเป็นต้องมีความเป็นเจ้าของหรือสิทธิ์ในการเข้าถึงที่เฉพาะเจาะจงก็หมายความว่าจำเป็นต้องได้รับการจัดการอย่างจริงจัง ปัญหาการติดตั้งจำนวนมากเกิดจากไม่เป็นไปตามข้อกำหนดของคำแนะนำการติดตั้ง
ควรสังเกตว่า Javacomm บางรุ่นจะมีคำแนะนำในการติดตั้งสองฉบับ หนึ่งใช้สำหรับ Java 1.2 และใหม่กว่าหนึ่งสำหรับรุ่น Java 1.1 การใช้คำแนะนำการติดตั้งที่ไม่ถูกต้องจะทำให้เกิดผลการติดตั้งที่ไม่สามารถใช้งานได้ ในทางกลับกันบางรุ่น/ส่วนประกอบ/แพ็คเกจของ TXTX จะมีคำอธิบายที่ไม่สมบูรณ์ ในกรณีนี้จำเป็นต้องได้รับซอร์สโค้ดที่เผยแพร่โดย RXTX ซึ่งมีคำแนะนำการติดตั้งที่สมบูรณ์
นอกจากนี้ควรสังเกตว่าโปรแกรมการติดตั้ง JDK ของ Windows จะมีเครื่องเสมือน Java สามเครื่องดังนั้นจะมีโฟลเดอร์ขยายสามโฟลเดอร์
ยิ่งไปกว่านั้นแม้แต่ JRE ที่สี่ซึ่งมีอยู่ในโครงสร้างไดเรกทอรีของ/windows Javacomm ควรติดตั้งใน JDK และ JRE สาธารณะทั้งหมดเป็นส่วนขยาย
WebStart
ชาวชวา
ปัญหาที่พบบ่อยเกี่ยวกับ Javacomm และ RXTX คือพวกเขาไม่สนับสนุนการติดตั้งผ่าน Java WebStart: Javacomm น่าอับอายเป็นเพราะคุณต้องโทรหาไฟล์ที่เรียกว่า Javax.com.properties ไปยังไดเรกทอรี JDK LIB และสิ่งนี้ไม่สามารถผ่าน Java WebStart ได้เสร็จสมบูรณ์ มันน่าผิดหวังมากที่ความต้องการไฟล์นี้คือการออกแบบที่ไม่จำเป็นใน Javacomm และนักออกแบบของ Javacomm สามารถหลีกเลี่ยงสิ่งนี้ได้อย่างง่ายดาย ซันปฏิเสธข้อผิดพลาดอย่างดื้อรั้นและพวกเขาเน้นว่ากลไกนี้เป็นสิ่งจำเป็น พวกเขากำลังพูดถึงเรื่องไร้สาระโดยเฉพาะอย่างยิ่งเมื่อพวกเขาพูดถึง Javacomm เพราะ Java มีสถาปัตยกรรมผู้ให้บริการที่เชี่ยวชาญในความตั้งใจดังกล่าวเป็นเวลานาน
มีเพียงบรรทัดเดียวในเนื้อหาของไฟล์แอตทริบิวต์นี้ซึ่งมีชื่อคลาส Java ที่ขับเคลื่อนด้วยท้องถิ่น
driver = com.sun.win.win32driver
ต่อไปนี้เป็นเทคนิคที่สามารถปรับใช้ Javacomm ผ่านเว็บเริ่มละเว้นไฟล์แอตทริบิวต์ที่ทำให้สมองเจ็บ แต่มันมีข้อบกพร่องร้ายแรงและอาจล้มเหลวเมื่อปรับใช้ Javacomm -ถ้า Sun จะสร้างเวอร์ชันใหม่
ก่อนอื่นปิดผู้จัดการรักษาความปลอดภัย โปรแกรมเมอร์ที่โง่ ๆ ของดวงอาทิตย์รู้สึกว่าการมีอยู่ของไฟล์ Javax.Comm.Comm.properties นั้นยอดเยี่ยมอีกครั้งและอีกครั้งโดยเฉพาะอย่างยิ่งเมื่อมันถูกโหลดครั้งแรก เพียงแค่ตรวจสอบว่าไฟล์มีอยู่โดยไม่มีเหตุผลอื่นหรือไม่
System.SetSecurityManager (NULL);
จากนั้นเมื่อ Javacomm API เริ่มต้นเดิมเดิม
string drivename = "com.sun.comm.win32driver";
RXTX
RXTX จำเป็นต้องเปลี่ยนความเป็นเจ้าของและการเข้าถึงที่ถูกต้องของอุปกรณ์อนุกรมในบางแพลตฟอร์ม นี่เป็นสิ่งที่ไม่สามารถทำได้ผ่าน WebStart
เมื่อโปรแกรมเริ่มต้นขึ้นคุณควรขอให้ผู้ใช้ทำการตั้งค่าที่จำเป็นในฐานะผู้ใช้ Super โดยเฉพาะอย่างยิ่ง RXTX มีอัลกอริทึมการจับคู่โหมดเพื่อตรวจสอบชื่ออุปกรณ์อนุกรม "ถูกกฎหมาย" เมื่อมีคนต้องการใช้อุปกรณ์ที่ไม่ได้มาตรฐานเช่นตัวแปลง USB-to-Serial สิ่งนี้มักจะยุ่งเหยิง กลไกนี้สามารถถูกบล็อกโดยแอตทริบิวต์ของระบบ สำหรับรายละเอียดโปรดดูคำแนะนำการติดตั้งของ RXTX
Javacomm API
การแนะนำ
API การสื่อสารแบบอนุกรมอย่างเป็นทางการของ Java คือ Javacomm API API นี้ไม่ได้เป็นส่วนหนึ่งของเวอร์ชันมาตรฐาน Java 2 ดังนั้นการใช้ API นี้จะต้องดาวน์โหลดแยกต่างหาก น่าเสียดายที่ Javacomm ไม่ได้รับความสนใจจากดวงอาทิตย์มากพอและเวลาบำรุงรักษาจริงไม่นานมาก ซันเพิ่งซ่อมแซมข้อบกพร่องที่ไม่สำคัญบางครั้ง แต่ไม่ได้ทำการบำรุงรักษาที่สำคัญบางอย่างที่หมดอายุมานาน
ส่วนนี้อธิบายการทำงานพื้นฐานของ Javacomm API ซอร์สโค้ดที่ให้มานั้นง่ายขึ้นเพื่อแสดงโฟกัสและจำเป็นต้องได้รับการปรับปรุงในแอปพลิเคชันที่ใช้งานได้จริง
ซอร์สโค้ดของบทนี้ไม่ใช่รหัสตัวอย่างที่มีอยู่เท่านั้น ตัวอย่างมากมายมีการดาวน์โหลด Javacomm ตัวอย่างเหล่านี้รวมถึงข้อมูลเพิ่มเติมเกี่ยวกับวิธีการใช้งานมากกว่าเอกสาร API น่าเสียดายที่ซันไม่มีการสอนจริงหรือเอกสารคำอธิบาย ดังนั้นเพื่อให้เข้าใจถึงกลไกของ API นี้การเรียนรู้ตัวอย่างเหล่านี้คุ้มค่าและคุณยังต้องเรียนรู้เอกสาร API นี้ แต่วิธีที่ดีที่สุดคือการเรียนรู้ตัวอย่างเหล่านี้และใช้พวกเขา เนื่องจากการขาดแอพพลิเคชั่นที่ใช้งานง่ายและความเข้าใจในรูปแบบการเขียนโปรแกรมของ API เหล่านี้จึงมักจะถูกโจมตี เมื่อเทียบกับชื่อเสียงและฟังก์ชั่น API นี้ดีกว่า แต่นั่นเป็นเพียง
API ใช้กลไกการโทรกลับเพื่อแจ้งข้อมูลใหม่ของโปรแกรมเมอร์ นี่เป็นความคิดที่ดีที่จะเรียนรู้กลไกนี้แทนที่จะพึ่งพาพอร์ตการสอบถาม ซึ่งแตกต่างจากอินเทอร์เฟซการโทรกลับอื่น ๆ ใน Java (เช่น: ในอินเตอร์เฟสกราฟิก) อินเตอร์เฟสนี้อนุญาตให้ฟังเพียงจอเดียวเท่านั้น หากผู้ฟังหลายคนร้องขอเหตุการณ์ไม่กี่เหตุการณ์อุปกรณ์ตรวจสอบหลักจะต้องดำเนินการโดยการแจกจ่ายข้อมูลไปยังผู้ฟังรองอื่น ๆ
ดาวน์โหลดและติดตั้ง
การดาวน์โหลด
หน้าเว็บ Javacomm ของ Sun ชี้ไปที่ที่อยู่ดาวน์โหลด ภายใต้ที่อยู่นี้ Sun ปัจจุบัน (2007) จัดเตรียมเวอร์ชัน Javacom 3.0 ที่รองรับ Solaris/SPARC, Solaris/X86 ได้มี Linux X86 อยู่แล้ว การดาวน์โหลดต้องมีบัญชีของ บริษัท ซัน หน้าดาวน์โหลดมีลิงค์ไปยังหน้าลงทะเบียน วัตถุประสงค์ของการลงทะเบียนไม่ชัดเจน เมื่อลงทะเบียนผู้ใช้สามารถดาวน์โหลด JDK และ JRES ได้ แต่สำหรับ Javacomm เกือบเล็กน้อย บริษัท Sun ได้เสนอบทบัญญัติทางกฎหมายและข้อ จำกัด ของรัฐบาลเกี่ยวกับการจัดจำหน่ายซอฟต์แวร์และการส่งออก
อย่างเป็นทางการไม่ได้ให้ Javacomm เวอร์ชัน Windows อีกต่อไปและ Sun ได้ละเมิดกลยุทธ์การตายของผลิตภัณฑ์ของตัวเอง -ไม่สามารถดาวน์โหลดได้ในผลิตภัณฑ์ Java แต่คุณยังสามารถดาวน์โหลดเวอร์ชัน Windows ของ 2.0 ได้จากสิ่งนี้ (Javacom 2.0)
ติดตั้ง
การติดตั้งพร้อมคำแนะนำการติดตั้งพร้อมดาวน์โหลด Javacomm 2.0 บางรุ่นจะมีคำแนะนำในการติดตั้งสองคำแนะนำ ความแตกต่างที่ชัดเจนที่สุดระหว่างคำอธิบายทั้งสองนี้คือสิ่งที่ผิดถูกใช้ในสภาพแวดล้อม Java1.1 โบราณและสิ่งที่เหมาะสมสำหรับ Java 1.2 (JDK1.2.html) นั้นถูกต้อง
ผู้ใช้ Windows อาจไม่ทราบว่าพวกเขาได้ติดตั้งสำเนาของ VM เดียวกันในสถานที่ต่าง ๆ (โดยปกติ 3 ถึง 4) แอปพลิเคชั่น IDE และ Java บางตัวอาจนำ JRE/JDK ส่วนตัวของตัวเองมาด้วย ดังนั้น Javacomm จำเป็นต้องติดตั้งซ้ำไปยัง VM (JDK และ JRE) เหล่านี้เพื่อพัฒนาและดำเนินการแอปพลิเคชันอนุกรม
IDE มีวิธีการเป็นตัวแทนของ IDE ในการเรียนรู้ห้องสมุดใหม่ (ชั้นเรียนและเอกสาร) โดยปกติแล้วห้องสมุดที่ Javacomm ไม่เพียง แต่จำเป็นต้องระบุโดย IDE เท่านั้น แต่ยังควรระบุแต่ละโครงการที่ใช้ห้องสมุดด้วย การอ่านเอกสาร IDE คุณควรให้ความสนใจกับรุ่นเก่าของ JavaMomm 2.0 และเอกสาร Javadoc API ใช้รูปแบบ Java 1.0 Java Doc IDE ที่ทันสมัยบางอย่างไม่ทราบโครงสร้างเหล่านี้อีกต่อไปและไม่สามารถรวมเอกสาร JavaComm2.0 เข้ากับระบบความช่วยเหลือของพวกเขาได้อีกต่อไป ในกรณีนี้จำเป็นต้องใช้เบราว์เซอร์ภายนอกเพื่ออ่านเอกสาร (กิจกรรมที่แนะนำ)
เมื่อติดตั้งซอฟต์แวร์แนะนำให้ทดสอบตัวอย่างและไดเรกทอรี Javadoc มันสมเหตุสมผลที่จะสร้างและเรียกใช้แอปพลิเคชันตัวอย่างเพื่อยืนยันว่าการติดตั้งนั้นถูกต้องหรือไม่ โปรแกรมตัวอย่างมักจะต้องมีการปรับเล็กน้อยเพื่อทำงานบนแพลตฟอร์มพิเศษ (เช่นตัวระบุพอร์ต COM ที่เขียนรหัสยากใหม่) เมื่อเรียกใช้โปรแกรมตัวอย่างที่ดีที่สุดคือมีฮาร์ดแวร์อนุกรมบางอย่าง
serial_programming: การเชื่อมต่อ RS-232 และ serial_programming: โมเด็มและคำสั่งให้ข้อมูลบางอย่างเกี่ยวกับวิธีการสร้างสภาพแวดล้อมการพัฒนาแอปพลิเคชันอนุกรม
ค้นหาพอร์ตอนุกรมที่คาดไว้
สามสิ่งแรกที่ต้องทำเมื่อใช้การเขียนโปรแกรมอนุกรม Javacomm
โลโก้พอร์ตของการแจงนับและความคาดหวังการเลือกจะเสร็จสมบูรณ์ในรอบเดียวกัน:
นำเข้า Javax.Comm.*; ในฐานะ "com1" ... "comx" เช่นกันและไม่ใช่ // โดยชื่ออุปกรณ์ Unix ของพวกเขา "/dev/tty ... " ทำให้ผู้ใช้กำหนดค่าได้//string wantedname = "/dev/ttya"; ตัวระบุ if // (a) มันหมายถึงพอร์ตอนุกรม (ไม่ใช่คู่ขนาน) และ // (b) ตรงกับชื่อการออกแบบ //CommportIdentifier portid = null; POMMPTIONIDIFIER PID = (commptionidifier) portablentifiers.nextelement (); ) {System.err.println ("ไม่พบพอร์ตอนุกรม" + WantedPortName); รายการโลโก้อนุกรมที่เข้าถึงได้เริ่มต้นในไดรเวอร์ที่เกี่ยวข้องกับแพลตฟอร์มเฉพาะที่ถูกผูกไว้ รายการนี้ไม่สามารถกำหนดค่าได้จริงผ่าน Javacomm วิธีการ commptidifier.addportname () ทำให้เข้าใจผิดเนื่องจากคลาสไดรเวอร์เกี่ยวข้องกับแพลตฟอร์มและการใช้งานของพวกเขาไม่ได้เป็นส่วนหนึ่งของ API สาธารณะ พึ่งพาไดรเวอร์รายการพอร์ตนี้อาจกำหนดค่า/ขยายในไดรเวอร์ ดังนั้นหาก Javacomm ไม่พบพอร์ตบางอย่างการเปลี่ยนแปลงบางอย่างของไดรเวอร์จะช่วยได้ เมื่อพบตัวระบุพอร์ตบางตัวแล้วคุณสามารถใช้เพื่อรับพอร์ตที่คาดหวัง: ////////////////////////////////0 0 ใช้ตัวระบุพอร์ต สำหรับบัญชี // port serialport = null; e);
การเริ่มต้นพอร์ตอนุกรม
การเริ่มต้นของพอร์ตอนุกรมนั้นใช้งานง่ายมาก คุณสามารถตั้งค่าพารามิเตอร์การสื่อสาร (อัตราพอตเตอร์บิตข้อมูลบิตหยุดและการตรวจสอบหุ่นกระบอก) ทีละคน
เป็นส่วนหนึ่งของการเริ่มต้นกระแสอินพุตและเอาต์พุตของการสื่อสารสามารถกำหนดค่าได้ในตัวอย่างต่อไปนี้
นำเข้า java.io.*; ... /////ตั้งค่าพารามิเตอร์ทั้งหมด ; NULL; Tenput Stream: Write- only "); ระบบ Linux ใหม่ใช้ Unicode ดังนั้นจึงอาจเป็นความต้องการที่จะ // ระบุรูปแบบการเข้ารหัสที่จะใช้) หรือ ISO Latin 1 (8 บิต // การสื่อสาร) เนื่องจากไม่มีแนวโน้มที่จะไม่มี แบบจำลองการยอมรับ // unicode สำหรับการกระทำของมัน เกิดขึ้นที่นี่ // performreadwriteCode (); พอร์ต
การส่งข้อมูลอย่างง่ายเพียงแค่เขียนข้อมูล
การเขียนข้อมูลลงในพอร์ตอนุกรมนั้นง่ายเหมือน Java IO พื้นฐาน แต่ยังมีข้อควรระวังบางอย่างเมื่อคุณใช้ AT Hayes Protocol:
คลิปบอร์ด
สิ่งที่ต้องทำ:
อธิบายวิธีผสมอินพุตและเอาต์พุตของไบนารีและอักขระในสตรีมเดียวกัน
แก้ไขโปรแกรมตัวอย่างเพื่อใช้การไหล
// เขียนไปยัง OS.PRINT ("AT"); OS.PRINT ("/R/N"); คำสั่งที่คุณส่งไปการอ่านข้อมูลอย่างง่าย (การหมุน)
หากคุณใช้การดำเนินการเขียนอย่างถูกต้อง (ตามที่อธิบายไว้ข้างต้น) คุณต้องใช้คำสั่งง่ายๆเท่านั้น
// อ่านคำตอบการตอบสนอง = is.readline ();
คำถามการอ่านและการเขียนง่ายๆ
การอ่านและการเขียนแบบอนุกรมที่เรียบง่ายแสดงให้เห็นในส่วนก่อนหน้ามีข้อบกพร่องที่ร้ายแรงมาก การดำเนินการทั้งหมดทำได้โดยการปิดกั้น I/O ซึ่งหมายความว่าเมื่อไม่มีข้อมูลที่อ่านได้หรือบัฟเฟอร์เอาต์พุตเต็ม (อุปกรณ์ไม่สามารถยอมรับข้อมูลเพิ่มเติมได้):
วิธีการอ่านและการเขียน (ในตัวอย่างก่อนหน้าคือ OS.print () หรือ IS.ReadLine ()) จะไม่กลับมาทำให้แอปพลิเคชันถูกระงับ แม่นยำยิ่งขึ้นเธรดการอ่านและการเขียนจะถูกบล็อก หากเธรดนั้นเป็นเธรดหลักของแอปพลิเคชันแอปพลิเคชันจะหยุดจนกว่าเงื่อนไขการปิดกั้นจะถูกปล่อยออกมา (นั่นคือข้อมูลที่อ่านได้เพื่อเข้าถึงหรืออุปกรณ์ได้รับการตอบกลับอีกครั้ง)
หากแอปพลิเคชันเป็นแอปพลิเคชันดั้งเดิมที่สุดโปรแกรมจะถูกบล็อก ตัวอย่างเช่นอย่างน้อยก็จะต้องอนุญาตให้ผู้ใช้ยกเลิกการดำเนินการสื่อสาร สิ่งนี้ต้องการการใช้ I/O ที่ไม่ปิดกั้นหรือ I/O แบบอะซิงโครนัส อย่างไรก็ตาม Javacomm ขึ้นอยู่กับระบบ I/O มาตรฐาน (InputStream, OutputStream) แต่สามารถใช้เทคนิคการเสียรูปที่แสดงในภายหลัง
"เทคนิคการเสียรูป" ที่เรียกว่าการสนับสนุนที่ จำกัด โดย Javacomm ให้กับ I/O แบบอะซิงโครนัสผ่านกลไกการแจ้งเตือนเหตุการณ์ อย่างไรก็ตามโซลูชั่นทั่วไปที่จะตระหนักถึง I/O ที่ไม่ปิดกั้นใน Java เพื่อบล็อก I/O คือเธรด วิธีนี้สำหรับการดำเนินการเขียนพอร์ตอนุกรมนี้เป็นไปได้และเป็นไปได้
การดำเนินการอ่านควรประมวลผลในเธรดแยกต่างหาก แต่ไม่จำเป็นต้องใช้กลไกการแจ้งเตือนเหตุการณ์ Javacomm สรุป:
อ่านการดำเนินการและใช้การแจ้งเตือนเหตุการณ์และ/หรือแยกเธรด
ใช้เธรดแยกต่างหากเพื่อเขียนการดำเนินการและสามารถเลือกกลไกการแจ้งเตือนเหตุการณ์ได้
ส่วนถัดไปจะแนะนำรายละเอียดอื่น ๆ
กิจกรรมการแนะนำการสื่อสารแบบอนุกรม
Javacomm API จัดเตรียมกลไกการแจ้งเตือนเหตุการณ์เพื่อเอาชนะปัญหาที่เกิดจากการปิดกั้น I/O แต่กลไกนี้ก็เป็นปัญหาในวิธีการของดวงอาทิตย์ทั่วไป
โดยหลักการแล้วแอปพลิเคชันสามารถลงทะเบียนการตรวจสอบเหตุการณ์ไปยังพอร์ตอนุกรมเฉพาะเพื่อรับการแจ้งเตือนเพื่อรับเหตุการณ์สำคัญในพอร์ตนี้ สองเหตุการณ์ที่น่าสนใจที่สุดในการอ่านและการเขียนข้อมูลคือ
javax.Comm.serialportevent.data_availeable และ Javax.Comm.serialportEvent.Output_buffer_empty
แต่สิ่งนี้ยังนำคำถามสองข้อ:
ก่อนที่จะทำการอภิปรายอย่างละเอียดส่วนถัดไปจะแสดงให้เห็นถึงวิธีการหลักในการดำเนินการและลงทะเบียนโปรเซสเซอร์เหตุการณ์อนุกรม โปรดจำไว้ว่ามีโปรเซสเซอร์เหตุการณ์เดียวในพอร์ตอนุกรมและต้องจัดการกับเหตุการณ์ที่เป็นไปได้ทั้งหมด
ตั้งค่าโปรเซสเซอร์เหตุการณ์อนุกรม
นำเข้า Javax.Comm ข้อมูล * เกี่ยวกับการสื่อสารเช่นเมื่อต้องมีการติดตามโปรโตคอล * โดยเฉพาะ เมธอด Event.getEventType ()) {case serialportevent.output_empty: outputBuferEmpty (เหตุการณ์); BREAK; BREAK; / ** * จัดการเหตุการณ์ว่างเปล่าออกมา / ใช้ข้อมูล WU ที่นี่}/ ** * จัดการเหตุการณ์ที่มีอยู่ เมื่อผู้ฟังถูกนำไปใช้แล้วจะสามารถใช้ในการตรวจสอบเหตุการณ์อนุกรมที่เฉพาะเจาะจง ในการทำเช่นนั้นคุณต้องเพิ่มอินสแตนซ์ของการฟังพอร์ตอนุกรม นอกจากนี้การรับแต่ละประเภทเหตุการณ์ต้องใช้แอปพลิเคชันแยกต่างหาก
พอร์ต serialport = ... ; ... /////กำหนดค่าพารามิเตอร์พอร์ตที่นี่ ภาพอินเทอร์เฟซ ServiceVentListener // หนึ่งจะโทร ///port.addeventristener (สิ่งนี้); e); ;
การเขียนข้อมูล
การเขียนข้อมูลด้วยการแยกแยกต่างหากมีวัตถุประสงค์เพียงจุดเดียว: เพื่อหลีกเลี่ยงบล็อกแอปพลิเคชันทั้งหมดที่ถูกล็อคเนื่องจากพอร์ตอนุกรมยังไม่พร้อมที่จะเขียนข้อมูล
การรับรู้บัฟเฟอร์วงแหวนที่เรียบง่ายเธรด
ใช้เธรดที่เป็นอิสระจาก Programline หลักในการเขียนการดำเนินการโดยระบุว่าข้อมูลที่ต้องเขียนในบางวิธีจะถูกส่งไปยังเธรดการเขียนจากเธรดแอปพลิเคชันหลัก (เธรดหลัก) สิ่งนี้สามารถใช้บัฟเฟอร์เหตุการณ์แบบอะซิงโครนัสที่ใช้ร่วมกันเช่นอาร์เรย์ไบต์ นอกจากนี้โปรแกรมหลักยังต้องการวิธีการตรวจสอบว่าข้อมูลหรือบัฟเฟอร์ข้อมูลสามารถเขียนในบัฟเฟอร์ข้อมูลได้หรือไม่ หากบัฟเฟอร์ข้อมูลเต็มแสดงว่าพอร์ตอนุกรมยังไม่พร้อมที่จะเขียนการดำเนินการและข้อมูลที่จะส่งออกคือการเข้าคิว โปรแกรมหลักต้องสอบถามพื้นที่ว่างใหม่ที่มีอยู่ในบัฟเฟอร์ข้อมูลที่ใช้ร่วมกัน อย่างไรก็ตามในช่องว่างระหว่างโปรแกรมหลักคุณสามารถทำสิ่งอื่น ๆ ได้เช่นการอัปเดตอินเทอร์เฟซผู้ใช้ (GUI) โดยให้พรอมต์คำสั่งที่สามารถออกจากข้อมูลและอื่น ๆ
เมื่อมองแวบแรก PipedInputStream/PipedOutputStream เป็นความคิดที่ดีสำหรับการสื่อสารนี้ แต่ถ้าการไหลของท่อมีประโยชน์จริงๆดวงอาทิตย์ไม่ใช่ดวงอาทิตย์ หากไม่ได้ทำความสะอาด pipedoutstream ที่เกี่ยวข้องในเวลา PipedInputStream จะบล็อกซึ่งจะบล็อกเธรดแอปพลิเคชัน แม้ว่าคุณจะใช้เธรดอิสระคุณก็ไม่สามารถหลีกเลี่ยงได้ java.nio.pipe ยังมีปัญหาเช่นนี้ สิ่งกีดขวางนั้นเกี่ยวข้องกับแพลตฟอร์ม มันไม่ดีมากที่จะเปลี่ยน I/O แบบดั้งเดิมโดยใช้ Javacomm เป็น Nio
พื้นที่บัฟเฟอร์วงแหวนซิงโครนัสง่ายมากใช้ในบทความนี้สำหรับการส่งข้อมูลเธรด แอปพลิเคชันในโลกแห่งความเป็นจริงมีแนวโน้มที่จะใช้บัฟเฟอร์ที่ซับซ้อนมากขึ้น ตัวอย่างเช่นการรับรู้ของโลกแห่งความจริงต้องใช้บัฟเฟอร์การดำเนินการจากมุมมองของอินพุตและโฟลว์เอาท์พุท
บัฟเฟอร์แหวนดังกล่าวไม่ได้พิเศษและไม่มีแอตทริบิวต์พิเศษในการประมวลผลเธรด มันเป็นเพียงโครงสร้างข้อมูลอย่างง่ายที่ใช้ที่นี่เพื่อให้บัฟเฟอร์ข้อมูล บัฟเฟอร์ได้ถูกนำไปใช้ที่นี่เพื่อให้แน่ใจว่าการเข้าถึงโครงสร้างข้อมูลคือความปลอดภัยของเธรด
/*** บัฟเฟอร์ RAING ที่ซิงโครไนซ์*เหมาะสมกับการส่งมอบจากเธรดหนึ่งไปยังอีกเธรด ขนาดของบัฟเฟอร์ ** / ขนาด int ที่ได้รับการป้องกัน; ขนาดของ 1k Clear ();} / ** * ล้างเนื้อหาบัฟเฟอร์ เขียนทับในระหว่างการดำเนินการปกติ มัน * ไม่ถูกต้องต่อไปเมื่อข้อมูลถูกอ่านจากบัฟเฟอร์ * หรือเขียนบัฟเฟอร์ int data () {return start <= end? . ข้อมูลเป็น posses param array เก็บข้อมูลที่จะเขียน * @param อย่างเป็นทางการของข้อมูลในอาร์เรย์ * @param n จำนวนข้อมูลที่จะเขียนเริ่มต้นจาก int n) {ถ้า (n <= 0) ส่งคืน 0; -end); ถ้า (i> 0) {system.arraycopy (ข้อมูล, บัฟเฟอร์, สิ้นสุด, i); end> = เริ่มต้น? / ** * อ่านข้อมูลได้มากที่สุดจากบัฟเฟอร์ );} /** * อ่านข้อมูลมากที่สุดเท่าที่จะได้รับจากบัฟเฟอร์ / int read (ข้อมูลไบต์ [], int Office Lid: 0 = <= ปิด <data.length; ถ้า (i> 0) {system.arraycopy (บัฟเฟอร์, เริ่มต้น, ปิด, ปิด, ปิด += i; ;} i = math.min (ยังคงอยู่ท้าย> = เริ่มต้น? 0: สิ้นสุด); ;} return n -remain;}}}}}}ด้วยการใช้บัฟเฟอร์แหวนนี้คุณสามารถส่งข้อมูลจากเธรดหนึ่งไปยังเธรดอื่น แน่นอนว่าเธรดอื่น ๆ นั้นปลอดภัยและไม่บล็อก จุดสำคัญที่นี่คือเมื่อบัฟเฟอร์เต็มหรือบัฟเฟอร์ว่างเปล่าการอ่านและการเขียนข้อมูลจะไม่ทำให้เกิดการอุดตัน
ตามโครงร่างของการสาธิตโปรเซสเซอร์เหตุการณ์ของการสาธิตส่วนใน "สร้างโปรเซสเซอร์องค์กรอนุกรม" คุณสามารถใช้บัฟเฟอร์แหวนที่ใช้ร่วมกันที่แนะนำใน "บัฟเฟอร์วงแหวนที่ปลอดภัยและง่าย การใช้งาน JavaComm ทั้งหมดไม่สนับสนุนกิจกรรมนี้ดังนั้นรหัสนี้อาจไม่ถูกเรียก แต่ถ้าเป็นไปได้มันเป็นส่วนหนึ่งของการรับรองปริมาณงานที่ดีที่สุดเพราะสามารถทำให้พอร์ตอนุกรมอยู่ในสถานะของความเกียจคร้านได้เป็นเวลานาน
โครงร่างของการตรวจสอบเหตุการณ์จำเป็นต้องให้วิธีการ outputBuffrempty ()
ringbuffer databuffer = ... ; OutputBuff ON (Event SerialPortEvent) {}ตัวอย่างต่อไปนี้สันนิษฐานว่าปลายทางของข้อมูลเป็นไฟล์ เมื่อข้อมูลมาถึงมันจะถูกลบออกจากพอร์ตอนุกรมและเขียนลงในไฟล์ปลายทาง นี่เป็นเพียงมุมมองที่ละเอียดอ่อนเพราะในความเป็นจริงคุณต้องตรวจสอบโลโก้ EOF ของข้อมูลเพื่อควบคุมโมเด็ม (ปกติเรียกว่า "CAT") เป็นโหมดคำสั่ง
นำเข้า Javax.Comm. *; ... InputStream คือ = Port.GetInputStream (); ** * จัดการเหตุการณ์อนุกรม serialportevent.data_available: // // ย้ายข้อมูลที่มีอยู่ทั้งหมดไปยังไฟล์ // ลอง {int c; Catch (ioexception ex) {... } break; );}
ปรับเปลี่ยนการควบคุม demodulator
Javacomm ส่วนใหญ่มีความกังวลเกี่ยวกับการประมวลผลแบบอนุกรมและการส่งข้อมูลบนพอร์ตอนุกรม มันไม่เข้าใจหรือให้การสนับสนุนสำหรับโปรโตคอลระดับสูงเช่นคำแนะนำในการมอดูเลต Hayes และคำแนะนำการ demodulation มักจะใช้ในการควบคุมแมวระดับลูกค้า นี่ไม่ใช่งานของ Javacomm และไม่ใช่ข้อผิดพลาด
เช่นเดียวกับอุปกรณ์อนุกรมพิเศษอื่น ๆ หากคุณต้องการควบคุมแมวด้วย Javacomm คุณต้องเขียนรหัสที่จำเป็นใน Javacomm หน้า "โมเด็ม Hayes-Commposition และ AT Commands" ให้ข้อมูลพื้นฐานที่จำเป็นในการประมวลผลแมว Hayes
ระบบปฏิบัติการบางระบบเช่น Windows หรือคำสั่งควบคุม Linux เพื่อกำหนดค่าคำสั่งพิเศษหรือแบรนด์ของคำสั่งควบคุม CAT ให้มาตรฐานมากขึ้นหรือน้อยลง ตัวอย่างเช่น "ไดรเวอร์" ของแมว Windows มักจะเป็นเพียงทางเข้าที่ลงทะเบียนโดยอธิบายแมวแต่ละตัว (ไดรเวอร์จริงเป็นไดรเวอร์การมอดูเลตอนุกรมสากล) Javacomm ไม่สามารถรับข้อมูลเฉพาะของระบบปฏิบัติการดังกล่าวได้ ดังนั้นจึงต้องมีเครื่องมือ Java แยกต่างหากเพื่อให้ผู้ใช้สามารถกำหนดค่าแอปพลิเคชันสำหรับการใช้แมวแต่ละตัวหรือเพิ่มรหัสแพลตฟอร์มที่เกี่ยวข้อง (ท้องถิ่น)
RXTX
ภาพรวมและเวอร์ชัน
เนื่องจากซันไม่ได้ให้การใช้งานการอ้างอิง Javacomm สำหรับ Linux ผู้คนจึงพัฒนา RXTX สำหรับ Java และ Linux ต่อมา RXTX ถูกย้ายไปยังแพลตฟอร์มอื่น ๆ RXTX เวอร์ชันล่าสุดเป็นที่รู้จักกันว่าใช้งานมากกว่า 100 แพลตฟอร์มรวมถึง Linux, Windows, Mac OS, Solaris และระบบปฏิบัติการอื่น ๆ
RXTX สามารถใช้เป็นอิสระจาก Javacomm API หรือยังสามารถใช้เป็นบริการ Java Commum API ที่เรียกว่า หากหลังใช้แพ็คเกจบรรจุภัณฑ์ที่เรียกว่า JCL JCL และ RXTX มักจะเต็มไปด้วย Linux/Java หรือ JCL จะรวมเข้ากับรหัสอย่างสมบูรณ์ ดังนั้นก่อนที่จะดาวน์โหลดทีละตัวลองดูซีดีของซีดีการแจกจ่าย Linux
เนื่องจากการสนับสนุนที่ จำกัด ของซันและเอกสารที่ไม่เหมาะสมของ Javacomm เขาได้ละทิ้ง Javacomm API และหันไปใช้ RXTX โดยตรงแทนที่จะเป็นแพ็คเกจบรรจุภัณฑ์ JCL อย่างไรก็ตามเอกสารของ RXTX นั้นหายากมาก โดยเฉพาะอย่างยิ่งนักพัฒนา RXTX ต้องการสร้างเวอร์ชันและเนื้อหากระเป๋าของพวกเขาเป็นระเบียบ (เช่นการใช้หรือ JCL แบบรวมที่ไม่ได้ใช้) เริ่มต้นจากเวอร์ชัน 1.5 RXTX รวมคลาสทางเลือกของคลาส JavaComm สาธารณะ เนื่องจากเหตุผลทางกฎหมายพวกเขาไม่ได้อยู่ในแพ็คเกจ java.pomm แต่อยู่ภายใต้ gui.io อย่างไรก็ตามเนื้อหาบรรจุภัณฑ์ทั้งสองรุ่นที่มีอยู่นั้นแตกต่างกันมาก
ดังนั้นหากคุณต้องการตั้งโปรแกรม javacomm api ดั้งเดิม
Sun Javacomm General Edition เมื่อเขียนบทความนี้เป็นแพ็คเกจ UNIX จริง ๆ (รวมถึงการสนับสนุนระบบ UNIX ประเภทต่างๆเช่น Linux หรือ Solaris) แม้ใน Windows แพ็คเกจ UNIX นี้จะต้องใช้เพื่อให้มีการใช้งานสากลของ Java.Comm ใช้ Java เพื่อใช้ส่วนนั้นเท่านั้น แต่จะถูกละเว้นห้องสมุดท้องถิ่นของ Unix
RXTX 2.0 เพื่อให้มีผู้ให้บริการที่แตกต่างกันใน JavaComm เวอร์ชันสากลซึ่งแตกต่างจากที่อยู่ภายใต้แพ็คเกจ JavaComm อย่างไรก็ตามหากคุณต้องการแทนที่แพ็คเกจด้วย gnu.io คุณจะต้องแปลงแอปพลิเคชัน Javacomm เป็นแอปพลิเคชัน RXTX เท่านั้น
หากคุณยอมแพ้สมาชิกหนึ่งในสมาชิกหลายคนที่ทำให้ Javacomm ผิดหวังกับพฤติกรรมของการสนับสนุน Windows คุณควรถ่ายโอน JavaComm ของคุณไปที่ RXTX อย่างที่คุณเห็นด้านบนมีสองวิธีในการทำสิ่งนี้ให้เสร็จ
上面的第一项在前面已经解释，第二项也相当简单。对于需要将JavaComm应用移植到RxTx 2.1上来的人，只需要将应用源代码中所有对“java.comm”包的引用换成“gnu.io”包，如果原始的JavaComm应用编写恰当，这里就没有其他的事情需要去做。
在Unix平台上，RxTx 2.1甚至提供了工具“contrib/ChangePackage.sh”去在源代码树形结构中执行全局的替换，这样的替换在其他的平台很容易使用支持重构功能的IDE（集成开发环境）来完成。