คอลเลกชันของเทอร์มินัล ANSI: 10 ขั้นตอน

2024 ผู้เขียน: John Day | [email protected]. แก้ไขล่าสุด: 2024-01-30 13:04

โปรเจ็กต์นี้เริ่มต้นจากการแสดงข้อความ 80 คอลัมน์บนจอ LCD ซึ่งเหมาะสำหรับการเรียกใช้โปรแกรมประมวลผลคำที่ล้าสมัย เช่น Wordstar มีการเพิ่มจอแสดงผลอื่นๆ อีกหลากหลายขนาดตั้งแต่ 0.96 ถึง 6 นิ้ว จอแสดงผลใช้ PCB เดียวและ Arduino Sketch / Program

มีการเชื่อมต่อ RS232 แบบอนุกรมสำหรับเชื่อมต่อกับคอมพิวเตอร์และซ็อกเก็ต PS/2 สำหรับแป้นพิมพ์ จอภาพได้รับเลือกให้เป็นตัวแทนของสินค้าที่มีจำหน่ายทั่วไปในราคาที่เหมาะสม จอแสดงผลใช้ Arduino Nano, Uno หรือ Mega ทั้งนี้ขึ้นอยู่กับหน่วยความจำที่ต้องการ

ขั้นตอนที่ 1: สรุปการแสดงผล

มีจอแสดงผลต่างๆ ที่มีความละเอียด 480x320 อนุญาตให้ใช้แบบอักษร 9x5 และข้อความคอลัมน์ 80 คอลัมน์ มีบอร์ดต่างๆ ที่มีความละเอียด 320x240 พร้อมด้วยฟอนต์ขนาด 9x5 และฟอนต์ขนาด 7x3 ที่เล็กมากสำหรับใส่ข้อความ 80 คอลัมน์ นอกจากนี้ยังมีบอร์ดขนาดเล็กที่มีขนาด 160x120 และ 128x64 พิกเซล นอกจากนี้ ข้อความขนาด 20x4 และ 16x2 จะแสดง และสุดท้ายคือบอร์ดแสดงผลแฉกแฉก 12x2 สิบสี่ส่วน

จอภาพบางจอใช้ I2C บางจอเป็น SPI และสำหรับจอภาพขนาดใหญ่ บัสข้อมูล 16 บิตเพื่อความเร็วในการอัปเดตที่เร็วขึ้น

จอแสดงผลขนาดเล็กใช้ Arduino Uno บอร์ดขนาดใหญ่ต้องการหน่วยความจำมากขึ้น ดังนั้นจึงควรใช้เมก้า บอร์ดแสดงแฉกแสงดาวใช้นาโน

ณ จุดนี้ฉันอาจพูดถึงภาพถ่ายที่ไม่ยุติธรรมกับการแสดงจำนวนมาก จอแสดงผล oled สีขาวขนาดเล็กนั้นคมชัดและสว่างมาก ซึ่งทำให้กล้องโฟกัสได้ยากขึ้น และจอแสดงผล LED แบบแฉกแสงก็ดูคมชัดขึ้นมากในชีวิตจริง

ขั้นตอนที่ 2: ฮาร์ดแวร์

PCB ได้รับการออกแบบมาให้ทำงานกับจอแสดงผลได้มากที่สุดเท่าที่เป็นไปได้ ง่ายต่อการเปลี่ยนระหว่าง Mega และ Uno โดยใช้จัมเปอร์สี่ตัว มีตัวต้านทานตัวแบ่งแรงดันไฟสำหรับจอแสดงผลที่ทำงานบน 3V หมุด I2C ถูกนำออกมาเป็นกลุ่มเพื่อให้สามารถเสียบจอแสดงผลได้โดยตรง เทอร์มินัลทำงานที่ 9600 บอด และในขณะที่สามารถเพิ่มได้ แต่จอแสดงผลขนาดใหญ่จำนวนมากจะไม่วาดใหม่เร็วกว่านี้มากนัก แป้นพิมพ์ PS2 เสียบเข้ากับซ็อกเก็ต DIN6 แป้นพิมพ์ USB ยังใช้งานได้กับปลั๊กอะแดปเตอร์ราคาถูก คุณสามารถทำการทดสอบลูปแบ็คอย่างง่ายได้โดยการต่อพิน 2 และ 3 บน D9 จากนั้นอักขระที่พิมพ์บนแป้นพิมพ์จะปรากฏขึ้นบนจอแสดงผล

ในบางกรณีไม่จำเป็นต้องใช้ PCB และเป็นไปได้ที่จะทำงานด้วยโมดูลที่สร้างไว้ล่วงหน้าบนอีเบย์ เช่น อะแดปเตอร์ PS2, บอร์ดอะแดปเตอร์ RS232 และจอแสดงผลที่ต่อเข้ากับบอร์ด Arduino โดยตรง

นอกจากนี้ยังมีบอร์ดแยกต่างหากสำหรับจอแสดงผลแบบแฉกแสง - ดูในภายหลังในคำแนะนำนี้

ขั้นตอนที่ 3: ซอฟต์แวร์

ด้านล่างนี้เป็นไฟล์ชื่อ Package.txt อันที่จริงแล้วเป็นไฟล์.zip ดังนั้นให้ดาวน์โหลดและเปลี่ยนชื่อ (Instructables ไม่อนุญาตให้ใช้ไฟล์ zip) รวมเป็นร่าง / โปรแกรม Arduino และนี่เป็นโปรแกรมเดียวที่ใช้โดยจอแสดงผลทั้งหมด นอกจากนี้ยังมีไฟล์.zip ทั้งหมดสำหรับจอแสดงผลแต่ละจอ

ที่จุดเริ่มต้นของโปรแกรมคือชุดของคำสั่ง #define Uncomment หนึ่งที่สอดคล้องกับการแสดงผล ใช้เครื่องมือ/บอร์ดเพื่อเลือก Uno, Mega หรือ Nano การเปลี่ยนบอร์ดทำได้ง่ายเพียงแค่เปลี่ยนบรรทัดเดียวในโค้ด

ความท้าทายประการหนึ่งในการทำงานกับจอแสดงผลหลายจอก็คือ ดูเหมือนว่าจอภาพทั้งหมดจะต้องมีไดรเวอร์ซอฟต์แวร์ของตัวเอง ทั้งหมดนี้รวมอยู่ในแพ็คเกจ การทดสอบรวมถึงการนำแพ็คเกจและติดตั้งใหม่บนเครื่องใหม่ทั้งหมดตั้งแต่เริ่มต้น คุณยังสามารถซอร์สโค้ดจาก Github และ Adafruit และ LCDWiki มีบางกรณีที่เวอร์ชันที่ใหม่กว่าใช้งานไม่ได้ ดังนั้นเวอร์ชันที่ใช้งานได้ทั้งหมดจึงรวมอยู่ในไฟล์ zip บางครั้งมีกรณีที่ไดรเวอร์หนึ่งหยุดทำงานอีกโปรแกรมหนึ่งเนื่องจากใช้ชื่อไฟล์เดียวกันแต่คนละเวอร์ชันกัน มีคำอธิบายในความคิดเห็นที่ด้านบนของโปรแกรมแสดงวิธีการติดตั้งไดรเวอร์แต่ละตัว ส่วนใหญ่ติดตั้งจาก Arduino IDE ด้วย Sketch/Include Library/Add ZIP library ซึ่งจะนำไฟล์ zip ไปใส่ใน c:\users\computername\mydocuments\arduino\libraries

หากคุณใช้จอแสดงผลเพียงจอเดียว ก็ไม่จำเป็นต้องติดตั้งไลบรารี่เหล่านี้บางตัว อย่างน้อยที่สุด คุณต้องมีไฟล์คีย์บอร์ดสองไฟล์และอีกไฟล์หนึ่งสำหรับการแสดงผลเฉพาะ บางรายการแสดงรหัสแชร์ มีคำแนะนำโดยละเอียดเพิ่มเติมในความคิดเห็นที่ด้านบนของโปรแกรม รวมถึงการขอรับไลบรารี gfx จาก Adafruit

เนื่องจากจอแสดงผลทั้งหมดใช้สเก็ตช์ Arduino เดียวกัน การเปลี่ยนจอแสดงผลจึงเป็นเพียงการไม่แสดงข้อคิดเห็นบรรทัดใดบรรทัดหนึ่งด้านล่าง:

// การแสดงผลที่แตกต่างกัน ให้ปล่อยหนึ่งในรายการที่ไม่มีเครื่องหมายกำกับ#define DISPLAY_480X320_LCDWIKI_ILI9486 // 3.5", 480x320, ข้อความ 80x32, เมกะ, 16 บิต, เสียบเข้ากับเมกะ 36 พิน (และ 2 พินพาวเวอร์)https://www.lcdwiki.com /3.5inch_Arduino_Display-Mega2560. ช้ากว่าตัวเลือกบางตัวด้านล่างแต่ฟอนต์ที่อ่านง่ายกว่าและหน้าจอที่ใหญ่ขึ้น, การบูตเครื่อง 5 วินาที //#define DISPLAY_480X320_MCUFRIEND_ILI9486 // 3.5", 480x320, ข้อความ 80x32, mega, ฟอนต์ 5x9 เฉพาะสำหรับ mega แต่ใช้เพียง หมุด uno, กำลังไฟ, D0-D14, A0-A5, แบบอักษรที่ดีกว่าโมดูล ssd1289 40 พิน แต่ช้ากว่ามาก https://www.arduinolibraries.info/libraries/mcufriend_kbv https://github.com/adafruit/Adafruit -GFX-Library //#define DISPLAY_320X240_MCUFRIEND_ILI9341 // 2.4", 320x240, text 53x24, mega //#define DISPLAY_320X240_SSD1289_40COL // 3.5", 320x240, text 40x20, mega, UTFT library (ไม่มีแบบอักษรที่เล็กกว่า 8x12) เร็ว //#define DISPLAY_320X240_SSD1289_53COL // 3.5", 320x240, text 53x24, mega, 9x5 font, can edit font. Fast //#define DISPLAY_320X240_SSD1289_80COL // 3.5", 320x240, text 80x30, mega, 7x3 font เล็กๆ แก้ไขฟอนต์ได้, ไดรเวอร์ที่เร็วกว่าสองตัวข้างต้น, เร็วที่สุดของทั้งหมดนี้เป็นไดรฟ์ตรง 16 บิตไปยังจอแสดงผลมากกว่า spi/i2c //#define DISPLAY_160X128_ST7735 // 1.8", 160x128, ข้อความ 26x12, uno (ILI9341) SPI 128x160 //#define DISPLAY_128X64_OLED_WHITE // 0.96", 128x64, text 21x6, mega, I2C, oled white on black (ไลบรารี tft สำหรับบอร์ดนี้ บวกกับโค้ดทั้งหมดและคีย์บอร์ด ที่เก็บข้อมูลของโปรแกรมหมด แม้ว่าความต้องการ ram จะน้อยมากก็ตาม ทำงานบนเมกะ) //#define DISPLAY_20X4 // text 20x4, uno, LCD with I2C, text LCD https://www.arduino.cc/en/Reference/LiquidCrystal //#define DISPLAY_16X2 // text 16x2, uno, เสียบเข้ากับ uno ใช้พิน 4 ถึง 10 //#define DISPLAY_STARBURST // text 12x2, nano, starburst display พร้อมตัวควบคุมนาโน //#define DISPLAY_320X240_QVGA_SPI_ILI9341 / / 2.2 ", 320x240, ข้อความ 11x8, uno, แบบอักษรขนาดใหญ่, uno, สัญญาณ 3v, จอแสดงผล SPI 9 พิน ดูคำแนะนำของ Bodmer - uno https://www.instructables.com/id/Arduino-TFT-display-and-font- ไลบรารี่ / รับ zip ที่ด้านล่างและใส่ gfx และ 9341 ลงในโฟลเดอร์ไลบรารี arduino ด้วยตนเอง

ขั้นตอนที่ 4: มาตรฐาน ANSI

ANSI อนุญาตให้ใช้คำสั่งง่ายๆ เพื่อล้างหน้าจอ เลื่อนเคอร์เซอร์ไปรอบๆ และเปลี่ยนสี ในภาพถ่ายบางส่วนมีการสาธิตที่แสดงสีพื้นหน้าและพื้นหลังทั้งหมด เหล่านี้คือสีแดง สีเหลือง สีเขียว สีฟ้า สีฟ้า สีม่วงแดง สีดำ สีขาว สีเทาเข้ม สีเทาอ่อน และสีสามารถสว่างหรือสลัวได้ จึงมีสีพื้นหน้า 16 สีและพื้นหลัง 16 สี

ค่อนข้างเป็นไปได้ที่จะคิดเกี่ยวกับการเพิ่มในโหมด 'กราฟิก' ซึ่งคุณสามารถวาดภาพที่มีความละเอียดสูงขึ้นได้มากที่ระดับพิกเซลและด้วย 256 สีขึ้นไป ข้อจำกัดหลักคือหน่วยความจำภายในของ Arduino และเวลาที่ใช้ในการส่งรูปภาพลงลิงก์แบบอนุกรมที่ 9600 บอด

โค้ดต้องการหนึ่งไบต์ในการจัดเก็บอักขระ และหนึ่งไบต์ในการจัดเก็บสี (3 บิตสำหรับพื้นหน้า, 3 บิตสำหรับพื้นหลัง, หนึ่งไบต์สำหรับสว่าง/สลัว และอีกหนึ่งไบต์สำหรับตัวหนา) ดังนั้นจอแสดงผลขนาด 80x30 จะต้องใช้ 2400x2 = 4800 ไบต์ ซึ่งจะพอดีกับเมกะ แต่ไม่ใช่ Uno

ขั้นตอนที่ 5: แสดง

ด้านบนเป็นภาพถ่ายของจอแสดงผลแต่ละรายการ มีภาพถ่ายจากด้านหน้าและด้านหลังของจอแสดงผลแต่ละจอ และเป็นตัวแทนของแบรนด์ต่างๆ ที่มีอยู่ในอีเบย์หรือที่คล้ายกัน บางตัวเป็น I2C บางตัวเป็นแบบขนาน บางตัวมีฟอนต์ที่ใหญ่กว่า บางตัวสามารถแสดงคอลัมน์ได้ 80 คอลัมน์ที่เหมาะสำหรับ Wordstar และโปรแกรมประมวลผลคำแบบเก่าอื่นๆ มีรายละเอียดเพิ่มเติมในข้อความของรหัส Arduino

ขั้นตอนที่ 6: แผนผัง

ด้านล่างนี้เป็นไฟล์สองไฟล์ มีการตั้งชื่อเป็น.txt เนื่องจาก Instructables ไม่จัดการไฟล์.zip ดาวน์โหลดและเปลี่ยนชื่อเป็น.zip

มีแผนผังและเลย์เอาต์ของบอร์ดเป็นไฟล์ pdf นอกจากนี้ยังมีแพ็คเกจ Seeed PCB เหล่านี้คือดอกเกอร์เบอร์ และถ้าคุณไปที่ Seeed และอัปโหลดมัน ควรแสดง gerbers และคุณสามารถสร้าง PCB ได้ บอร์ด 14 เซ็กเมนต์มีขนาดใหญ่และมีราคาค่อนข้างสูงกว่าเล็กน้อย แต่อันที่เล็กกว่านั้นเหมาะกับรูปแบบ Seeed ที่ต้องการขนาด 10x10 ซม. ดังนั้นจึงค่อนข้างสมเหตุสมผลสำหรับบอร์ด 5 หรือ 10 บอร์ด - อันที่จริงค่าจัดส่งมากกว่าบอร์ด

สามารถใช้จอแสดงผลหลายจอได้โดยไม่ต้องใช้ PCB มีโมดูลซ็อกเก็ต PS2, ชิลด์/โมดูล RS232 ทั้งหมดที่มีใน ebay หรือคล้ายกัน จอแสดงผลบางตัวเช่น I2C สามารถใช้สายเชื่อมต่อได้ไม่กี่เส้น บางรุ่นเช่นจอแสดงผล SSD1289 มาพร้อมกับแผงอะแดปเตอร์และสามารถเสียบเข้ากับ Mega ได้โดยตรง

ขั้นตอนที่ 7: Starburst Display

จอแสดงผลแฉกแสงเป็นบอร์ดขนาดใหญ่กว่าและใช้นาโนและชิป 74xx จำนวนหนึ่งในการทำมัลติเพล็กซ์ มีการทดลองมากมายเพื่อกำหนดจำนวนจอแสดงผลที่คุณสามารถมัลติเพล็กซ์ได้ ก่อนที่มันจะสลัวเกินไปหรือแสงวูบวาบจะสังเกตเห็นได้ชัดเจนเกินไป จอแสดงผลมาจาก Futurlec https://www.futurlec.com/LEDDisp.shtml จอแสดงผล 14 ส่วนสามารถพิมพ์อักษรตัวพิมพ์เล็กและสามารถแก้ไขได้ในโค้ดหากจำเป็น เปลี่ยนชื่อไฟล์เหล่านี้จาก.txt เป็น.zip

ขั้นตอนที่ 8: การเพิ่มโค้ดสำหรับจอแสดงผลอื่นๆ

สามารถเพิ่มโค้ดสำหรับจอภาพอื่นๆ ได้ ขั้นตอนแรกคือการได้รับบางสิ่งบางอย่างเพื่อแสดง อาจเป็นพิกเซลหรือตัวอักษรก็ได้ ซึ่งส่วนใหญ่เกี่ยวข้องกับการค้นหาไดรเวอร์ ดาวน์โหลด ทดสอบ ไม่พบคอมไพล์ จากนั้นถอนการติดตั้งไดรเวอร์นั้นเพื่อไม่ให้เกิดความสับสนในภายหลัง จากนั้นจึงลองไดรเวอร์ใหม่ ขั้นตอนต่อไปคือการได้ตัวอักษรเพื่อแสดงด้วยสีที่ถูกต้อง เนื่องจากจอภาพบางจอที่เหมือนกันจริง ๆ แล้วจะทำให้สีสลับกัน โชคดีที่โดยปกติแล้วมีเพียงตัวเลขเดียวในรหัสเริ่มต้นที่จะแก้ไขปัญหานี้ได้ ขั้นตอนต่อไปคือการเขียนสองสามบรรทัดเพื่อกำหนดว่าจะใช้ uno หรือ mega ความกว้างของจอแสดงผล ความสูง ขนาดฟอนต์ หมุดแป้นพิมพ์ และไฟล์ไดรเวอร์ที่จะใช้ สิ่งเหล่านี้เริ่มต้นที่บรรทัดที่ 39 ในโค้ด และคุณสามารถคัดลอกรูปแบบของจอแสดงผลที่มีอยู่ได้

ต่อไปก็ให้ลงไปที่บรรทัด 451 แล้วใส่โค้ดเริ่มต้นลงไป นี่คือที่ที่คุณตั้งค่าสีพื้นหลังและการหมุน และเริ่มการแสดงผล

ต่อไปให้เข้าบรรทัดที่ 544 แล้วเพิ่มโค้ดเพื่อแสดงตัวอักษร ในบางกรณีนี่เป็นเพียงบรรทัดเดียว เช่น

my_lcd. Draw_Char(xPixel, yPixel, c, tftForecolor, tftBackcolor, 1, 0); // x, y, ถ่าน, ข้างหน้า, หลัง, ขนาด, โหมด

ต่อไปให้ไปที่บรรทัด 664 แล้วเพิ่มโค้ดเพื่อวาดพิกเซล อีกครั้ง บางครั้งนี่เป็นเพียงบรรทัดเดียว เช่น:

tft.drawPixel(xPixel, yPixel, tftForecolor);

สุดท้ายไปที่บรรทัด 727 และเพิ่มรหัสเพื่อวาดเส้นแนวตั้งสำหรับเคอร์เซอร์เช่น

tft.drawFastVLine(xPixel, yPixel, fontHeight, tftForecolor);

โปรแกรมจะแยกแยะสิ่งต่างๆ เช่น จำนวนหน่วยความจำที่จะจัดสรรสำหรับบัฟเฟอร์หน้าจอตามความกว้างของหน้าจอและขนาดแบบอักษร

ขั้นตอนที่ 9: การสาธิต Wordstar

ทำได้โดยใช้คอมพิวเตอร์ CP/M และมีตัวเลือกมากมายที่นี่ ฉันต้องการบางอย่างในการตั้งค่าอย่างรวดเร็ว เลยใช้การจำลองบน ESP32 (Google ESP32 CP/M) มีคอมพิวเตอร์ย้อนยุคอื่น ๆ มากมาย เช่น การจำลอง FPGA ของ Grant Searle และ RC2014 สำหรับผู้ที่ต้องการใช้ Z80 จริง คอมพิวเตอร์ย้อนยุคจำนวนมากมักจะใช้โปรแกรมเทอร์มินัลบนพีซีเป็นจอแสดงผล เช่น Teraterm การดีบักโปรเจ็กต์ ANSI จำนวนมากเกี่ยวข้องกับการรันโปรแกรมเทอร์มินัลและโปรแกรม ANSI แบบคู่ขนาน และทำให้แน่ใจว่าหน้าจอดูเหมือนกัน

ขั้นตอนที่ 10: ความคิดเพิ่มเติม

เมื่อขนาดจอแสดงผลเพิ่มขึ้น จอภาพก็จะช้าลงและช้าลง การวาดตัวละครใหม่เกี่ยวข้องกับการวาดภาพทุกพิกเซลในตัวละครนั้นใหม่ เนื่องจากจะต้องวาดสีพื้นหลังด้วย ดังนั้นทุกอย่างจะขึ้นอยู่กับความเร็วที่คุณสามารถวาดพิกเซลได้ มีการปรับแต่งบางอย่าง เช่น หากจอแสดงผลไม่สามารถตามข้อมูลที่เข้ามาได้ เพียงแค่เก็บข้อความไว้ในบัฟเฟอร์หน้าจอ แล้วทำการวาดใหม่แบบเต็มหน้าจอเมื่อไม่มีข้อความเข้ามาอีก จอแสดงผลจำนวนมากที่คุณเห็น ลดราคาแสดงภาพสวย ๆ บนหน้าจอ แต่สิ่งที่พวกเขาอาจไม่แสดงคือใช้เวลานานเท่าใดในการแสดงภาพนั้น และในบางกรณีอาจใช้เวลา 5 วินาทีขึ้นไป I2C และ SPI นั้นยอดเยี่ยมสำหรับจอภาพขนาดเล็ก แต่สิ่งที่มากกว่า 50 คอลัมน์ต้องการบัสข้อมูล 8 หรือ 16 บิต

Wordstar ค่อนข้างเทอะทะที่จะใช้ที่ 9600 บอดและ 19200 นั้นใช้งานได้มากกว่าสำหรับการเลื่อนข้อความ แต่จอแสดงผลไม่สามารถติดตามได้จริงๆ

การแสดงผลที่เร็วที่สุดที่ฉันเคยใช้คือชิป Propeller ที่มีชิป 512k ภายนอก 8 บิตสองตัว เพื่อสร้างบัสข้อมูลแบบขนาน 16 บิต แต่ละฟอนต์ถูกโหลดไว้ล่วงหน้าในแรม ใช้ชิปตัวนับจำนวน 74xx เรียงซ้อนเพื่อตอกบัตรข้อมูลลงในจอแสดงผล ซึ่งหมายความว่าไม่มีการประมวลผลภายในใด ๆ ในการดึงข้อมูลและส่งออกข้อมูลของ CPU และอัตราการรีเฟรชนั้นเร็วพอ ๆ กับชิป Propeller สามารถสลับพินได้ น่าแปลกที่จอแสดงผลสามารถติดตามสิ่งนี้ได้แม้ที่ 20Mhz ดังนั้นจึงเป็นไปได้ที่จะอัปเดตแบบเต็มหน้าจอในเวลาเพียง 30 มิลลิวินาที อัตราดังกล่าวเร็วพอที่จะเลื่อนได้อย่างราบรื่นเหมือนที่คุณเห็นบนโทรศัพท์มือถือ

ชิป Propeller มีความล้ำสมัยมากว่า 10 ปีที่แล้ว และมีตัวเลือกเพิ่มเติมในขณะนี้ รวมถึง ESP8266 และ ESP32 ที่มีแรมภายในจำนวนมาก อย่างไรก็ตาม ชิปเหล่านั้นยังไม่มีพินจำนวนมาก ดังนั้นจึงอาจมีประโยชน์ในการใช้วิธีการแบบเก่าของชิป ram ภายนอกที่โอเวอร์คล็อกไปยังจอแสดงผล

สำหรับจอแสดงผลขนาดใหญ่ อาจมีราคาถูกกว่าการใช้หน้าจอ LCD TV หรือหน้าจอ VGA และดูอีมูเลเตอร์ ANSI บางตัวที่ได้รับการเข้ารหัส เช่น ESP32 ซึ่งขับเคลื่อน VGA โดยตรง

ฉันหวังว่าคุณจะพบว่าโครงการนี้มีประโยชน์

เจมส์ ม็อกแฮม

แอดิเลด ออสเตรเลีย