ASIC रिपेयर गाइड: चिप की जांच और हैशबोर्ड कैसे बदलें

अगर आपका S19 Pro अपनी 110 TH/s की औकात दिखाना बंद कर दे, और वेब डैशबोर्ड पर पूरे 76 चिप्स की जगह 0 या टूटी हुई चेन दिखने लगे — तो समझ जाओ कि बोर्ड को तुरंत डायग्नोस्टिक बेंच पर ले जाने का टाइम आ गया है। 90% मामलों में यह ओवरहीटिंग के कारण चिप के डैमेज होने, LDO रेगुलेटर में शॉर्ट/पंचर होने या फिर PCB में माइक्रो-क्रैक आने की वजह से होता है।

S19 Pro हैश बोर्ड आर्किटेक्चर: डोमेन और सिग्नल कैसे काम करते हैं

Antminer S19 Pro के हैश बोर्ड पर कुल 76 BM1398 चिप्स लगे होते हैं, जिन्हें 19 सीरीज़ पावर डोमेन (हर डोमेन में 4 चिप्स) में बांटा गया है। मेन बस का कुल वोल्टेज (फर्मवेयर के हिसाब से लगभग 12.5–15V) इन सभी डोमेन में आपस में डिवाइड होता है। एक डोमेन को औसतन 0.7–0.8V मिलता है, जबकि खुद चिप का VCORE वोल्टेज लगभग 0.32–0.42V के आसपास होता है।

सिग्नल कंट्रोल बोर्ड के पास वाले 1st चिप से लेकर आखरी 76th चिप तक सीरीज़ में फ्लो करते हैं:

• CLK (25 MHz): क्लॉक सिग्नल। अगर यह मान लो 30वें चिप पर कट गया, तो उसके आगे के सारे चिप बंद पड़ जाएंगे।
• CO (Command Output): कंट्रोल बोर्ड से आने वाली इनपुट कमांड लाइन।
• RI (Return Input): कंट्रोल बोर्ड को वापस जाने वाली रिस्पॉन्स लाइन। यह उलटी दिशा में चलती है — 76वें चिप से 1स्ट चिप की तरफ।
• RST (Reset): रिसेट लाइन। इस पर लो वोल्टेज (Low logic level) आते ही चिप तुरंत हार्ड रिसेट में चला जाता है।
• BO (Busy Output): लाइन बिजी होने का सिग्नल।

स्टेप-बाय-स्टेप डायग्नोस्टिक्स: माइनर के लॉग से लेकर मल्टीमीटर चेकिंग तक

वेब इंटरफेस या कस्टम फर्मवेयर (VNish, HiveOS) के ज़रिए Kernel Log खोलें। सबसे पहले यह चेक करें कि सिग्नल चेन असल में कहाँ पर ब्रेक हो रही है।

लॉग्स में ध्यान देने वाली बातें:

• Chain 1: found 0 asics — RI लाइन से बिल्कुल भी रिस्पॉन्स नहीं आ रहा है। 1st चिप, उसका LDO सप्लाई या सिग्नल रिबन केबल कनेक्टर चेक करें।
• Chain 2: only 42 asics found — सिग्नल 42वें या 43वें चिप पर जाकर अटक गया है। सीधे इसी सेक्शन पर फोकस करें।
• Read temp sensor failed — TMP75 टेम्परेचर सेंसर उड़ गया है। S19 Pro में यह कई अलग-अलग डोमेन पर लगे होते हैं। सेंसर डेड होने पर सेफ्टी की वजह से बोर्ड बूट ही नहीं होगा।

टेस्ट पॉइंट्स (Test Points) का मेज़रमेंट

बोर्ड को किसी लैब सप्लाई/टेस्टर से पावर दें (मेन बस में हाई करंट दिए बिना) और मल्टीमीटर को डायोड मोड पर सेट करें (रेड प्रोब को GND पर रखें)।

[चिप 42] ---> (CO / CLK / RST) ---> [चिप 43]
[चिप 42] <--- (RI / BO)        <--- [चिप 43]

ग्राउंड के मुकाबले टेस्ट पॉइंट्स पर सिग्नल लाइन्स का रेजिस्टेंस पूरे बोर्ड पर लगभग सेम मिलना चाहिए:

• CLK, CO, RI, RST: लगभग 450–600 Ohms के आसपास।

अगर 43वें चिप पर CLK पॉइंट 0 Ohm (शॉर्ट) बीप करे या इन्फिनिटी (Open Circuit) दिखाए — तो समझो चिप गया, इसे बदलना पड़ेगा।

LDO पावर सप्लाई

हर डोमेन को चिप की इंटरनल लॉजिक चलाने के लिए एक्स्ट्रा सपोर्टिव वोल्टेज की ज़रूरत होती है। इन्हें छोटे LDO रेगुलेटर जनरेट करते हैं:

• VDD 1.8V: सिग्नल सर्किटरी को पावर देता है।
• VDD 0.8V: इंटरनल लॉजिक कोर को पावर देता है।

अगर चिप पर 1.8V तो मिल रहा है लेकिन 0.8V गायब है — तो चिप क्लॉक सिग्नल आगे फॉरवर्ड नहीं कर पाएगा और बोर्ड वहीं से चेन ड्रॉप कर देगा।

ऑसिलोस्कोप की ज़रूरत क्यों है और इससे टेस्टिंग कैसे करें

मल्टीमीटर सिर्फ एवरेज DC वोल्टेज दिखाता है। लेकिन जब वोल्टेज तो ठीक दिख रहा हो पर सिग्नल में नॉइज़ हो या एम्प्लीट्यूड गिर गया हो, तो मल्टीमीटर पूरी तरह बेकार साबित होता है। मल्टीमीटर आपको धोखा दे सकता है, पर ऑसिलोस्कोप (DSO) सीधे सिग्नल का वेवफॉर्म दिखा देता है।

इसके लिए कम से कम 100 MHz बैंडविड्थ वाला ऑसिलोस्कोप और 10X एटेन्युएटर प्रोब चाहिए।

CLK चेकिंग (25 MHz क्लॉक फ्रीक्वेंसी):

प्रोब को CLK टेस्ट पॉइंट पर रखें। आपको लगभग 1.8V एम्प्लीट्यूड की क्लीन साइन वेव या स्क्वायर वेव मिलनी चाहिए। अगर प्रॉपर सिग्नल की जगह 0.4V का दबा हुआ सॉ-टूथ (sawtooth) वेवफॉर्म दिख रहा है — तो चिप का इंटरनल बफर डैमेज हो चुका है और वह सिग्नल को आगे पुश नहीं कर पा रहा।

CO/RI डेटा पैकेट्स की चेकिंग:

बूट होते समय बोर्ड सिग्नल के छोटे पल्स पैकेट्स भेजता है। ऑसिलोस्कोप पर ये क्विक बर्स्ट (Bursts) की तरह दिखते हैं। अगर चिप 43 के इनपुट पर बर्स्ट आ रहा है लेकिन आउटपुट से कुछ नहीं निकल रहा — तो या तो चिप खराब है या उसका RST रिसेट पिन ज़ीरो (Low) पर अटका है।

पावर बस में नॉइज़/रिपल (Ripple):

स्कोप के इनपुट को AC मोड (AC Coupling) पर स्विच करें और सीधे चिप के नीचे लगे कैपेसिटर्स को मापें। 30–40 mV से ज़्यादा रिपल का मतलब है कि लगातार गर्मी की वजह से चिप के आसपास की सिरेमिक कैपेसिटेंस खराब हो चुकी है।

टेस्ट पॉइंट रेफरेंस गाइड (Antminer S19 Pro / BM1398)

सोल्डरिंग गाइड: BM1398 को सही तरीके से रिमूव और री-बॉल करना

S19 Pro के एल्युमीनियम बोर्ड्स बहुत भारी हीट सिंक की तरह काम करते हैं। अगर आप बिना नीचे से गर्म किए सिर्फ ऊपर से हॉट एयर गन मारोगे — तो पक्का बोर्ड की पैड उखड़ जाएगी और सब जलकर बेकार हो जाएगा।

ज़रूरी सामान:

• प्री-हीटर / बॉटम हीटर (थर्मल प्रोफाइल 160–180°C)।
• हॉट एयर सोल्डरिंग स्टेशन (चिप के साइज की नोजल)।
• नो-क्लीन BGA फ्लक्स (NC-559, Martin, या RMA-223)।
• 0.35 mm लेडेड सोल्डर बॉल्स या Sn63/Pb37 लेडेड सोल्डर पेस्ट (लेडेड पेस्ट 183°C पर पिघलता है, जिससे फैक्ट्री के बिना-सीसे यानी लीड-फ्री सोल्डर के मुकाबले काम बहुत आसान हो जाता है)।

स्टेप-बाय-स्टेप प्रोसेस:

1. बोर्ड को प्री-हीटर पर रखें और धीरे-धीरे 150–160°C तक प्री-हीट करें। अगर जल्दबाजी की, तो एक्सपेंशन डिफरेंस के कारण बोर्ड मुड़कर "केला" बन जाएगा।
2. चिप के नीचे हल्का सा फ्लक्स अप्लाई करें।
3. ऊपर से हॉट एयर गन से हीट करें (एयर गन का टेम्परेचर लगभग 340–360°C, मीडियम एयरफ्लो)। गन को गोल-गोल घुमाते रहें।
4. ट्वीजर (चिमी) से चिप को हल्का सा टच करके देखें: जैसे ही चिप सोल्डर बॉल्स पर "फ्लोट" करने लगे, उसे ध्यान से सीधा ऊपर उठा लें।
5. बोर्ड के पैड्स को तांबे की सोल्डर विक और रेज़िन से साफ़ करें, फिर थिनर (गैलोशा) या आइसोप्रोपिल अल्कोहल (IPA) से पूरी तरह क्लीन कर लें।
6. स्टेंसिल और लेडेड सोल्डर पेस्ट/बॉल्स की मदद से नए चिप को री-बॉल करें।
7. चिप को डॉट/की मार्क के हिसाब से अलाइन करें (चिप और बोर्ड पर बने निशान मैच होने चाहिए) और सही जगह पर बैठाएं।
8. प्री-हीटर पर रखें और ऊपर से हॉट एयर देकर जब तक सोल्डर पिघल न जाए, हीट करें। लिक्विड सोल्डर के सर्फेस टेंशन की वजह से चिप अपने आप बिल्कुल परफेक्ट जगह पर सेट हो जाएगा।

क्विक डायग्नोस्टिक्स के लिए Python लॉग पार्सर

लॉग्स को खुद बैठकर मैन्युअली न खंगालना पड़े, इसके लिए यह रहा एक रेडी-टू-यूज़ Python स्क्रिप्ट। माइनर का लॉग इसमें डालें, यह तुरंत ख़राब वाली चेन ढूँढकर बता देगा कि किस चिप पर सीधे मल्टीमीटर ठोकना है।

#!/usr/bin/env python3
import re
import sys
EXPECTED_ASICS = 76
def parse_asic_log(filepath):
    chain_pattern = re.compile(
        r"Chain\[(\d+)\]:\s*found\s*(\d+)\s*asics",
        re.IGNORECASE
    )
    sensor_pattern = re.compile(
        r"sensor[\[\s]*(\d+)[\]\s]*.*temp.*error",
        re.IGNORECASE
    )
    issues_found = False
    problem_chains = []
    reported_sensors = set()
    print(f"[*] लॉग की जाँच जारी है: {filepath}\n")
    try:
        with open(filepath, "r", errors="ignore") as f:
            for num, line in enumerate(f, 1):
                # चेन में चिप्स की गिनती चेक करें
                c_match = chain_pattern.search(line)
                if c_match:
                    chain_id = int(c_match.group(1))
                    found = int(c_match.group(2))
                    if found < EXPECTED_ASICS:
                        issues_found = True
                        problem_chains.append(
                            (chain_id, found, EXPECTED_ASICS)
                        )
                        print(
                            f"[!] चेन {chain_id}: कुल {EXPECTED_ASICS} में से केवल "
                            f"{found} चिप्स मिले।"
                        )
                        if found == 0:
                            print(
                                "    -> चेन का पहला चिप नहीं मिल रहा है।"
                            )
                            print(
                                "    -> बोर्ड की पावर, RI, "
                                "RST, BOOT और क्लॉक सिग्नल चेक करें।"
                            )
                        else:
                            print(
                                f"    -> चिप #{found} का आउटपुट (CLK/CO) "
                                f"चेक करें"
                            )
                            print(
                                f"    -> चिप #{found + 1} का इनपुट (RI) और "
                                f"LDO सप्लाई चेक करें"
                            )
                        print()
                # टेम्परेचर सेंसर एरर चेक करें
                s_match = sensor_pattern.search(line)
                if s_match:
                    sensor_id = int(s_match.group(1))
                    if sensor_id not in reported_sensors:
                        issues_found = True
                        reported_sensors.add(sensor_id)
                        print(
                            f"[!] टेम्परेचर सेंसर एरर "
                            f"#{sensor_id} (लाइन {num})."
                        )
                        print(
                            "    -> TMP75 सेंसर, उसकी पावर "
                            "और I2C लाइन्स की जाँच करें।"
                        )
                        print()
        # फाइनल समरी रिपोर्ट
        print("=" * 60)
        print("फाइनल डायग्नोस्टिक समरी")
        print("=" * 60)
        if not issues_found:
            print("[+] लॉग में कोई खराबी नहीं मिली।")
            return False
        if problem_chains:
            print("\nप्रॉब्लम वाली चेन्स:")
            for chain_id, found, expected in problem_chains:
                print(
                    f"  - Chain {chain_id}: "
                    f"{found}/{expected} ASIC"
                )
        if reported_sensors:
            print("\nटेम्परेचर सेंसर एरर्स:")
            for sensor_id in sorted(reported_sensors):
                print(f"  - Sensor {sensor_id}")
        print()
        return True
    except FileNotFoundError:
        print(f"[-] फ़ाइल नहीं मिली: {filepath}")
        return True
    except Exception as e:
        print(f"[-] फ़ाइल प्रोसेस करने में एरर: {e}")
        return True
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(
            f"यूसेज: {sys.argv[0]} <path_to_log.txt> "
            f"[expected_asics]"
        )
        sys.exit(1)
    if len(sys.argv) >= 3:
        try:
            EXPECTED_ASICS = int(sys.argv[2])
        except ValueError:
            print("[-] expected_asics एक नंबर होना चाहिए।")
            sys.exit(1)
    has_issues = parse_asic_log(sys.argv[1])
    sys.exit(1 if has_issues else 0)

रन करने का तरीका:

python diag.py kernel.log

अलग चिप्स काउंट वाले बोर्ड्स के लिए:

• python diag.py kernel.log 63
• python diag.py kernel.log 72
• python diag.py kernel.log 80

कैबिनेट में पैक करने से पहले फाइनल चेकलिस्ट

• VCORE बस रेजिस्टेंस: ग्राउंड के साथ शॉर्ट सर्किट (0 Resistance) नहीं होना चाहिए।
• बिना लोड के LDO वोल्टेज टेस्ट: लैब पावर सप्लाई से कनेक्ट करें और नए चिप पर 1.8V और 0.8V आ रहा है या नहीं, चेक करें।
• सिग्नल फ्लो टेस्ट: ऑसिलोस्कोप से चेक करें कि 25 MHz का क्लॉक सिग्नल नए लगे चिप से आगे पास हो रहा है या नहीं।
• फुल लोड स्ट्रेस टेस्ट: माइनर को वापस असेंबल करें, उसके स्टॉक फैन्स लगाएं, और 2–3 घंटे तक स्टॉक फर्मवेयर पर चलाकर उस पर्टिकुलर चेन के HW एरर्स मॉनिटर करें।