📝 👩🏻‍🔧 🥣 पुराने सिंथेसाइज़र का नया जीवन। भाग २ 🐾 💅🏿 🥝

पुराने बर्न-आउट सिंथेसाइज़र के बारे में कहानी की निरंतरता, जिसमें मैं पूरी तरह से लिनक्स पर एंबेडस्की ई 8 मिनी-कंप्यूटर के आधार पर बनाए गए सॉफ़्टवेयर सिंथेसाइज़र के साथ ध्वनि उत्पन्न करने के लिए ज़िम्मेदार हार्डवेयर की जगह पूरी तरह से नया जीवन साँस लेने की कोशिश कर रहा हूँ। जैसा कि अक्सर होता है, योजना के पहले और दूसरे भाग के प्रकाशन के बीच बहुत अधिक समय बीत चुका है, लेकिन, फिर भी, हम जारी रखेंगे।

पिछले भाग में, समाधान की तकनीकी विशेषताओं के विवरण के साथ सिंथेसाइज़र के नए "मस्तिष्क" के लिए हार्डवेयर प्लेटफ़ॉर्म चुनने की प्रक्रिया का वर्णन किया गया था, आवश्यक पुस्तकालयों की असेंबली प्रक्रिया और प्रक्रिया में जिन समस्याओं का सामना करना पड़ा था, उन्हें संक्षेप में वर्णित किया गया था। अब, लोहे के संबंध में, हम देखेंगे कि सिंथेसाइज़र के कीबोर्ड मैट्रिक्स की व्यवस्था कैसे की जाती है, और फिर सॉफ्टवेयर भाग पर अधिक विवरण होगा।

कीबोर्ड मैट्रिक्स

सिंथेसाइज़र का कीबोर्ड मैट्रिक्स सामान्य कीबोर्ड मैट्रिक्स के समान है, जो कि माइक्रोकंट्रोलर के कई प्रशंसकों ने शायद अपने ल्यूडिनो से जुड़ा हुआ है। प्रत्येक सिंथेसाइज़र कुंजी के लिए, यह एक (सबसे सस्ता मॉडल) से दो (मॉडल के थोक में) स्विच प्रदान करता है। दो आसन्न स्विच का उपयोग करना, जिनमें से एक कुंजी दबाए जाने से पहले बंद हो जाता है, माइक्रोकंट्रोलर सशर्त बल का निर्धारण कर सकता है, या इसके बजाय जिस गति से कुंजी दबाया गया था, ताकि बाद में संबंधित वॉल्यूम की एक ध्वनि पुन: उत्पन्न हो। यह इस तरह दिखता है:

बोर्ड के पीछे डायोड हैं जो एक ही समय में कई कुंजी दबाते समय दबाए गए कुंजी के "झूठे" पढ़ने को रोकते हैं। यहां कीबोर्ड मैट्रिक्स के सर्किट आरेख का एक टुकड़ा है, जिस पर ये दो स्विच और उनसे जुड़े डायोड दिखाई देते हैं:

मैट्रिक्स को स्कैन करने के लिए, माइक्रोकंट्रोलर क्रमिक रूप से स्तंभों (एन के रूप में लेबल किए गए पिन) को खींचता है, और पंक्तियों (बी लेबल वाले पिन) पर स्तर की जांच करता है। यदि किसी पंक्ति का स्तर ऊंचा हो जाता है, तो वर्तमान में सक्रिय "कॉलम-पंक्ति" संयोजन के अनुरूप कुंजी दबाया जाता है। आरेख कीबोर्ड का केवल एक हिस्सा दिखाता है - कुल 76 कुंजी (13 लाइनें और 6 x 2 कॉलम हैं, जो मैट्रिक्स को स्कैन करने के लिए कुल 156 संभावित विकल्प और माइक्रोकंट्रोलर के 25 उपयोग किए गए आउटपुट) देता है। पूरे कीबोर्ड की स्कैनिंग प्रति सेकंड कई बार की जाती है और कलाकार के लिए अदृश्य होती है।

मेरे सिंथेसाइज़र में, कीबोर्ड को स्कैन करने के लिए जिम्मेदार माइक्रोकंट्रोलर मूल रूप से एक 8-बिट, एक बार प्रोग्राम योग्य हिताची HD63B05V0 माइक्रोकंट्रोलर 8 मेगाहर्ट्ज की आवृत्ति पर काम कर रहा था और 4 केबी रोम और 192 रैम मेमोरी बाइट्स था। दुर्भाग्य से, यह नियंत्रक पहले लेख की शुरुआत में वर्णित बिजली की घटना के बाद निष्क्रिय हो गया। लेकिन, सौभाग्य से, यह मेरे मौजूदा ATmega162 नियंत्रक के साथ निष्कर्ष में लगभग संगत निकला, जिसके लिए मैंने बोर्ड पर केवल 2 पटरियों को काटने और फिर से टांका लगाकर प्रतिस्थापित किया, जिनमें से एक RESET पिन है, जो गलत जगह पर है। जैसे HD63B05V0।

चूंकि इस नियंत्रक को चालू करने से मुझे अंतर्निहित UART (चूंकि यह अन्य पिन पर भी था) का उपयोग करने की अनुमति नहीं दी गई थी, मैंने दबाए गए कुंजियों के बारे में जानकारी प्रदर्शित करने के लिए धारावाहिक बंदरगाह के इस एक तरफा (केवल-लेखन) कार्यान्वयन का उपयोग किया। इसके अलावा, TinySafeBoot बूटलोडर, जो सीरियल पोर्ट के सॉफ्टवेयर कार्यान्वयन का भी उपयोग करता है, भविष्य के फर्मवेयर अपडेट को सक्षम करने के लिए माइक्रोकंट्रोलर में डाला गया था। चूंकि मैंने सभी उच्च-स्तरीय सिंथेसाइज़र सॉफ़्टवेयर के त्वरित विकास के लिए भाषा के रूप में पायथन + क्यूटी 5 चुना है, टाइनीसेफ़बूट के लिए मैंने पायथन मॉड्यूल भी लिखा है जो आपको एवीआर माइक्रोकंट्रोलर को फर्मवेयर पढ़ने और लिखने की अनुमति देता है। एवीआर माइक्रोकंट्रोलर खुद एंबर्टस्की ई 8 बोर्ड पर UART1 सीरियल पोर्ट से जुड़ा है और स्तर रूपांतरण की आवश्यकता से बचने के लिए 3.3V द्वारा संचालित है।

AVR के लिए फ़र्मवेयर स्रोत

#include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #include <string.h> #include "dbg_putchar.h" #define MIDI_BASE 18 #define ZERO_BASE 28 #define KEYS_COUNT 76 #define hiz(port, dir) do { \ (dir) = 0; \ (port) = 0; \ } while(0) #define alow(port, dir) do { \ (dir) = 0xff; \ (port) = 0; \ } while(0) uint8_t keys[KEYS_COUNT]; /* Get state of a row by its index * starting from 1 to 13 */ uint8_t getRow(uint8_t idx) { if (idx <= 8) { return (PINC & (1 << (8 - idx))); } else if (idx >= 9 && idx <= 11) { return (PINE & (1 << (11 - idx))); } else if (idx == 12) { return (PINA & (1 << PIN6)); } else if (idx == 13) { return (PINA & (1 << PIN4)); } return 0; } inline void activateColumn1(uint8_t idx) { PORTD = 0x00 | (1 << (8 - idx)); PORTB = 0x00; } void activateColumn2(uint8_t idx) { if (idx <= 3) { PORTB = 0x00 | (1 << (idx + 4)); PORTD = 0x00; } else if (idx == 4) { PORTB = 0x00 | (1 << PIN4); PORTD = 0x00; } else if (idx == 5 || idx == 6) { PORTD = 0x00 | (1 << (idx - 5)); PORTB = 0x00; } } inline void deactivateColumns(void) { PORTD = 0x00; PORTB = 0x00; } inline void initPorts(void) { hiz(PORTA, DDRA); hiz(PORTC, DDRC); hiz(PORTE, DDRE); PORTB = 0x00; DDRB = 0xfe; DDRD = 0xff; } void resetRows(void) { /* output low */ alow(PORTC, DDRC); alow(PORTE, DDRE); /* don't touch PA7 & PA5 */ DDRA |= 0x5f; PORTA &= ~0x5f; _delay_us(10); /* back to floating input */ hiz(PORTC, DDRC); hiz(PORTE, DDRE); DDRA &= ~0x5f; } /* base MIDI note number is 25: C#0 */ int main(void) { uint8_t row, col, layer; uint8_t note, offset; initPorts(); memset(keys, 0, sizeof(keys)); dbg_tx_init(); dbg_putchar('O'); dbg_putchar('K'); while(1) { for (layer = 0; layer < 2; layer++) { for (col = 1; col <= 6; col++) { if (!layer) activateColumn1(col); else activateColumn2(col); for (row = 1; row <= 13; row++) { note = 6 * row + col + MIDI_BASE; offset = note - ZERO_BASE; if (getRow(row)) { if (!layer) { /* increase velocity counter */ if (keys[offset] < 254 && !(keys[offset] & 0x80)) keys[offset]++; } else { if (!(keys[offset] & 0x80)) { /* generate note-on event */ dbg_putchar(0x90); dbg_putchar(note); /*dbg_putchar(keys[offset]);*/ dbg_putchar(0x7f); /* stop counting */ keys[offset] |= 0x80; } } } else { if (layer) continue; if (keys[offset] & 0x80) { /* generate note off event */ dbg_putchar(0x90); dbg_putchar(note); dbg_putchar(0x00); /* reset key state */ keys[offset] = 0x00; } } } deactivateColumns(); resetRows(); } } } return 0; }

TinySafeBoot के लिए पायथन मॉड्यूल

 import serial import binascii import struct import intelhex import sys class TSB(object): CONFIRM = '!' REQUEST = '?' def __init__(self, port): self.port = serial.Serial(port, baudrate=9600, timeout=1) self.flashsz = 0 def check(self): if not self.flashsz: raise Exception("Not activated") def activate(self): self.port.write("@@@") (self.tsb, self.version, self.status, self.sign, self.pagesz, self.flashsz, self.eepsz) = \ struct.unpack("<3sHB3sBHH", self.port.read(14)) self.port.read(2) self.pagesz *= 2 self.flashsz *= 2 self.eepsz += 1 assert(self.port.read() == self.CONFIRM) def rflash(self, progress=None, size=0): self.check() self.port.write("f") self.addr = 0 self.flash = "" size = self.flashsz if not size else size while self.addr < size: if progress is not None: progress("read", self.addr, size) self.port.write(self.CONFIRM) page = self.port.read(self.pagesz) if len(page) != self.pagesz: raise Exception("Received page too short: %d" % len(page)) self.addr += len(page) self.flash += page return self.flash.rstrip('\xff') def wflash(self, data, progress=None): if len(data) % self.pagesz != 0: data = data + "\xff" * (self.pagesz - (len(data) % self.pagesz)) assert(len(data) % self.pagesz == 0) self.check() self.port.write("F") self.addr = 0 assert(self.port.read() == self.REQUEST) while self.addr < len(data): if progress is not None: progress("write", self.addr, len(data)) self.port.write(self.CONFIRM) self.port.write(data[self.addr:self.addr + self.pagesz]) self.addr += self.pagesz assert(self.port.read() == self.REQUEST) self.port.write(self.REQUEST) return self.port.read() == self.CONFIRM def vflash(self, data, progress=None): fw = self.rflash(progress, len(data)) return fw == data def info(self): print "Tiny Safe Bootloader: %s" % self.tsb print "Page size: %d" % self.pagesz print "Flash size: %d" % self.flashsz print "EEPROM size: %d" % self.eepsz if __name__ == "__main__": import argparse def progress(op, addr, total): sys.stdout.write("\r%s address: $%0.4x/$%0.4x" % (op, addr, total)) sys.stdout.flush() parser = argparse.ArgumentParser() parser.add_argument("filename", help="firmware file in Intel HEX format") parser.add_argument("--device", help="Serial port to use for programming", default="/dev/ttyUSB0") args = parser.parse_args() tsb = TSB(args.device) tsb.activate() tsb.info() fw = intelhex.IntelHex(args.filename) assert(tsb.wflash(fw.tobinstr(), progress)) assert(tsb.vflash(fw.tobinstr(), progress)) print "\nOK\n"

AVR के लिए एक प्रोग्रामर के रूप में, मैंने सबसे पहले लॉन्चपैड MSP430 पर आधारित एक प्रोग्रामर का इस्तेमाल किया, जिसमें मेरे कुछ टुकड़े हैं, और फिर इस होममेड चमत्कार (अच्छी तरह से काम करना) ने चीन से आने वाले TL866CS MiniPromermer को रास्ता दिया। नए प्रोग्रामर की भावना बेहद सकारात्मक है।

सिंथेसाइज़र के कीबोर्ड डिज़ाइन और इसे स्कैन करने के तरीके के बारे में बहुत विस्तृत जानकारी, जिसमें एक बाहरी रैम चिप को जोड़ने के लिए AVR माइक्रोकंट्रोलर इंटरफ़ेस के माध्यम से स्कैनिंग का एक बहुत ही मूल तरीका शामिल है, OpenMusicLabs वेबसाइट पर वर्णित है।

रियलटाइम प्रीमेशन सपोर्ट के साथ एक कर्नेल खाना बनाना

आंशिक रूप से शेड्यूलर पर अधिक नियंत्रण हासिल करने के लिए और ध्वनि खेलते समय विलंबता को कम करने और आंशिक रूप से खेल हित के लिए, मैंने PREEPMT RT पैच के साथ कोर का उपयोग करने का निर्णय लिया, जिनमें से एक मुख्य विशेषता यह है कि व्यवधान भी "प्रक्रिया" बन सकते हैं। प्राथमिकता के आधार पर अनुसूचक द्वारा पूर्वनिर्धारित किया जाए। S5PV210 प्रोसेसर के लिए सैमसंग द्वारा आपूर्ति की गई मूल कोर, जिसके आधार पर सिस्टम बनाया गया है, एंड्रॉइड से जाहिर तौर पर कर्नेल संस्करण 3.0.8 पर आधारित है। इस कर्नेल संस्करण (3.0.8) के लिए प्रोजेक्ट साइट पर उपलब्ध RT_PREEMPT पैच में से कोई भी बिना विरोध के स्रोत पर सुपरइम्पोज़ होना चाहता था, लेकिन अंत में, सभी संघर्षों को मैन्युअल रूप से हल करते हुए, हम 3.0.8-rt23 संस्करण को पैच करने में कामयाब रहे।

इस तथ्य के कारण कि स्पिनलॉक और म्यूटेक्स जैसी बुनियादी संरचनाएं भी इस तरह से संशोधित कर्नेल में संशोधित हुईं, कुछ परिधीय उपकरणों के मालिकाना ड्राइवरों, जैसे कि वीडियो कैमरा, एक कैपेसिटिव टचस्क्रीन नियंत्रक, और, जो सबसे भयानक है, इसके साथ लिंक करने के लिए संकलित ऑब्जेक्ट फ़ाइलों के रूप में वितरित किया गया है। ऑडियो कोडेक। हम बाद में उनके पास लौट आएंगे, और अब उन्हें बंद कर देंगे और पहली बार एक ताजा इकट्ठे वास्तविक समय कर्नेल के साथ बोर्ड लॉन्च करने का प्रयास करेंगे और ... हमें एक त्वरित कर्नेल आतंक मिलेगा। यह पहले भी हुआ था जब kgdb डीबगर लॉन्च किया गया था (जो, जैसा कि बाद में पता चला, अभी भी काम नहीं करेगा, भले ही यह शुरू हुआ हो), इसलिए डिबगिंग के लिए हमें init/main.c

फ़ाइल में प्रिंटफॉर्म्स सम्मिलित करने थे, स्थान निर्धारित करने के लिए start_kernel

फ़ंक्शन। जिसमें सब कुछ चरमरा रहा है। इस प्रकार, यह पता चला कि आखिरी चीज जो कर्नेल करने में hrtimers_init()

, उसे hrtimers_init()

फ़ंक्शन को कॉल करना था, जो उच्च-रिज़ॉल्यूशन टाइमर और उनके रुकावटों को शुरू करता है। यह कोड प्लेटफ़ॉर्म-विशिष्ट है, और हमारे मामले में यह arch/arm/plat-s5p/hr-time-rtc.c

। जैसा कि मैंने कहा, PREEMPT RT पैच के साथ कर्नेल की मुख्य विशेषताओं में से एक यह है कि बाधाएं धागे बन जाती हैं। यह एक नियमित कर्नेल में संभव है, लेकिन डिफ़ॉल्ट रूप से PREEMPT RT के साथ कर्नेल लगभग सभी अवरोधों को वैसा ही बनाने की कोशिश करता है। कोड के आगे के विश्लेषण से पता चला कि इन थ्रेड्स को संचालित करने के लिए kthreadd_task कार्य का उपयोग किया जाता है, जो प्रारंभ के बहुत अंत में प्रारंभ होता start_kernel

फ़ंक्शन - बहुत बाद में टाइमर की तुलना में आरंभिक होते हैं। गिरावट इस तथ्य के कारण थी कि कर्नेल स्ट्रीमिंग द्वारा टाइमर को बाधित करने की कोशिश कर रहा था, जबकि kthreadd_task अभी भी NULL था। यह व्यक्तिगत व्यवधानों के लिए सेट करके हल किया जाता है जिसे किसी भी परिस्थिति में प्रवाहित नहीं किया जाना चाहिए, IRQF_NO_THREAD ध्वज, जो कि टाइमर hr-time-rtc.c

फ्लैग फ्लैग को hr-time-rtc.c

में जोड़ा गया था। हुर्रे! कर्नेल बूट हुआ, लेकिन यह केवल शुरुआत है ...

जैसा कि मैंने ऊपर उल्लेख किया है, साइड इफेक्ट्स में से एक यह था कि ऑडियो इनपुट / आउटपुट के लिए जिम्मेदार मॉड्यूल नए कर्नेल के साथ लिंक करना बंद कर देता है। यह आंशिक रूप से था क्योंकि PREEMPT RT के साथ कर्नेल केवल SLAB मेमोरी प्रबंधन तंत्र का समर्थन करता है (और संस्करण 3.0.8 में), और शुरू में मॉड्यूल SLUB तंत्र के साथ संकलित किया गया था, जो नए कर्नेल द्वारा समर्थित नहीं है। हालाँकि, मैं बहुत भाग्यशाली था कि मैंने कास्परस्की लैब में काम किया, और मैंने एक सहयोगी को एआरएम के लिए हेक्स-रेज डिकंपाइलर का उपयोग करते हुए मेरे लिए ड्राइवर और कोडक फ़ाइलों को अपघटित करने के लिए राजी किया, जिसके बाद मैं उनके स्रोत कोड को लगभग पूरी तरह से पुन: बनाने में सक्षम था। व्यवहार में, क्योंकि परिणामस्वरूप, ऑडियो इंटरफ़ेस को "नए" ड्राइवर के साथ निर्धारित किया गया था, हालांकि, WM8960 माइक्रोक्रेकिट रजिस्टरों को शुरू करने के लिए निम्न-स्तरीय प्रक्रिया में कुछ अंतरों के कारण, ध्वनि कलाकृतियों के साथ खेला गया था। कुछ समय के लिए मैंने अपने ड्राइवर को ट्वीक करने की कोशिश की, लेकिन फिर मैंने एक आसान तरीका चुना - मैंने चीनी कंपनी एंबेडस्की टेक भेजा, जहां मैंने एक मिनी-कंप्यूटर खरीदा, PREEMPT_RT के साथ मेरा पैच खरीदा, और उनसे मेरे लिए ऑडियो फाइल संकलित करने और भेजने के लिए कहा। लोगों ने जल्दी से जवाब दिया और मुझे उन फाइलों को भेज दिया जिनके साथ ध्वनि ने अंततः उम्मीद के मुताबिक काम किया।

वैसे, जब मैं अपने विघटित चालक के साथ व्यस्त था, तो मैंने पाया कि kgdb डिबगर मेरे या मूल कर्नेल के साथ काम नहीं करता है। जैसा कि यह निकला, इसके लिए सीरियल पोर्ट के सिंक्रोनस पोलिंग की आवश्यकता होती है, जो सैमसंग सीरियल पोर्ट ड्राइवर ( drivers/tty/serial/samsung.c

) में उपलब्ध नहीं था। मैंने इस पैच के आधार पर ड्राइवर को आवश्यक समर्थन जोड़ा, जिसके बाद डिबगर ने काम किया।

आगे की खुदाई। नए कोर का दूसरा साइड इफेक्ट अत्यंत कम हो गया है, जिसमें बड़े "लैग्स" के साथ S5PV210 चिप पर सिस्टम के सभी लंबे समय से पीड़ित सीरियल पोर्ट के संचालन की गति है, जिसके परिणामस्वरूप सीरियल पोर्ट के माध्यम से टर्मिनल में सामान्य संचालन असंभव था, और एवीआर नियंत्रक चमकती के रूप में भी काम नहीं करना चाहिए। पोलिंग कीबोर्ड सिंथेसाइज़र। लंबे समय तक मैंने यह समझने की कोशिश की कि क्या कारण था, लेकिन मैंने केवल यह देखा कि टर्मिनल में प्रत्येक चरित्र में प्रवेश करने से कई मिलियन सीरियल पोर्ट की पीढ़ी बाधित होती है - कर्नेल उन्हें संसाधित करने की जल्दी में नहीं लगता था। अंत में, मैंने IRQF_NO_THREAD बनाने के लिए उपरोक्त झंडे का उपयोग करके इस समस्या को हल किया, सभी सीरियल पोर्ट नॉन-थ्रेडेड को बाधित करता है। यह समाधान बहुत सुंदर नहीं serial_core.c

, क्योंकि सैमसंग चालक के अलावा, मुझे serial_core.c

और serial_core.h

परिवर्तन करना पड़ा, जिससे सभी सीरियल पोर्ट सामान्य रूप से प्रभावित हुए। क्योंकि PREEMPT RT के साथ कर्नेल में NO_THREAD वाले ड्राइवरों में spin_lock_t का उपयोग करना असंभव है, लेकिन आपको raw_spinlock_t का उपयोग करने की आवश्यकता है।

मूल कर्नेल में, जो, जैसा कि मैंने ऊपर कहा था, विभिन्न परिधीय उपकरणों का समर्थन करता है, जैसे कि वीडियो कैमरा, हार्डवेयर कोडेक्स, एचडीएमआई, आदि, 512 एमबी रैम में से, केवल 390 एमबी के बारे में उपलब्ध थे, और शेष उपरोक्त उपकरणों के लिए आरक्षित था। , और हमेशा (भले ही वे कर्नेल कॉन्फ़िगरेशन प्रक्रिया के दौरान अक्षम थे)। यह बहुत ही बेकार है, विशेष रूप से यह देखते हुए कि अतिरिक्त 120 एमबी रैम सिंथेसाइज़र द्वारा नमूनों को संग्रहीत करने के तरीके में नहीं होगा। मेमोरी को फ़ाइल arch/arm/mach-s5pv210/mach-tq210.c

में आरक्षित किया गया था, जो किसी विशेष मशीन (हमारे मामले में, बोर्ड) के कॉन्फ़िगरेशन और उपकरणों के बारे में सभी जानकारी एकत्र करने के लिए मुख्य बिंदु है। हम स्मृति के आवंटन पर टिप्पणी करते हैं - s5p_reserve_bootmem

फ़ंक्शन को कॉल करते हैं, और हमें सिंथेसाइज़र को काम करने के लिए 120 एमबी अतिरिक्त मेमोरी मिलती है।

अंतिम परिवर्तन जो कर्नेल के लिए किया गया था, ऑडियो डेटा के लिए न्यूनतम बफर आकार का संबंध था, जो मूल में स्मृति के एक पृष्ठ के बराबर था, जो 44100 हर्ट्ज की एक नमूना आवृत्ति पर, 16 बिट्स के 2 चैनलों ने प्रत्येक को लगभग 20 एमएस - थोड़ा सा दिया। यह मान फ़ाइल sound/soc/samsung/dma.c

में 128 बाइट्स में बदल दिया गया था, जिसके बाद स्थिरता और प्रदर्शन से समझौता किए बिना न्यूनतम बफर आकार कुछ मिलीसेकंड तक कम हो गया था।

PREEMPT RT और GitHub पर सभी संशोधनों के साथ कर्नेल स्रोत कोड

AVR माइक्रोकंट्रोलर LinuxSampler के साथ कैसे संवाद करता है

AVR मिनी-कंप्यूटर बोर्ड के सीरियल पोर्ट से जुड़ा हुआ है और इसके सॉफ्टवेयर UART के लिए तैयार मिडी संदेशों को बाहर निकालता है। ड्राइवरों को लिखने की आवश्यकता को समाप्त करने के लिए, सभी ऑडियो और मिडी डेटा के लिए JACK सर्वर को परिवहन के रूप में उपयोग करने का निर्णय लिया गया। C में एक छोटा अनुप्रयोग सीरियल पोर्ट से जुड़ता है, JACK में MIDI-OUT के रूप में पंजीकृत होता है और सभी प्राप्त MIDI संदेशों को पुनर्निर्देशित करना शुरू कर देता है, और JACK उन्हें पहले ही LinuxSampler में डिलीवर कर देता है। सस्ता और हंसमुख।

धारावाहिक बंदरगाह और JACK के बीच पुल अनुप्रयोग का स्रोत कोड

 #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/time.h> #include <unistd.h> #include <assert.h> #include <string.h> #include <sysexits.h> #include <errno.h> #include <signal.h> #include <fcntl.h> #include <termios.h> #include <jack/jack.h> #include <jack/midiport.h> #define UART_SPEED B9600 jack_port_t *output_port; jack_client_t *jack_client = NULL; int input_fd; void init_serial(int fd) { struct termios termios; int res; res = tcgetattr (fd, &termios); if (res < 0) { fprintf (stderr, "Termios get error: %s\n", strerror(errno)); exit (EXIT_FAILURE); } cfsetispeed (&termios, UART_SPEED); cfsetospeed (&termios, UART_SPEED); termios.c_iflag &= ~(IGNPAR | IXON | IXOFF); termios.c_iflag |= IGNPAR; termios.c_cflag &= ~(CSIZE | PARENB | CSTOPB | CREAD | CLOCAL); termios.c_cflag |= CS8; termios.c_cflag |= CREAD; termios.c_cflag |= CLOCAL; termios.c_lflag &= ~(ICANON | ECHO); termios.c_cc[VMIN] = 3; termios.c_cc[VTIME] = 0; res = tcsetattr (fd, TCSANOW, &termios); if (res < 0) { fprintf (stderr, "Termios set error: %s\n", strerror(errno)); exit (EXIT_FAILURE); } } double get_time(void) { double seconds; int ret; struct timeval tv; ret = gettimeofday(&tv, NULL); if (ret) { perror("gettimeofday"); exit(EX_OSERR); } seconds = tv.tv_sec + tv.tv_usec / 1000000.0; return seconds; } double get_delta_time(void) { static double previously = -1.0; double now; double delta; now = get_time(); if (previously == -1.0) { previously = now; return 0; } delta = now - previously; previously = now; assert(delta >= 0.0); return delta; } static double nframes_to_ms(jack_nframes_t nframes) { jack_nframes_t sr; sr = jack_get_sample_rate(jack_client); assert(sr > 0); return (nframes * 1000.0) / (double)sr; } static double nframes_to_seconds(jack_nframes_t nframes) { return nframes_to_ms(nframes) / 1000.0; } static jack_nframes_t ms_to_nframes(double ms) { jack_nframes_t sr; sr = jack_get_sample_rate(jack_client); assert(sr > 0); return ((double)sr * ms) / 1000.0; } static jack_nframes_t seconds_to_nframes(double seconds) { return ms_to_nframes(seconds * 1000.0); } static void process_midi_output(jack_nframes_t nframes) { int t, res; void *port_buffer; char midi_buffer[3]; jack_nframes_t last_frame_time; port_buffer = jack_port_get_buffer(output_port, nframes); if (port_buffer == NULL) { printf("jack_port_get_buffer failed, cannot send anything.\n"); return; } jack_midi_clear_buffer(port_buffer); last_frame_time = jack_last_frame_time(jack_client); t = seconds_to_nframes(get_delta_time()); res = read(input_fd, midi_buffer, sizeof(midi_buffer)); if (res < 0 && errno == EAGAIN) return; res = jack_midi_event_write(port_buffer, t, midi_buffer, 3); if (res != 0) { printf("jack_midi_event_write failed, NOTE LOST."); } } static int process_callback(jack_nframes_t nframes, void *notused) { if (nframes <= 0) { printf("Process callback called with nframes = 0; bug in JACK?"); return 0; } process_midi_output(nframes); return 0; } int connect_to_input_port(const char *port) { int ret; ret = jack_port_disconnect(jack_client, output_port); if (ret) { printf("Cannot disconnect MIDI port."); return -3; } ret = jack_connect(jack_client, jack_port_name(output_port), port); if (ret) { printf("Cannot connect to %s.", port); return -4; } printf("Connected to %s.", port); return 0; } static void init_jack(void) { int i, err; jack_client = jack_client_open("midibridge", JackNullOption, NULL); if (jack_client == NULL) { printf("Could not connect to the JACK server; run jackd first?"); exit(EXIT_FAILURE); } err = jack_set_process_callback(jack_client, process_callback, 0); if (err) { printf("Could not register JACK process callback."); exit(EXIT_FAILURE); } char port_name[32]; snprintf(port_name, sizeof(port_name), "midi_out"); output_port = jack_port_register(jack_client, port_name, JACK_DEFAULT_MIDI_TYPE, JackPortIsOutput, 0); if (output_port == NULL) { printf("Could not register JACK output port '%s'.", port_name); exit(EXIT_FAILURE); } if (jack_activate(jack_client)) { printf("Cannot activate JACK client."); exit(EXIT_FAILURE); } } static void usage(void) { fprintf(stderr, "usage: midibridge -a <input port>\n"); exit(EXIT_FAILURE); } int main(int argc, char *argv[]) { int ch; char *autoconnect_port_name = NULL; while ((ch = getopt(argc, argv, "a:")) != -1) { switch (ch) { case 'a': autoconnect_port_name = strdup(optarg); break; default: usage(); } } input_fd = open("/dev/ttySAC1", O_RDWR | O_NOCTTY | O_NDELAY | O_NONBLOCK); if (input_fd < 0) { fprintf(stderr, "Cannot open serial port %s\n", strerror(errno)); return EXIT_FAILURE; } init_serial (input_fd); init_jack(); if (autoconnect_port_name) { if (connect_to_input_port(autoconnect_port_name)) { printf("Couldn't connect to '%s', exiting.", autoconnect_port_name); exit(EXIT_FAILURE); } } getc(stdin); return 0; }

यह समाधान jack-smf-player

का उपयोग करके आपको jack-smf-player

माध्यम से मिडी फाइलें खेलने की भी अनुमति देता है, जिसे मैंने एआरएम और डब्ल्यूएवी / एमपी 3 के लिए संकलित किया है और ऑडियो आउटपुट के लिए jack-smf-player

लिए समर्थन के साथ mplayer द्वारा।

बोनस

पिछली पोस्ट पर nefelim4ag की टिप्पणी के लिए धन्यवाद, मैंने कामेच्छा के अस्तित्व के बारे में सीखा - एक पुस्तकालय जो आपको नियमित लिनक्स सिस्टम में एंड्रॉइड ड्राइवरों का उपयोग करने की अनुमति देता है। तंबूरा के साथ कुछ नृत्यों के बाद, जिनमें से सभी विवरण, दुर्भाग्य से, मुझे अब याद नहीं है, मैं अपने सिस्टम में लिबायब्रिबिस प्राप्त करने में कामयाब रहा और ओपन 5 ईएस 2.0, ईजीएलएफएस और क्यूटी क्विक 2.0 के लिए समर्थन के साथ क्यूटी 5 और पायक्यूटी 5 का पुनर्निर्माण किया। अब मेरा उपयोगकर्ता इंटरफ़ेस Qt क्विक का उपयोग करता है और एंड्रॉइड 4.0 के तहत ~~नवीनतम फैशन ट्रेंड्स के अनुरूप दिखता है~~ ।

अंत में

एक छोटा डेमो अब तक केवल ऑडियो है, क्योंकि सिंथेसाइज़र अब अर्ध-सॉर्टेड अवस्था में है। वीडियो अगली पोस्ट में होगा, जो कि संभवतः अगस्त में पैदा होगा, चीन में मदरबोर्ड के आने के बाद, सिंथेसाइज़र के सभी हिस्सों को एक साथ जोड़ता है। इसके अलावा, अगली पोस्ट सबसे अधिक संभावना है कि इस तरह के निम्न-स्तरीय कर्नेल जोड़तोड़ के लिए समर्पित नहीं होंगे, लेकिन PyQt5 और QtQuick पर सॉफ्टवेयर के उपयोगकर्ता भाग को ध्यान में रखने की प्रक्रिया और, परिणामस्वरूप, प्रदर्शन

अगर किसी को दिलचस्पी है:

एआरएम के लिए क्रॉस-संकलित किए गए सभी सॉफ़्टवेयर को सूचीबद्ध करें

alsa-लिब-1.0.27.2
alsa-utils-1.0.27.2
libaudiofile-0.3.6
dbus-1.8.0
dropbear-2014.63
FFTW-3.3.3
fluidsynth-1.1.6
fontconfig-2.11.0
freetype-2.5.3
चिकना-2.34.3
libicu-52.1
जैक ऑडियो-कनेक्शन किट-0.121.3
जैक smf-utils-1.0
libffi-3.0.13
libgig-3.3.0
libgig-SVN
libhybris
libsamplerate-0.1.8
libsndfile-1.0.25
linuxsampler-1.0.0
linuxsampler-SVN
mplayer SVN-r36900-4.4.6
openssl-1.0.0l
psutil-1.2.1
pyjack-0.5.2
PyQt-जीपीएल-5.2
pyserial-2.7
पायथन 2.7.6
strace-4.8
tslib-1.4.1

यदि आपको इस सूची से कुछ इकट्ठा करने और समस्याएँ उत्पन्न करने की आवश्यकता है, तो मैं ख़ुशी से अपना अनुभव साझा करूँगा। इसके अलावा, यहां जो कुछ भी कहा गया है, उसमें से एक अन्य लोकप्रिय प्लेटफॉर्म के लिए सही है, जिसे फ्रेंडलीम टिनीफ210 कहा जाता है, जो कि एस 5 पी वी 212 के एक ही प्रोसेसर पर आधारित है और, शायद, किसी को इसके साथ एक वास्तविक समय कोर का उपयोग करने की आवश्यकता होगी।

पुराने सिंथेसाइज़र का नया जीवन। भाग २

कीबोर्ड मैट्रिक्स

रियलटाइम प्रीमेशन सपोर्ट के साथ एक कर्नेल खाना बनाना

AVR माइक्रोकंट्रोलर LinuxSampler के साथ कैसे संवाद करता है

बोनस

अंत में

More articles: