จากพื้นฐาน: ฉันสร้างคีย์บอร์ดในฝันของนักพัฒนาได้อย่างไร

วันหนึ่งในเดือนสิงหาคมปี 2007 ฉันทำงานอย่างอดไม่ได้ที่จะตระหนักว่าแป้นพิมพ์ PC ปกติของฉันไม่ได้ให้บริการฉันได้มากเท่าที่จะมากได้ ฉันต้องขยับมือไปมาระหว่างบล็อกต่างๆ ของแป้นพิมพ์มากเกินไป หลายร้อยครั้งหรือหลายพันครั้งต่อวัน และมือของฉันก็อยู่ใกล้กันจนไม่สะดวก ฉันคิดว่าจะต้องมีวิธีที่ดีกว่านี้

การรับรู้นี้ตามมาด้วยความรู้สึกตื่นเต้นอย่างท่วมท้นขณะที่ฉันคิดเกี่ยวกับการปรับแต่งแป้นพิมพ์ที่ดีที่สุดสำหรับนักพัฒนา และต่อมา เมื่อตระหนักว่าในฐานะนักพัฒนาซอฟต์แวร์อิสระที่ฝังตัว ฉันไม่มีความหวังอย่างไร้ความหวังเกี่ยวกับฮาร์ดแวร์

ตอนนั้นฉันค่อนข้างยุ่งกับโปรเจ็กต์อื่น ๆ แต่ก็ไม่ถึงวันเลยที่ฉันไม่ได้คิดเกี่ยวกับการสร้างคีย์บอร์ดสำหรับแฮ็กเกอร์ ไม่นานฉันก็เริ่มอุทิศเวลาว่างให้กับการทำงานในโครงการ ฉันได้เรียนรู้ชุดทักษะใหม่ทั้งหมด ชักชวนเพื่อนของฉัน Andras Volgyi วิศวกรเครื่องกลวิสามัญให้เข้าร่วมโครงการ รวบรวมบุคคลสำคัญ และอุทิศเวลาให้เพียงพอเพื่อสร้างต้นแบบการทำงาน ทุกวันนี้ Ultimate Hacking Keyboard นั้นมีอยู่จริง เรากำลังคืบหน้าทุกวัน และการเปิดตัวแคมเปญคราวด์ฟันดิ้งของเราอยู่ไม่ไกลเกินเอื้อม

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

คุณจะทำคีย์บอร์ดได้อย่างไร?

หลังจากอุทิศชีวิตหลายพันชั่วโมงให้กับหัวข้อนี้ เป็นเรื่องยากสำหรับฉันที่จะให้คำตอบสั้นๆ แต่มีวิธีที่น่าสนใจในการตอบคำถามนี้ จะเป็นอย่างไรหากเราเริ่มต้นด้วยสิ่งง่ายๆ เช่น บอร์ด Arduino และค่อยๆ สร้างให้เป็น Ultimate Hacking Keyboard? ไม่ควรเพียงย่อยง่ายแต่ให้ความรู้อย่างยิ่ง ดังนั้น ให้การเดินทางของบทช่วยสอนเกี่ยวกับแป้นพิมพ์เริ่มต้นขึ้น!

ขั้นตอนที่หนึ่ง: คีย์บอร์ดที่ไม่มีคีย์

ขั้นแรก มาสร้างแป้นพิมพ์ USB ที่ปล่อยอักขระ x หนึ่งครั้งต่อวินาที บอร์ดพัฒนา Arduino Micro เป็นตัวเลือกในอุดมคติสำหรับจุดประสงค์นี้ เนื่องจากมีไมโครคอนโทรลเลอร์ ATmega32U4 - microcrontroller AVR และโปรเซสเซอร์เดียวกันกับสมองของ UHK

เมื่อพูดถึงไมโครคอนโทรลเลอร์ AVR ที่รองรับ USB Lightweight USB Framework สำหรับ AVR (LUFA) คือไลบรารีที่เลือกได้ ช่วยให้โปรเซสเซอร์เหล่านี้กลายเป็นสมองของเครื่องพิมพ์ อุปกรณ์ MIDI คีย์บอร์ด หรืออุปกรณ์ USB เกือบทุกชนิด

เมื่อเสียบอุปกรณ์เข้ากับพอร์ต USB อุปกรณ์จะต้องโอนโครงสร้างข้อมูลพิเศษที่เรียกว่า USB descriptors ตัวอธิบายเหล่านี้บอกโฮสต์คอมพิวเตอร์ถึงประเภทและคุณสมบัติของอุปกรณ์ที่กำลังเชื่อมต่อ และแสดงด้วยโครงสร้างแบบต้นไม้ ในการทำให้เรื่องซับซ้อนยิ่งขึ้นไปอีก อุปกรณ์ไม่เพียงแต่ใช้งานได้เพียงฟังก์ชันเดียวแต่ยังใช้งานได้หลากหลาย มาดูโครงสร้างคำอธิบายของ UHK:

• ตัวระบุอุปกรณ์
  • ตัวอธิบายการกำหนดค่า
    • ตัวอธิบายอินเทอร์เฟซ 0: GenericHID
      • ตัวอธิบายปลายทาง
    • ตัวอธิบายอินเทอร์เฟซ 1: แป้นพิมพ์
      • ตัวอธิบายปลายทาง
    • ตัวอธิบายอินเทอร์เฟซ 2: Mouse
      • ตัวอธิบายปลายทาง

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

เมื่อเราได้สร้าง descriptor แล้ว ก็ถึงเวลาส่งอักขระ x ในทุกวินาที

 uint8_t isSecondElapsed = 0; int main(void) { while (1) { _delay_us(1000); isSecondElapsed = 1; } } bool CALLBACK_HID_Device_CreateHIDReport(USB_ClassInfo_HID_Device_t* const HIDInterfaceInfo, uint8_t* const ReportID, const uint8_t ReportType, void* ReportData, uint16_t* const ReportSize) { USB_KeyboardReport_Data_t* KeyboardReport = (USB_KeyboardReport_Data_t*)ReportData; if (isSecondElapsed) { KeyboardReport->KeyCode[0] = HID_KEYBOARD_SC_X; isSecondElapsed = 0; } *ReportSize = sizeof(USB_KeyboardReport_Data_t); return false; }

USB เป็นโปรโตคอลแบบสำรวจ ซึ่งหมายความว่าคอมพิวเตอร์โฮสต์จะสอบถามอุปกรณ์ตามช่วงเวลาปกติ (ปกติ 125 ครั้งต่อวินาที) เพื่อดูว่ามีข้อมูลใหม่ที่จะส่งหรือไม่ การเรียกกลับที่เกี่ยวข้องคือฟังก์ชัน CALLBACK_HID_Device_CreateHIDReport() ซึ่งในกรณีนี้จะส่ง scancode ของอักขระ x ไปยังโฮสต์ทุกครั้งที่ตัวแปร isSecondElapsed มี 1 isSecondElapsed ถูกตั้งค่าเป็น 1 จากลูปหลักต่อวินาที และตั้งค่าเป็น 0 จากการโทรกลับ

ขั้นตอนที่สอง: คีย์บอร์ดสี่ปุ่ม

ณ จุดนี้แป้นพิมพ์ของเราไม่มีประโยชน์อย่างยิ่ง คงจะดีถ้าเราพิมพ์ลงไปได้จริงๆ แต่สำหรับสิ่งนั้น เราจำเป็นต้องมีแป้น และแป้นต่างๆ ต้องถูกจัดเรียงเป็นเมทริกซ์ของแป้นพิมพ์ แป้นพิมพ์ขนาดเต็ม 104 คีย์สามารถมีได้ 18 แถวและ 6 คอลัมน์ แต่เราจะมีเมทริกซ์แป้นพิมพ์ขนาด 2x2 แบบเรียบง่ายสำหรับการเริ่มต้นใช้งาน นี่คือแผนผัง:

และนี่คือลักษณะที่ปรากฏบนเขียงหั่นขนม:

สมมติว่า ROW1 เชื่อมต่อกับ PINA0 , ROW2 ถึง PINA1 , COL1 ถึง PORTB0 และ COL2 ถึง PORTB1 โค้ดการสแกนจะมีลักษณะดังนี้:

 /* A single pin of the microcontroller to which a row or column is connected. */ typedef struct { volatile uint8_t *Direction; volatile uint8_t *Name; uint8_t Number; } Pin_t; /* This part of the key matrix is stored in the Flash to save SRAM space. */ typedef struct { const uint8_t ColNum; const uint8_t RowNum; const Pin_t *ColPorts; const Pin_t *RowPins; } KeyMatrixInfo_t; /* This Part of the key matrix is stored in the SRAM. */ typedef struct { const __flash KeyMatrixInfo_t *Info; uint8_t *Matrix; } KeyMatrix_t; const __flash KeyMatrixInfo_t KeyMatrix = { .ColNum = 2, .RowNum = 2, .RowPins = (Pin_t[]) { { .Direction=&DDRA, .Name=&PINA, .Number=PINA0 }, { .Direction=&DDRA, .Name=&PINA, .Number=PINA1 } }, .ColPorts = (Pin_t[]) { { .Direction=&DDRB, .Name=&PORTB, .Number=PORTB0 }, { .Direction=&DDRB, .Name=&PORTB, .Number=PORTB1 }, } }; void KeyMatrix_Scan(KeyMatrix_t *KeyMatrix) { for (uint8_t Col=0; Col<KeyMatrix->Info->ColNum; Col++) { const Pin_t *ColPort = KeyMatrix->Info->ColPorts + Col; for (uint8_t Row=0; Row<KeyMatrix->Info->RowNum; Row++) { const Pin_t *RowPin = KeyMatrix->Info->RowPins + Row; uint8_t IsKeyPressed = *RowPin->Name & 1<<RowPin->Number; KeyMatrix_SetElement(KeyMatrix, Row, Col, IsKeyPressed); } } }

โค้ดจะสแกนครั้งละหนึ่งคอลัมน์ และภายในคอลัมน์นั้น รหัสจะอ่านสถานะของสวิตช์กุญแจแต่ละตัว สถานะของสวิตช์กุญแจจะถูกบันทึกลงในอาร์เรย์ ภายในฟังก์ชัน CALLBACK_HID_Device_CreateHIDReport() ก่อนหน้าของเรา รหัสการสแกนที่เกี่ยวข้องจะถูกส่งออกไปตามสถานะของอาร์เรย์นั้น

ขั้นตอนที่สาม: คีย์บอร์ดที่มีสองส่วน

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

อีกครึ่งหนึ่งจะมีเมทริกซ์คีย์บอร์ดอีกอันหนึ่งซึ่งทำงานในลักษณะเดียวกับก่อนหน้านี้ สิ่งใหม่ที่น่าตื่นเต้นคือการสื่อสารระหว่างครึ่งแป้นพิมพ์ โปรโตคอลยอดนิยมสามประการในการเชื่อมต่ออุปกรณ์อิเล็กทรอนิกส์คือ SPI, I ² C และ UART สำหรับวัตถุประสงค์ในทางปฏิบัติ เราจะใช้ UART ในกรณีนี้

การสื่อสารแบบสองทิศทางไหลผ่าน RX ไปทางขวาและผ่าน TX ไปทางซ้ายตามแผนภาพด้านบน VCC และ GND จำเป็นสำหรับการถ่ายโอนพลังงาน UART ต้องการให้เพียร์ใช้อัตราบอด จำนวนบิตข้อมูล และจำนวนบิตหยุดเหมือนกัน เมื่อตัวรับส่งสัญญาณ UART ของเพียร์ทั้งสองได้รับการตั้งค่า การสื่อสารจะเริ่มไหล

สำหรับตอนนี้ ครึ่งแป้นพิมพ์ด้านซ้ายจะส่งข้อความหนึ่งไบต์ไปยังแป้นพิมพ์ด้านขวาครึ่งหนึ่งผ่าน UART ซึ่งแสดงถึงเหตุการณ์การกดปุ่มหรือการกดปุ่ม แป้นพิมพ์ด้านขวาครึ่งหนึ่งจะประมวลผลข้อความเหล่านี้และจัดการสถานะของอาร์เรย์เมทริกซ์แป้นพิมพ์แบบเต็มในหน่วยความจำตามลำดับ นี่คือวิธีที่แป้นพิมพ์ด้านซ้ายส่งข้อความครึ่งหนึ่ง:

 USART_SendByte(IsKeyPressed<<7 | Row*COLS_NUM + Col);

รหัสสำหรับครึ่งแป้นพิมพ์ขวาเพื่อรับข้อความมีลักษณะดังนี้:

 void KeyboardRxCallback(void) { uint8_t Event = USART_ReceiveByte(); if (!MessageBuffer_IsFull(&KeyStateBuffer)) { MessageBuffer_Insert(&KeyStateBuffer, Event); } }

KeyboardRxCallback() ตัวจัดการการขัดจังหวะจะถูกทริกเกอร์เมื่อใดก็ตามที่ได้รับไบต์ผ่าน UART เนื่องจากตัวจัดการขัดจังหวะควรดำเนินการโดยเร็วที่สุด ข้อความที่ได้รับจะถูกใส่ลงในบัฟเฟอร์วงแหวนสำหรับการประมวลผลในภายหลัง ในที่สุดบัฟเฟอร์วงแหวนจะได้รับการประมวลผลจากภายในลูปหลักและเมทริกซ์ของแป้นพิมพ์จะได้รับการอัปเดตตามข้อความ

ข้างต้นเป็นวิธีที่ง่ายที่สุดในการทำให้สิ่งนี้เกิดขึ้น แต่โปรโตคอลขั้นสุดท้ายจะค่อนข้างซับซ้อนกว่าเล็กน้อย ข้อความแบบหลายไบต์จะต้องได้รับการจัดการ และแต่ละข้อความจะต้องได้รับการตรวจสอบความสมบูรณ์โดยใช้การตรวจสอบ CRC-CCITT

ณ จุดนี้ ต้นแบบเขียงหั่นขนมของเราดูน่าประทับใจทีเดียว:

ขั้นตอนที่สี่: พบกับจอแสดงผล LED

เป้าหมายหนึ่งของเรากับ UHK คือการทำให้ผู้ใช้สามารถกำหนดแผนที่แป้นพิมพ์เฉพาะแอปพลิเคชันได้หลายแบบเพื่อเพิ่มประสิทธิภาพการทำงานต่อไป ผู้ใช้ต้องการวิธีที่จะรับรู้ถึงคีย์แมปที่แท้จริงที่กำลังใช้งานอยู่ ดังนั้นจอแสดงผล LED ในตัวจึงถูกสร้างขึ้นในคีย์บอร์ด นี่คือจอแสดงผลต้นแบบพร้อมไฟ LED ทั้งหมดติดสว่าง:

จอแสดงผล LED ถูกใช้งานโดยเมทริกซ์ LED 8x6:

สัญลักษณ์ LED สีแดงทุกๆ สองแถวแสดงถึงส่วนของจอแสดงผล LED 14 ส่วน สัญลักษณ์ LED สีขาวแสดงถึงตัวบ่งชี้สถานะเพิ่มเติมสามตัว

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

เมทริกซ์ LED ถูกขับเคลื่อนโดยวงจรรวม (ICs) สองวงจร วงจรหนึ่งขับเคลื่อนแถวและอีกวงจรขับเคลื่อนคอลัมน์ IC ต้นทางที่ขับเคลื่อนคอลัมน์คือไดรเวอร์ PCA9634 I2C LED:

IC ซิงก์ LED เมทริกซ์ที่ขับเคลื่อนแถวคือรีจิสเตอร์การเปลี่ยนกำลัง TPIC6C595:

มาดูรหัสที่เกี่ยวข้องกัน:

 uint8_t LedStates[LED_MATRIX_ROWS_NUM]; void LedMatrix_UpdateNextRow(bool IsKeyboardColEnabled) { TPIC6C595_Transmit(LedStates[ActiveLedMatrixRow]); PCA9634_Transmit(1 << ActiveLedMatrixRow); if (++ActiveLedMatrixRow == LED_MATRIX_ROWS_NUM) { ActiveLedMatrixRow = 0; } }

LedMatrix_UpdateNextRow() จะถูกเรียกทุกๆ มิลลิวินาที โดยจะอัปเดตแถวของเมทริกซ์ LED อาร์เรย์ LedStates เก็บสถานะของ LED แต่ละดวง อัปเดตผ่าน UART ตามข้อความที่มาจากครึ่งแป้นพิมพ์ขวา ซึ่งเกือบจะเหมือนกับกรณีของการกด/การกดปุ่ม

ภาพใหญ่

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

จนถึงตอนนี้มีการพูดถึงรายละเอียดด้านอุปกรณ์ของแป้นพิมพ์ของนักพัฒนามากแล้ว แต่ไม่มากเกี่ยวกับ UHK Agent ซึ่งเป็นซอฟต์แวร์ฝั่งโฮสต์ เหตุผลก็คือว่าในตอนนี้ Agent นั้นเป็นพื้นฐานที่ต่างจากฮาร์ดแวร์และเฟิร์มแวร์ อย่างไรก็ตาม สถาปัตยกรรมระดับสูงของ Agent ได้รับการพิจารณาแล้ว ซึ่งฉันอยากจะแบ่งปัน

UHK Agent คือแอปพลิเคชันตัวกำหนดค่าซึ่งสามารถปรับแต่งแป้นพิมพ์ให้เหมาะสมกับความต้องการของผู้ใช้ได้ แม้ว่าจะเป็นลูกค้าที่ร่ำรวย แต่ Agent ก็ใช้เทคโนโลยีเว็บและทำงานบนแพลตฟอร์ม node-webkit

เอเจนต์สื่อสารกับแป้นพิมพ์โดยใช้ไลบรารี node-usb โดยส่งคำขอควบคุม USB แบบพิเศษเฉพาะอุปกรณ์และประมวลผลผลลัพธ์ ใช้ Express.js เพื่อแสดง REST API สำหรับการบริโภคโดยแอปพลิเคชันบุคคลที่สาม นอกจากนี้ยังใช้ Angular.js เพื่อจัดเตรียมส่วนต่อประสานผู้ใช้ที่เรียบร้อย

 var enumerationModes = { 'keyboard' : 0, 'bootloader-right' : 1, 'bootloader-left' : 2 }; function sendReenumerateCommand(enumerationMode, callback) { var AGENT_COMMAND_REENUMERATE = 0; sendAgentCommand(AGENT_COMMAND_REENUMERATE, enumerationMode, callback); } function sendAgentCommand(command, arg, callback) { setReport(new Buffer([command, arg]), callback); } function setReport(message, callback) { device.controlTransfer( 0x21, // bmRequestType (constant for this control request) 0x09, // bmRequest (constant for this control request) 0, // wValue (MSB is report type, LSB is report number) interfaceNumber, // wIndex (interface number) message, // message to be sent callback ); }

ทุกคำสั่งมีตัวระบุ 8 บิตและชุดอาร์กิวเมนต์เฉพาะคำสั่ง ปัจจุบัน เฉพาะคำสั่ง re-enumerate เท่านั้นที่ถูกนำมาใช้ sendReenumerateCommand() ทำให้อุปกรณ์ระบุอีกครั้งเป็น bootloader ซ้ายหรือ bootloader ขวา สำหรับอัพเกรดเฟิร์มแวร์ หรือเป็นอุปกรณ์คีย์บอร์ด

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

การสร้างต้นแบบ

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

นี่คือลักษณะของเคสคีย์บอร์ดที่พิมพ์ 3 มิติ:

ตามการออกแบบทางกลและแผนผัง ต้องออกแบบแผงวงจรพิมพ์ PCB ด้านขวามีลักษณะดังนี้ใน KiCad:

จากนั้น PCB จะถูกประดิษฐ์และส่วนประกอบที่ติดตั้งบนพื้นผิวจะต้องบัดกรีด้วยมือ:

สุดท้าย หลังจากที่ประกอบชิ้นส่วนทั้งหมด รวมทั้งการพิมพ์ 3 มิติ ขัดเงา และทาสีชิ้นส่วนพลาสติก และประกอบทุกอย่าง เราก็ได้ต้นแบบแป้นพิมพ์สำหรับแฮ็กเกอร์ที่ใช้งานได้ดังนี้:

บทสรุป

ฉันชอบเปรียบเทียบคีย์บอร์ดของนักพัฒนากับเครื่องดนตรีของนักดนตรี คีย์บอร์ดเป็นสิ่งที่ค่อนข้างใกล้ชิดถ้าคุณคิดเกี่ยวกับมัน ท้ายที่สุด เราใช้พวกมันทั้งวันเพื่อสร้างซอฟต์แวร์ของวันพรุ่งนี้ ทีละอักขระ

อาจเป็นเพราะเหตุผลข้างต้น ฉันคิดว่าการพัฒนา Ultimate Hacking Keyboard เป็นสิทธิพิเศษ และถึงแม้จะผ่านความยากลำบากมามากมาย แต่บ่อยครั้งกว่านั้นจะเป็นการเดินทางที่น่าตื่นเต้นและประสบการณ์การเรียนรู้ที่เข้มข้นอย่างไม่น่าเชื่อ

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

สุดท้ายนี้ คุณสามารถเยี่ยมชม https://ultimatehackingkeyboard.com เพื่อดูข้อมูลเพิ่มเติม และสมัครรับข้อมูลที่นั่นเพื่อรับการแจ้งเตือนเกี่ยวกับการเปิดตัวแคมเปญของเรา