AMD-แ แซแแแแแ แแ แแแฃแฅแขแแฃแแ 2019 แฌแแแ แฉแแแขแแ แ, แกแแแแช Zen 2 แแแแ แแแ แฅแแขแแฅแขแฃแ แแแ แแแแแฃแแ แฃแแแ แแแ แแฎแแแ แแ แแแฃแฅแขแ แฌแแ แแแแแแ. แแฃแแชแ, แงแแแแแแ แจแแแแแแญแแแแ แแแแชแฎแแแแแแแ, แกแฃแ แแชแแ แ, แแแกแแขแแแแก แกแแแแแแขแจแ, แฌแแแก แแแแแกแแแแก แจแแแแแแแฎแ. แแแแแแ แแก แแแแแก แแแแแ แแ แแแกแแแ แแแแแแก Ryzen Threadripper แแ แแชแแกแแ แแแ แแแแแแแแ, แ แแแแแแกแแช แแแแแกแแแแ แ แแแงแแแ แฃแแแก แแแแชแแแ แจแแแซแแแ แ แแแแ แช แแแแแแแแแแ แแแ แแแแแแก แ แแแแแแแแแ, แแกแแแ แจแแแแแแแแแฃแแ แจแแกแ แฃแแแแแก แแแแแ. แแฃแแชแ, แแแแกแแแฃแแ แแแแ แกแแกแแแแแแแ แแงแ แแก, แ แแ AMD-แ แคแแกแแแ แแ แแแแแ แแ: 32-แแแ แแแแแแ AMD Ryzen Threadripper 3970X แแ 24-แแแ แแแแแแ Threadripper 3960X แแแ แขแแแแ แจแแแซแแแแ แจแแแซแแแแ แแแแแแแแฃแแแฃแ แแ แแแแฎแแแ แแแแแแแ, แ แแแแแแแช แฅแแแแแ แแ แแแฃแจแแแแแแ แชแแคแ แฃแ แแแแขแแแขแก แแ แแคแแกแแแแแแฃแ แแ แแฃแแแแช แกแแแแงแแแ แฃแแ แแแแแแ แแ แกแแญแแ แแแแแ แแแแจแแแแแแแแ แแแแแแแแแ แกแแแซแแแแ แแก.

แแฃแแชแ, แกแแแแ แแแแแแแแแกแแแแก แฃแแแ แแฆแแแแจแแแก, แ แแ แแฎแแแ แแแกแแแ แแแแแแก Ryzen Threadripper แแ แแ แแก แแแ แแแแ แแ แขแแแแก แแ แแชแแกแแ แ. แแแแ แฌแแแแแแ แแแแแแ แแกแแแ แแแแแแ แฉแแแแแแ แ แแแแ แช แแแฌแแแแแ แแ แแแแแแแ แแแแแแ แจแแกแแซแแแแแแแแแแ, แแกแแแ แแแ แแแแก แจแแแแ แแแแ แแแแแแ แแ แแแฃแแแก แฆแแ แแแฃแแแแแ. แแฃแแชแ, AMD Ryzen Threadripper 3970X แแ Threadripper 3960X แแแแแช แแแแแ แแแแกแฎแแแแแแฃแแ แจแแแแแแแแแแแแ. แแแแ แฌแแแแแแ แแแแแแแกแแแ แแแแกแฎแแแแแแแ, แแแ แแแแฆแแก แแแชแแแแแแ แแแกแแฎแแ แฎแแแแแ แแ แแแแแ แแแแแ UMA แขแแแแแแแแ. แแแ แแ แแแแกแ, แแ แแชแแกแแ แแแแก แแฎแแ Zen2 แแแแ แแแ แฅแแขแแฅแขแฃแ แแแ แแแแแกแแแแกแแแ แแ แแแ, AMD-แ แแแแฃแแฏแแแแกแ แแแแแกแ แแแแแ แแแกแแขแแแแก HEDT แแแแขแคแแ แแ, แฌแแแ X399 แฉแแแกแแขแ แฉแแแแแชแแแ แฃแคแ แ แแฎแแแ TRX40 แกแแกแขแแแแก แแแแแแฃแ แ แแแแ แแแแ. แแแกแจแ แแแแแแ แ แกแแแฎแแแ แแ แแชแแกแแ แแแ แแแแแแจแแ แแแแก แแแแขแแ แฃแแแ แแแแแแแก แแแแจแแแแแแแแแ แแ แแ: แแ แแแแแแแแกแแแแก แแฎแแ แแแแแแงแแแแแ PCI Express 4.0 x8 แแแขแแแฃแกแ, แ แแช แแแแแ แฃแคแ แ แ แแฃแแ แแ แคแฃแแฅแชแแแแแแฃแ แ แกแแกแขแแแแแแก แจแแฅแแแแก แจแแกแแซแแแแแแแแแก แฅแแแแก.

แแฃแแชแ, แแงแ แแแ แแแแฃแแ แแแแ แแแแ แแแแแแแแแ: แแฎแแแ แแแแแแฃแ แ แแแแ แแแแก แแแแแ แแแแ แแแแแแฌแแแ แแแแกแแแแแแแแก แแแแแ แแแ แฌแแแ แแ แแแแแแแแ แ แแแแแแแแก Ryzen Threadripper แแ แแชแแกแแ แแแก แจแแ แแก. แแฎแแแ 24 แแ 32 แแแ แแแแแแ แแ แแชแแกแแ แแแ แแแแแฎแแแก แแฎแแแ แแแแแแแแขแแแแก แแแแแงแแแแแแก, แ แแแแแแแช แแฅแกแแแฃแแแฃแ แแ TRX40-แแแ แแแแแฃแแ. แแก แแ แแแแจแแแแแแแแแ แแฆแฃแแแแก แจแแกแแซแแ แแแ แแแแขแแแก แแแฆแแแ แฎแแ แแกแฎแแก แแแแคแแแฃแ แแชแแแแแก แแฌแงแแแแกแแก. แแฃแแชแ, แฃแกแแแแ แแแ แแฅแแแแ แแฃ แแแขแงแแแ, แ แแ แแแแแแแแขแแแแก แแฌแแ แแแแแแแแแ แแแแฃแแแแกแขแแแ แแแฃแ แแแแแแแแแจแ แแแขแแแแก: แฃแแแ แแแแแชแฎแแแแ แกแฃแ แแชแแ แ แแแแฃแแ แแแแแแแแขแ, แ แแแแแแแช แแแแ แแ แแแ แแแแฆแแ Ryzen Threadripper 3970X แแ Threadripper 3960X. แแ แแแแแฎแแแแแจแ แฉแแแ แแแแแชแแแแแ Gigabyte-แแก แแแแ แจแแแแแแแแแแแฃแ แแ แ-แแ แ แแกแแ แแแคแแก.
AMD TRX40 แกแแกแขแแแแก แแแแแแฃแ แ แแแแแแแฅแขแ: แ แ แแ แแก แแฎแแแ
แแ แ-แแ แแ แงแแแแแแ แแแแจแแแแแแแแแ แแแแขแคแแ แแแก แแแฃแแฏแแแแกแแแ, แ แแแแแแช AMD-แ 7-แแ แขแแฅแแแแแแแแแ แแ แแชแแกแแ แแแแก แฌแแ แแแแแแแ แแแแแกแแแแกแแแ แแ แแแ แแแแแฎแแ แชแแแแ, แแงแ PCI Express 4.0 แแแขแแแฃแกแแก แคแแ แแแ แแแแแงแแแแแ, แ แแแแแกแแช แฉแแแฃแแแแ แแ PCI Express 3.0-แแแ แจแแแแ แแแแ แแ แฏแแ แแแขแ แแแแขแแ แแแ แฐแฅแแแแ. แแแแแแแแ แแแแแ, แแแฆแแแกแแฉแฅแแ แแแแ แแแขแแแฃแกแแก แแฎแแ แแแญแแ แ แแแแแฉแแแ แแแแฎแแแ แแแแแก X570 แแแแกแแกแขแแแแจแ แแ Ryzen 3000 แแ แแชแแกแแ แแแจแ, แแฎแแ แแ แแก แฃแคแ แ แแแฆแแแ แแแแกแแก แแ แแแฃแฅแขแแแแ - Ryzen Threadripper-แกแ แแ TRX40 แกแแกแขแแแฃแ แแแแแแฃแ แแแแ แแแแ แแแแแแแแ. แแแแแแ แแฃแแแ, HEDT แแแแขแคแแ แแแก แจแแแแฎแแแแแจแ, AMD-แ แแแแแขแแแแ แแแฃแจแแแ แแแแก แฃแแ แฃแแแแแกแแงแแคแแ, แ แแ แแ แแชแแกแแ แกแ แแ แฉแแแกแแขแก แจแแ แแก แแแแจแแ แแก แแแแขแแ แแแ แแแแ แแแแแงแ แแ แ แแ แฏแแ , แแ แแแแ แแแแแ แฃแคแ แ แแแขแแ - แแแฎแฏแแ (3,94-แแแ 15,75 แแ/แฌแ-แแแ).
แแก แแแแฆแฌแแแ แแแแ, แ แแ แแ แกแแกแขแแแแก แแแแแแแแแขแแแก แจแแ แแก แแแแจแแ แ แฃแแ แฃแแแแแงแแคแแแแ แแ แ แแแฎแ, แ แแแแ แช แแแ แ, แแ แแแแ แ แแ PCI Express แฎแแแแ. แจแแแแแแ, TRX40-แแ แแแคแฃแซแแแแฃแแ แแแแ แแแคแแแ แแแแแแแแแแแ แแแ แแแแช แแแฆแแแกแแฉแฅแแ แแแ แแแแจแแ แแแก แจแแแแฎแแแก แแแแแแกแแแแก, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ แแ แ แแฎแแแแ แแแ แแแแแ แแ แแชแแกแแ แแแ, แแ แแแแ แฉแแแกแแขแแแแแช. แแแแแแฃแ แแแแแแแฅแขแกแ แแ แแ แแชแแกแแ แก แจแแ แแก แแแแจแแ แ แแฆแแ แฌแแ แแแแแแแแก แจแแแแคแแ แฎแแแแ แคแแฅแขแแ แก.

แแแแแแแแ TRX40-แก แแฅแแก แแแแ แ แแแแแแแแแ แแแฆแแแกแแฉแฅแแ แแแแ แแแขแแ แคแแแกแแแ, แแ แฉแแแแแแก แฌแแ แแแแแ GlobalFoundries-แก แแแแแแแ, แกแแแแช แแ แแแแแแ 12 แแ แขแแฅแแแแแแแ แแแแแแงแแแแแ. แจแแแแแแ, แ แแแแ แช X570-แแก แจแแแแฎแแแแแจแ, แฉแแแกแแขแแ แแแแฎแแ แฎแ 16 PCI Express 4.0 แฎแแแแก แแฎแแ แแแญแแ แแก แฉแแ แแแ, แ แแแแแแ แแแแแงแแแแแ แจแแกแแซแแแแแแแ แแแแแขแแแแแ แแแฌแงแแแแแแแแแแก แแแกแแแแแจแแ แแแแแ. แแก แฎแแแแแ แจแแแซแแแแ แแแแแแ แแแก SATA แ แแแแแจแ, แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แซแแแแ แแแกแแแแแก แแฎแแ แแแกแแญแแ แแ, แแแแ แแ แกแแแ แแ แฏแแแจแ, แแฎแแ Ryzen Threadripper-แแ แแแคแฃแซแแแแฃแ แกแแกแขแแแแแก แจแแฃแซแแแแ แแแแฎแแแ แแแแแก แจแแกแแแแแแแ 72 PCI Express 4.0 แฎแแแ - 56 แแ แแชแแกแแ แ แแ 16 แฉแแแกแแขแ.

TRX40-แแก แแแแแ แแ แแ แแแแจแแแแแแแแแ แแแฃแแฏแแแแกแแแ, X399-แแแ แจแแแแ แแแแ, แแ แแก 10 แแแแข/แฌแ USB 3.2 Gen2 แแแ แขแแแแก แ แแแแแแแแแก แแ แแ. แฉแแแกแแขแแก แแแแแแ, แแฎแแ แแกแแแ แ แแ แแแ แขแแ, แแแจแแ แ แแชแ แแแ แ X399-แก แแฎแแแแ แแ แ แฐแฅแแแแ. แแแ แแ แแแแกแ, TRX40-แก แแฅแแก แแแฎแ USB 2.0 แแแ แขแ, แ แแช แจแแแซแแแแ แจแแกแแคแแ แแกแ แแงแแก แแแฌแงแแแแแแแแแแกแแแแก, แ แแแแแแแช แแ แแ แแแ แแแแแขแแแ แแฃแแแ แแแแขแแ แฃแแแ แแแแแแแ. แกแแแแขแแ แแกแแ, แ แแ AMD-แ แกแ แฃแแแแ แแแแขแแแ 5 แแแแข/แฌแ USB 3.2 Gen1 แแแ แขแแแแก แแแแแขแแแแก แแแแ แแแแแก แแฎแแ แกแแกแขแแแฃแ แแแแแแฃแ แแแแแแแฅแขแจแ. แแกแแแ แแแ แขแแแแก แแแแแ แแแ แแแกแแแ แแแแแแก Ryzen Threadripper-แแก แแฎแแ แแแแ แแแคแแแแ แจแแกแแซแแแแแแแ แแฎแแแแ แแแแแขแแแแแ แแแแขแ แแแแ แแแแก แแแแแงแแแแแแ.
| TRX40 | X570 | X399 | |
|---|---|---|---|
| แแ แแชแแกแแ แแแ | Ryzen Threadripper-แแก แแแกแแแ แแแแแ | Ryzen-แแก แแแแ แ แแ แแแกแแแ แแแแแ | Ryzen Threadripper แแแ แแแแ แแ แแแแ แ แแแแแ |
| แแ แแชแแกแแ แแแ แแแแแแจแแ แแแ | PCIe x8 | PCIe x4 | PCIe x4 |
| PCI Express แแแ แกแแ | 4.0 | 4.0 | 3.0 |
| แแแ แ PCI Express แฎแแแแแแก แ แแแแแแแแ | 16 | 16 | 8 |
| USB 3.2 Gen2 แแแ แขแแแ | 8 | 8 | 2 |
| USB 3.2 Gen1 แแแ แขแแแ | 0 | 0 | 4 |
| USB 2.0 แแแ แขแแแ | 4 | 4 | 6 |
| SATA | 4 | 4 | 8 |
| TDP | 15 W | 11 W | 5 W |
แแแกแแแ แแแแแแก Ryzen แแ แแชแแกแแ แแแแก แแแแแจแแแแแก แจแแแแแ, แฉแแแ แฃแแแ แแแชแแ, แ แแ AMD-แแก แกแแกแขแแแฃแ แแแแแแฃแ แแแแ แแแแแก, แ แแแแแแแช แแฎแแ แก แฃแญแแ แแ PCI Express 4.0 แแแขแแแฃแกแก, แฃแฉแแแฃแแแ แแแฆแแแ แกแแแแแก แแแคแ แฅแแแแ แแฅแแ. TRX40 แแแแแแแแแแกแ แแ แแ แแก แแ แแแกแแแแก แแแแแชแฎแแแแแฃแแแ 15 แแแขแแแแ แแแ แแฃแแ แแแแแขแ, แ แแช แแแแแ แฃแคแ แ แแแฆแแแแ, แแแแ แ Socket AM4 X570 แกแแกแขแแแฃแ แ แแแแแแฃแ แ แแแแ แแแแแแก แกแแแแ แแฃแแ แกแแแแแก แแแคแ แฅแแแแ. แแก แแแจแแแแก, แ แแ Ryzen Threadripper แแ แแชแแกแแ แแแแก แแฎแแแ แแแแ แแแคแแแ แงแแแแแแแแก แแแแแแงแแแแแแ แฉแแแกแแขแแก แแฅแขแแฃแ แแแแ แแแแแแก, แ แแแแแก แแแ แแจแแช แแฅแแแแ แกแ แฃแแแแ แจแแกแแซแแแแแแ แแงแ.
แ แแแแ แช แฃแแแ แแฆแแแแจแแแ, แแฎแแแ แแแแแแฃแ แ แแแแ แแแแก แแแแแ แแแแ แแแแแแแ แแแแฎแแแแ แฌแแแ แแ แแฎแแแ แแแแแแแแก HEDT แกแแกแขแแแแแก แจแแ แแก แแแแกแแแแแแแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแฎแแแ AMD Ryzen Threadripper 3970X แแ Threadripper 3960X แแแแ แฉแฃแแแแแ แซแแแ แคแแ แ-แคแแฅแขแแ แก แแ LGA แแแแแแแก 4096 แแแแขแแฅแขแแ, แแกแแแ แแ แแ แแแ แแแแกแแแแแ แแแแแแแ แฌแแแแแแ แแแแแแแแ. แคแแแแแฃแ แแ, แแแแขแแฅแขแแก แแแขแ แแชแ แแ แจแแชแแแแแ, แแแแ แแ PCI Express 4.0-แแก แแแแแ แแแแ แแแแแฎแแแ แแแแแแ แแ แแแแแก แแแแแญแแแแก แชแแแแแแแ. แจแแแแแแ, แแฎแแแ Ryzen Threadripper แแแ แแฃแจแแแแก X399 แแแคแแแแ, แฎแแแ TRX40-แแ แแแคแฃแซแแแแฃแแ แแแคแแแ แแ แแ แแก แแแแกแแแแแ Ryzen Threadripper แแ แแชแแกแแ แแแแก แแแ แแแ แแ แแแแแแกแแแ.

แแแแแแ แแฃแแแ, แแแฃแ แแแแแแแ แแแแแแแก แแแแ, AMD-แ แแ แจแแชแแแแ Socket SP3 (sTR4)-แแก แแแแ แแ แแแแคแแแฃแ แแชแแ แแ โแแแกแแฆแแแแแแกโ แแแแแแ แแแแ แกแแแแขแแก แฉแแ แฉแแแ แจแแแแแ แฉแฃแแ. แแฆแแแฉแแแ, แ แแ แแแฅแแแแแฃแ แแ, แกแฎแแแแแกแฎแแ แแแแแแก แแ แแชแแกแแ แแแ แฃแ แแแแ แแจแแแชแแแแแแแ แแ แแแ แแ แจแแฃแแแแกแแแแแแ แแฎแแแแ แแแแแแฃแ แแ แแแแฅแขแ แฃแ แแแแแแ แแ แกแแแแแก. แแฃแแชแ, AMD แแแแแ แแแแ, แ แแ Ryzen Threadripper-แแก แแ แแกแฌแแ แ แแแแแแก แแแแ แแแคแแแ แแแงแแแแแแ แแ แฃแแแ แแแแแแฌแแแแก แ แแแแ แกแแแฌแฃแฎแแ แ แจแแแแแ. แกแแกแขแแแ แฃแแ แแแแ แแ แฉแแแ แแแแแ, แแแแ แแ แแ แช แแ แแชแแกแแ แ แแ แแ แช แแแคแ แแ แแแคแฃแญแแแแ.
แขแแฅแแแแฃแ แ แแแฎแแกแแแแแแแแแ
แแแแแแแแขแแแแก แแฌแแ แแแแแแแแก แจแแ แแก, Gigabyte-แแ แแแแแแแแ แจแแแแแแแแแแแแก แงแแแแแแ แคแแ แแ แแ แฉแแแแแ แแแกแแแ แแแแแแก Ryzen Threadripper แแ แแชแแกแแ แแแแกแแแแก. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแแกแ แแแแแฃแ แแแขแแแแก แฃแแแขแแกแแแ แแฎแแแแ แแ แแ แแ แแ แ แแแแแแแ แจแแแแแคแแ แแแแแแแ, Gigabyte-แแ แแแแแแแแ แกแฎแแแแแกแฎแแ แแแแแก แแแฎแ แแแคแ. แแ แแแแแฎแแแแแกแแแแก แแฌแแ แแแแแแแกแแแ แแแแแฆแแ TRX40 Aorus Master แแแแแแแแขแ, แ แแแแแแช แกแแจแฃแแแ แแแแแก แแแ แแแแขแแ.

แงแแแแแแ แแแฎแแแฌแแแ Gigabyte แแแคแ, TRX40 Aorus Xtreme, แแแแงแแแก แแ แ 10 แแแแแแแขแแแแ แฅแกแแแแก แแแแขแ แแแแ แแ, แแแฎแ M.2 แกแแแขแแ PCI Express 4.0 x4 แแแกแแแแแก แแฎแแ แแแญแแ แแ แแ CPU-แก แแแแแแก แกแฅแแแแ 16 แแ แฎแแก แแคแแแแแแแแแ. แแ แแแแแฎแแแแแก แแแแ แ, TRX40 Aorus Master, แฃแคแ แ แแแ แขแแแ แแแคแแ, แแแแ แแ แแแฃแฎแแแแแแ แแแแกแ, แแก แแแแ แฉแฃแแแแก แแซแแแแฌแแแแแแ แแ แแแฃแฅแขแแก แแแแ แแแฎแแกแแแแแแแแก. แแแ แแแแแแแแแฃแแแ E-ATX แคแแ แ-แคแแฅแขแแ แจแ, แแฆแญแฃแ แแแแแ แแแฎแ PCI Express x16 แกแแแขแแ แแ แแฅแแก 5 แแแแแแแขแแแแ Aquantia แฅแกแแแแก แแแแขแ แแแแ แ แแ Wi-Fi 6 แกแขแแแแแ แขแแก แฃแแแแแแ แฅแกแแแแช แแ. แแแแ แแ แงแแแแแแ แแแแจแแแแแแแแแ แแก แแ แแก, แ แแ, แซแแแแ แแแแแแแก แแกแแแแกแแ, แแก แแฆแญแฃแ แแแแแ 16-แคแแแแแแ แแแแแแแแก แแซแแแแ แ แแแแแแก แกแฅแแแแ. แแแแแ แฃแแแ แแแแแแแฎแแแแแ แงแฃแ แแแฆแแแ, แ แแแแแ แแฎแแ แแ แแชแแกแแ แแแก แแฅแแ แฃแแ แแแแ โแแแแแแแโ แแแ แแฃแแ แแแแแขแ 280 แแแขแแก แแแแแแ แแ แแแแกแแแแแก, แ แแ แแกแแแ CPU แฃแแ แฃแแแแแงแแคแแแ แแงแแก แแแฆแแแ แฎแแ แแกแฎแแก แกแแแซแแแแ แแ, แแแแ แแแคแแแ แแแแแแก แฌแ แ แฃแแแ แแงแแก แจแแฅแแแแแ แซแแแแแ, แซแแแแแ แคแ แแฎแแแแ แแ แฃแกแแคแ แแฎแแแแแก แแแแ แแฆแแ แแ.
| แแแแแแแแขแ TRX40 Aorus Master | |
| แแฎแแ แแแญแแ แแแ แแ แแชแแกแแ แแแ | AMD Ryzen Threadripper แแ-3 แแแแแ |
| แฉแแแกแแขแ | AMD TRX40 |
| แแแฎแกแแแ แแแแก แฅแแแกแแกแขแแแ | 8รDDR4, 256 แแ-แแแ, DDR4-4400-แแแ, แแแฎแ แแ แฎแ |
| แแแคแแ แแแแแแก แกแแแขแแแ | 2 ร PCI Express 3.0/4.0 x16 (x16 แ แแแแแ); 2 ร PCI Express 3.0/4.0 x16 (x8 แ แแแแแ); 1รPCI Express 4.0 x1 |
| แแแกแแแก แแแขแแ แคแแแกแแแ | 8 ร SATA 6 แแ/แฌแ 1รM.2 (PCI-E 4.0/3.0 x4/SATA 2242/2260/2280/22110 แคแแ แแแขแแก แแแฌแงแแแแแแแแแแกแแแแก) 2 ร M.2 (PCI-E 4.0/3.0 x4/SATA 2242/2260/2280 แคแแ แแแขแแก แแแฌแงแแแแแแแแแแกแแแแก) |
| USB แแแ แขแแแ | แฃแแแแ แแแแแแแ 5รUSB 3.2 Gen2; 1รUSB 3.2 Gen2 Type-C แฃแแแแ แแแแแแแ; 1 ร USB 3.2 Gen2 Type-C, แ แแแแ แช แจแแแ แแแแแฅแขแแ แ; 4 ร USB 3.2 Gen1 แจแแแ แแแแแฅแขแแ แแแแ; 6 ร USB 2.0 แจแแแ แแแแแฅแขแแ แแแแ |
| แฅแกแแแแก แแแแขแ แแแแ แแแ | 1รIntel WGI211AT (Ethernet 1Gbps); 1 ร Aquantia AQtion AQC111C (Ethernet 5 Gbps); 1 ร Intel Dual Band Wireless AX200NGW/CNVi (Wi-Fi 802.11a/b/g/n/ac/ax (2,4/5 GHz) + Bluetooth 5.0) |
| แแฃแแแ แฅแแแกแแกแขแแแ | 1 ร Realtek ALC4050H + Realtek ALC1220-VB แแแแแแ; 1 ร Realtek ALC4050H แแแแแแ + ESS SABRE9218 DAC |
| แฃแแแแ แแแแแแแก แแแขแแ แคแแแกแแแ | 1รUSB 3.2 Gen2 (แขแแแ-C); 5 ร USB 3.2 Gen2 (แขแแแ-A); 2 ร USB 2.0; 2รRJ-45; 5 ร แแแแ-แฏแแแแก แแฃแแแ แแแแแฅแขแแ แแแ; 1 ร S/PDIF (แแแขแแแฃแ แ, แแแแแแแแแแ); 2 ร แแแขแแแแก แแแแแฅแขแแ แแแ; ClearCMOS แฆแแแแแ; Q-Flash Plus แฆแแแแแ |
| แคแแ แแ แคแแฅแขแแ แ | E-ATX (305ร269 แแ) |
| แคแแกแ | 499 แแจแจ แแแแแ แ (แ แแแแแแแแแแฃแแแ) |
Gigabyte TRX40 Aorus Master-แแก แ แแแแแแแแแแฃแแ แคแแกแ แแฌแแ แแแแแแแก แแแแ 500 แแแแแ แแ แแ แแก แแแแแแแแแ, แแฃแแชแ Ryzen Threadripper-แแกแแแแก แแแแแฃแแแแแแ แแแแแแแแขแแแ แแแคแ แแแ แแฅแแแแ. แแฅ แแแแจแแแแแแแแ แ แแแก แแแแแจแแแก แแแแ แ แแฃแแ แแแแฅแขแ แ แแแแแแแ, แแแฆแแแแแแแแแแ แแแฃแแ แแแคแแ แแแแแแก แจแแกแแซแแแแแแแแแ แแ แแก แคแแฅแขแ, แ แแ แแแแ แแ แแแแขแคแแ แแแก แแแ แแแแฃแแ แแ แแแแฃแ แแแแกแ แแฅแแก, แ แแแแแ Ryzen Threadripper 3970X-แแกแ แแ Threadripper 3960X-แแก แ แแแแแแแแแแฃแแ แคแแกแแแ 1400 แแ 2000 แแแแแ แแ. แแแ แแ แแแแกแ, แฃแแแ แแแฆแแแ แแ, แ แแ AMD-แแก แคแแแแแแแฃแ แ แแ แแชแแกแแ แแแแกแแแแก แแแแแฃแแแแแ แกแฎแแ แแแแแแแแขแแแแแ แจแแแแ แแแแ, TRX40 Aorus Master แแ แช แแกแ แซแแแ แแ. แแแแแแแแแ: แแแกแแแ แแแแแแก Ryzen Threadripper-แแกแแแแก แแแแแฃแแแแแแ แงแแแแแแ แแแฃแฏแแขแฃแ แ แแแแแแแแขแแแ 400 แแแแแ แ แฆแแ แก, แฎแแแ แแแแ แคแแกแแก แแฆแแแ แ 850 แแแแแ แแแแ แแฆแฌแแแก.
แจแแคแฃแแแ แแ แจแแคแฃแแแ
แแแฃแฎแแแแแแ แแแแกแ, แ แแ แซแแแ แแแฆแแ แแแฃแ แแ แแ แแแแแคแฃแแฅแชแแฃแ แแแแแแแแขแแ แแกแแฃแแ แแแ, Gigabyte TRX40 Aorus Master แจแแแแ แแแแ แแแขแแ แ แงแฃแแจแแ แฌแแ แแแแแแแแแ, แ แแแแแก แแแแแแแช แแแแแ แแ แแแแกแฎแแแแแแแ แกแแจแฃแแแ แคแแกแแก แแแแแแแแแแก แแแแแแแแขแแแแก แงแฃแแแแแกแแแ.
![]() | ![]() |
แจแแคแฃแแแแก แกแแแแคแแ แแแชแแ แจแแแแแ แกแ แแแกแแฆแแแ แแแแแกแแ. แฃแแแแ แแฎแแ แแก แแแชแแแฃแแแ แแแฎแแกแแแแแแแแแแก แแแแแ แกแแ, แแกแแแ แแแคแแ แแแชแแ แแแคแแก แซแแ แแแแแ แฃแแแ แแขแแกแแแแแแก แจแแกแแฎแแ. Gigabyte-แก แแแงแแแแ แแซแแแแ แ แแ แแชแแกแแ แแก แแแแแแก แฌแงแแ แ, แแแ แแแ แแแแแ แแแฃแแ แแแแแแก แฌแ แแแแก แแแแ แแแแแ, แแแฎแ PCI Express x16 แกแแแขแ แแ แแขแแแแแแก แแแแแฎแ แแแ แกแแแก แแฎแแ แแแญแแ แแ, แฅแกแแแแก แแแแขแ แแแแ แ 5 แแแแข/แฌแ แแแแขแแ แฃแแแ แแแแแแแ แแ Wi-Fi 6 แกแขแแแแแ แขแแก แฃแแแแแแ แแแแฃแแแแแชแแ.
แแแคแแก แแแงแแแแ แกแฎแแแแแกแฎแแ แแฅแกแแกแฃแแ แแแแก แกแแแแแแ แแแแ แ แแแแแแแแ:
- แแแฎแ SATA แแแแแแ;
- แแ แแ Wi-Fi แแแขแแแ 4 dBi-แแก แแแซแแแแ แแแแ;
- G-Connector แแแแฃแแ LED-แแแแกแ แแ แแแ แแฃแกแแก แฆแแแแแแแแก แแแ แขแแแ แจแแแ แแแแแกแแแแก;
- แแ แแ แแแแแแ แแแกแแแแ แแแแแแ LED แแแแแแแก แแแกแแแแแจแแ แแแแแ;
- แแ แแ แแแแแแ RGB LED แแแแแแแก แแแกแแแแแจแแ แแแแแ;
- แแ แแ แฎแแแก แฌแแแแแก แกแแแกแแ แ;
- แแ แ Velcro-แก แกแแแแแแแ แจแแกแแแ แแแ;
- แแ แ แแแกแขแแแชแแฃแ แ แขแแแแแ แแขแฃแ แแก แกแแแกแแ แ;
- แฎแ แแฎแแแแ แแ แกแแงแ แแแแแแ M.2 แแแกแแแแแก แแแกแแแแแขแแแแแแแ;
- แกแขแแแแ แแแแก แแแแ แแแ แกแฎแแฃแแแก แแแแแ แแชแแแกแแแแก.

แแแแแแ แแฃแแแ, แแแฌแแแแแแก แแแแ แแแแแแ แแแแแแแแแแ แ, แชแฎแแแแ, แ แแ Gigabyte-แแก แแแ แแ แฅแแแจแ แแแชแแแฃแแ แแแแ แแแคแ แแ แแ แแก แคแแแแแแแฃแ แ แแแแแฌแงแแแขแแแแแแแแก แแ แ-แแ แแ. แแ แแฌแแ แแแแแแแก แงแแแแแแ แซแแแ แแแฆแแ แแแฃแแ แแแคแแแ, แ แแแแ แช แฌแแกแ, แแแฌแแแแแฃแแแ แแแแแขแแแแแแก แแแแจแแแแแแแแแ แฃแคแ แ แแ แชแแแ แกแแแ.
แแแแแแแ แแ แแแฎแแกแแแแแแแแแ
Gigabyte TRX40 Aorus Master แแฎแแแ Ryzen Threadripper-แแก แแแ แแแแ แแแแ แแแคแแ, แ แแแแแแช แฉแแแแก แแแแแ แแขแแ แแแจแ แแแแแแ. แแก แแแฎแแ แแแแแ, แกแแแแ แฉแแแ แแแแฅแแแแแแ แจแแกแแซแแแแแแแ แแแขแแแฃแ แแ แแแแชแแแแแแแ Zen 2 แแแแ แแแ แฅแแขแแฅแขแฃแ แแก แแ แแแแแแแ แแแแแ แแ แฎแฃแแฉแแแแแขแแแ แแ แแชแแกแแ แแแก แแแฅแแแแแแแจแ. แแแแขแแ, แแแแกแแแฃแแ แแแแ แแแแแแขแแ แแกแแแ Gigabyte-แแก แแแคแแ. แแแ แแแ แ แแแจแ, แซแแแแแ แกแแแแขแแ แแกแ แแงแ, แแฃ แ แแแแ แแแแฎแแ แฎแแก แแแแแแแแแ แแแแ แแ แแ แแแแแ แกแแแขแแก, แแแแขแ แแแแ แแกแ แแ แแแแแฅแขแแ แแก แแแ แแแแ, แ แแแแแแ แแแแกแแฎแฃแ แแแแช แแแแแแแแ แแแ Ryzen Threadripper-แก แจแแฃแซแแแ TRX40 แกแแกแขแแแแก แแแแแแแกแแแ แแ แแแ แกแขแแแแแ แขแฃแ PCB-แแ. แแแแ แแช, แแกแแแ แซแแแแแ แกแแแแขแแ แแกแ แแงแ, แแฃ แ แแแแ แจแแแซแแแแ แแแแแแงแฃแ แแแแแแก แแ แแชแแกแแ แแก แแแแแแก แกแฅแแแ แแ แ แแแแ แฃแแแ แแแชแแแแแก แแก, แ แแแ แแแแแแแงแแคแแแแก 300 แแแขแแแแ แแแฎแแแ แแแแก แแ แแชแแกแแ แแแแก แกแแญแแ แแแแแแ แแแแแแแแฃแ แ แแแแแจแแช แแ.

แแ แฃแแแ แแแฅแแแก, แ แแ Gigabyte TRX40 Aorus Master-แแ แจแแซแแ แแแแแฏแแ แแแแแ แแแกแฃแฎแแแแก แแแชแแแ แงแแแแ แแกแแ แแแแฎแแแแ. แแแแ แแ แฃแแแ แแแแแก แงแแแแแกแ, แแแ แซแแแแแ แแแแแแ แแฉแแแแ, แ แแ Ryzen Threadripper-แแกแแแแก แแแแแแแแขแแแแก แจแแฅแแแ แกแแ แแแแฃแ แกแแแแแแแ แ แกแแแฃแจแแแแแก แแแแแฎแแแก แแ แจแแแแแแ, แแกแแแ แแแคแแแแก แแแแแแแ แกแแแแแแ แแ แแกแขแแแแแ แขแฃแแ แแแแแแแก. แแแแแแแแแ, แแแชแแแฃแแ Gigabyte แแแคแ แแแแแแแแแฃแแ แแงแ แแแแแแแแฃแแ แแแฎแแแ แแ E-ATX แคแแ แ-แคแแฅแขแแ แแ (แกแแแแแ 269 แแ แฉแแแฃแแแแ แแแ 244 แแ-แแก แฌแแแแแฆแแแแ), แแแแ แแ แแแแก แแแฃแฎแแแแแแ, แแแกแแฃแ แ Socket sTR4 แแ แแชแแกแแ แแก แกแแแแขแ, แ แแ DIMM แกแแแขแ แแ แแแแแก แแแแแแงแแแแ แแแแแช แแแแแแแแ แแแก แแแแ แแแแ แแแฎแแแแ แก. แแแแแแ แแฃแแแ, แแแแแก แฌแ แแแแก แแแแแแ แแแแแแแ แแแแจแแแแแแแแแ แแฆแแแฉแแแ, แ แแ แแก แแแแแแแแ แแแแแแก แแแคแแก แแแแ แแแแ แแแแแก แแแกแฌแแ แแ, แฎแแแ แแแกแ แแแแ แแแแแแก แกแแกแขแแแ แแแแแแแแ แแแ แแแแฃแ แแแแแแก, แแแ แจแแ แแก แแแคแแก แฃแแแแ แแแฌแแแจแ.

แแแฃแฎแแแแแแ แแแแกแ, TRX40 Aorus Master-แแแ แแฃแจแแแแ แกแแแแแแ แแแกแแฎแแ แฎแแแแแ แแฆแแแฉแแแ. แแแฃแฎแแแแแแ แแแแกแ, แ แแ แแ แแแคแแแ แแแฎแกแแแ แแแแก แกแแแขแแแ แแ แแชแแกแแ แแก แแฃแแแกแแแ แกแแแแแแ แแฎแแแกแแ แแแแแแแกแแแฃแแ แแ แแกแแแ แแแ แแแ PCIe x16 แกแแแขแกแ แแ แแแแ แแแแแ แแแแแแก แแแแแแก แ แแแแแขแแ แก แจแแ แแกแแ แแแญแแ แแแ, Gigabyte TRX40 Aorus Master-แแ แแแคแฃแซแแแแฃแแ แกแแกแขแแแแก แแฌแงแแแแกแแก แแ แแแแแ แ แแ แแแแแแ แแ แแ แกแแแแแก, แงแแแแ แจแแแแฎแแแแแจแ, แแฃ แแ แแชแแกแแ แแก แแแกแแแ แแแแแแแ แแฎแแแแแ แแแแ แแแแแแก แกแแกแขแแแแก แแงแแแแแ แแ แแ แ แ แแแแ แแแแแแขแฃแ แฐแแแ แแก แแแแแแ แแแแแแแก. แฃแคแ แ แแแขแแช, แแ แแแคแแแ แงแแแแ แแแแแแ แ แแแแแฅแขแแ แ แแ แจแแแ แแแ แขแ แแแ แฏแแแแ แแ แฅแแแแ แแแแแแแแแ แแแแแแแแแฃแแ แแ แแแแแ แฌแแแแแ แกแ แฃแแแ แแฌแงแแแแ แกแแกแขแแแแจแแช แแ แแ แแ แแก แ แแฃแแ.

แแแแ แก แแแแแ แแแฃแฎแแ แแแแ แแก แคแแฅแขแ, แ แแ Gigabyte TRX40 Aorus Master แแแแฅแแแก แแแแแแแแ แแ แแงแแแแแก แแแแแแแแแ แแแแแแแแก แแแแแแแขแแแก. แแแแแแแแก แแแแ แฃแแ แฃแแแแแงแแคแแแ แแ แแแแแ แแ RGB แแแแแแแแแขแแ แฃแแแแ แแแแแแแก แแแ แแฃแกแจแ แแ แกแแแฃแแ แแแขแแ แ แแ แซแแแแแ แแแแ แซแแแแแฃแแ โแแแแแโ, แ แแแแแแช แกแฃแแแช แแ แแ แฆแแแแก TRX40 Aorus Master-แแกแแแแก แแ แฉแแฃแ แแแแชแ แแแแฃแแแฃแ แกแขแแแก. แแฃแแชแ, แคแแ แแแแก แแฃแแขแแก แแแแฎแ แแแแ แแแแแแแ แจแแซแแแแแ แแ แแแคแแ แกแแกแขแแแแก แชแแกแแ แขแงแแแแก แงแแแแ แคแแ แแ แแแแ แฌแงแแแแแแก. แแแแแก แแ แแแแแก, แแแแแแแแ แแแแ แแแ แ LED แแแแแแแก แจแแกแแแ แแแแแแ แแแฎแ แฌแแ แขแแแ แแแแแแแแแกแฌแแแแก: แแ แ แแแกแแแแ แแแกแแแแก แแ แแ แ แฉแแแฃแแแแ แแแ 5050 RGB LED-แแกแแแแก.

แแแคแแ แแแแแแก แแแ แแแแแแก แแแกแแงแแแแแแแ, Gigabyte TRX40 Aorus Master แแแแแแแแแ แแแฎ PCIe x16 แกแแแขแก. แงแแแแ แแแแแแแ แแแแแแจแแ แแแฃแแแ แแ แแชแแกแแ แแก PCI Express แฎแแแแแแแ, แแแ แแแ แแ แแแกแแแ แกแแแขแแแแ แแแแชแ แแ แแแแแงแแคแแแแ 16 PCI Express 4.0 แฎแแแ, แฎแแแ แแแแ แ แแ แแแแแฎแ แกแแแขแแแแ - 8. แแฃแแชแ, แฃแแแ แแแแแแแแแแกแฌแแแแ, แ แแ แแแแ แฃแ แแแแ แแแแแแแแแแแก แแแแ, แแแแจแ แแฎแแแแ แกแแแ แแแ แแแแก แแแแแแขแแแแแแ แจแแกแแซแแแแแแ แแ แแแแ แกแแแขแแแแ แแแแ แแแแแแก แกแแกแขแแแแ. แ แแช, แแฃแแชแ, แกแแแแแ แแกแแ แแแขแแ, แแแแกแแแฃแแ แแแแ แแฃ แแแแแฎแกแแแแแ, แ แแ Aorus-แแก แแแแ แแขแฃแ แ แซแแ แแแแแแ แแแแแแ แแแแแ แแ แแแแขแแ แแแฃแแ.

แแ แแชแแกแแ แจแ แแแ แฉแแแแแ แ แแ PCI Express 4.0 แฎแแแ แแแแแงแแคแแแแ แแ M.2 แแแแแฅแขแแ แแ, แ แแแแแแแช แแแแแแแแแฃแแแ แแแ แแแแ แแ แแแกแแแ PCIe x16 แกแแแขแแแแก แฅแแแจ. Gigabyte TRX40 Aorus Master-แแ แแแงแแแแแฃแแ แกแแกแขแแแฃแ แ แแแแแแแก แฅแแแจ แแ แแก แแแแแ แแ แแ, แแแกแแแ M.2 แกแแแขแ, แแแแ แแ แแแก แแฃแจแแแแแแ แแแกแฃแฎแแกแแแแแแแแ TRX40 แฉแแแ. แงแแแแ M.2 แกแแแขแแก แแแแแแ แแแแ แแแแ แแแแแแก แแแแแกแแแ แแกแแ แแ แช แแฃ แแกแ แแแ แแแ, แแแแ แแ แแ แแแแแแแฌแงแแแ, แ แแ Ryzen Threadripper-แแกแแแแก แแแคแแแแ แแแแ แแแแแกแฃแคแแแ แแแแแแ แแ แแ แแก. แแแ แแ แแแแกแ, TRX40 Aorus Master-แแ แแ แกแแแฃแแ แแแกแแแแแกแแแแก แแแแแแแแกแฌแแแแแฃแแแ แ แแแแแขแแ แแแ, แ แแแแแแแช แกแแแแแแ แกแฅแแแ แแแฃแแแแแก แคแแ แคแแขแแแแ แแแแแแแแ แแแฃแแ แแ แแคแแแแ, แแแแขแแ แแแแแฎแฃแ แแแแ แกแแคแ แแฎแ แแ แฃแแแ แจแแฃแฅแแแแก แแ แแแฃแฅแขแแฃแ NVMe SSD แแแแแแแแก, แแแจแแแแช แแ, แแฃ แแกแแแ แแแแแแแแแฃแแแ แฃแจแฃแแแแ แแ แแคแแแฃแแ แแแแฉแฅแแ แแแแแก แฅแแแจ.

แแ แแแแแแแ, Gigabyte-แแ แซแแแแแ แแแกแฃแฎแแกแแแแแแแแแ แแแฃแแแ แแแคแแก แกแฎแแแแแกแฎแแ แแแแแแแแแขแแก แแแแ แแแแแแก. แแแแแแแแแ, แฉแแแกแแขแแ แแแแแแขแแแแแฃแแแ แกแแแแแแ แแแแ แ แแแแแขแแ แ, แ แแแแแแช แแฆแญแฃแ แแแแแ 50 แแ-แแแแ แชแแแขแ แแแแแฃแแ แแแแขแแแแขแแ แแ. แฃแคแ แ แแแขแแช, แงแแแแแแ แฎแจแแ แแ แแก แแแแขแแแแขแแ แ แแแแแแขแแ: แฉแแแกแแขแแก แขแแแแแ แแขแฃแ แ แแจแแแแแแ แแฆแแแแขแแแ 50 แแ แแแฃแกแก แแแกแแฃแ แ แแแแ แแแแแแก แแ แแกแแช แแ แแ แแแแขแแแแขแแ แ แแฎแแแแ แแ แแแจแแฃแแแก แแแแแญแแ แแแแแกแแก แแ แแแแแ.

แแฃแแชแ แงแแแแแแ แจแแแแแแญแแแแ แแก แแ แแก, แแฃ แ แแแแ แฎแแแแ แแแแแแก แแแแแแก แแแแ แแแแแ. RX40 Aorus Master-แแก แชแฎแแแ แแแแแแก แแแแแแแแแขแแแ แแแแแแแแแฃแแแ แแ แ แ แแแจแ แแแคแแก แแแแ แแแแแก แแแกแฌแแ แแ, แงแแแแ แแแคแแ แฃแแแ แแ แแ แ แแแแแขแแ แแ, แ แแแแแกแแช แแฅแแก แแแแแชแแแแแ แแ แแฎแแแ แแแฃแแแแแก แคแแ แคแแแแ. แแแ แแ แแแแกแ, แแแแแชแแแแแ แแ แซแแแแแแ แฃแคแ แ แจแแ แก, แแแแแก แแแคแแก แฃแแแแ แแแแแก แแแกแฌแแ แแ แฅแแแแแ, แกแแแแช แแก แแแแแแ แแแฃแแแ แแแแแ แแ แ แแกแแแแก แ แแแแแขแแ แแแ แฃแแแแ แแแแแแแก แแแ แกแแก แแ แแจแ แแ แแแก แฅแแแจ แแแกแแฃแ แแแฃแแแแแก แแแแแแแ.

แแก แงแแแแแคแแ แ แกแแจแฃแแแแแแก แแซแแแแ แแคแแฅแขแฃแ แแ แแแแ แซแแแแ แกแแแซแแแแ แแก แกแแคแแฎแฃแ แแแแก แแแฆแแ แกแแแฃแจแแ แขแแแแแ แแขแฃแ แแก, แแฃแแชแ แแแแฆแแแแแกแแแแก, Gigabyte-แแก แแแแแแ แแแแ แแกแแแ แแแแแแขแแก แแแแขแแแแขแแ แ, แ แแแแแแช, แแแแแแก แแแฎแแแแแ, แฃแแแแ แแแแแแแก แแแ แแฃแกแแก แแแแแแแจแ แแแแ แ แ แแแแแขแแ แแก แแแจแแแแแแ แฃแแแ แฅแ แแแแแแก.

แแแแ แแ, แ แแแแ แช แฉแแแก, แฃแแแแแกแ แแฅแแแแแแ, แแฃ แแแแก แแ แแแแแแแแแแแแ. แคแแฅแขแแ, แ แแ แแ แแแแขแแแแขแแ แก แแฅแแก 30 แแ แแแแแแขแ แ แแ แแ แฃแแแแก แกแแฉแฅแแ แ แฌแฃแแจแ 10 แแแแก แแ แฃแแแแแ. แแแฅแกแแแแแฃแ แ แกแแฉแฅแแ แแก แแ แแกแแช แแ, แ แแแแแกแแช แแก แแฆแฌแแแก, แ แแแแกแแช แแแแแแก แฌแงแแ แแก แฌแ แแแแก แขแแแแแ แแขแฃแ แ 100 แแ แแแฃแกแก แแฆแฌแแแก, แแแกแ แแคแแฅแขแฃแ แแแ แจแแแซแแแแ แแญแแฅแแแจ แแแแงแแแแ. แแแแ แแ แแก แฅแแแแก แคแแแฃแ แฎแแแฃแ แก แแแจแแแแช แแ, แ แแแแกแแช แแแขแแแ แแแ แแชแแ แแ, แ แแแแแ แแ แแแแจแแแก แแแแแแแแฃแ แ แแ แฃแแแแก แกแแฉแฅแแ แ แฌแฃแแจแ 5 แแแแกแ แแ แฃแแแ.
แแฃแแแแ แแแ แแแแฎแแ แฉแแแแแ: แแแแแแแแแ แกแญแแ แแแแ แแฃ แแ แ Gigabyte TRX40 Aorus Master-แก แแกแแแ แแแฎแแแฌแแแ VRM แแแแ แแแแแแก แกแแกแขแแแ? แแ แฉแแแ แจแแแแแซแแแ แแแแแแแแแ แแฃแแแกแฃแฎแแ. แแแคแแก แกแแแซแแแแ แแก แแแแแแงแแแแ แแฃแจแแแแแก แแ แแก แจแแกแแแฉแแแแแ แชแฎแแแแแแ. แแแแแแแแแ, TRX40 Aorus Master-แแก แขแแกแขแแแแก แแ แแก 24-แแแ แแแแแแ Ryzen Threadripper 3970X แแ แแชแแกแแ แแ, Precision Boost Override แคแฃแแฅแชแแแก แฉแแ แแแแ, แแ แแชแแกแแ แแก แแแฎแแแ แแแแ แจแแแซแแแแ แแแแฆแฌแแแก 320-380 แแแขแก, แ แแแแแก แแ แแกแแช VRM แขแแแแแ แแขแฃแ แ 80 แแ แแแฃแกแก แแฆแฌแแแแ.

แแฃ แแแ แแแ แแแแแแแ แแแแแ, แแฃ แ แแแแ แแ แแก แแแฌแงแแแแแ แแแแแแก แฌแงแแ แแก แฌแ แแแ, แแแแแแ แแแกแแแแแแ, แแฃ แกแแแแแ แแแแแก แแก แแแแแแแ. แฉแแแ แฏแแ แแ แแแแแแฎแแแก แแกแแแ แแซแแแแ แ แแแแแแก แฌแงแแ แแก แฌแ แแแแแ แกแแแแแฎแแแ แแแแ แแแแแแแแขแแแจแ, แ แแแแแ Gigabyte TRX40 Aorus Master-แจแ แแแแแแงแแแแ แแฌแงแแแแแแ 19 แแแแแฃแแแแแแแแ แแ แฎแแก แแฅแแแ แฌแ แแแแก แแแฎแแแแแ.

แแฅแแแแ 16 แแ แฎแ แแแแแ แแ แแชแแกแแ แก แแแแแแ, แฎแแแ แแแแแ แกแแแ แแ แฎแ แแแแแแแก แแ แแชแแกแแ แแก SoC-แก. แแ แฉแแแ แแกแแฃแแ แแแ แกแ แฃแแแแ แแแขแแแกแแ แคแแแแแแ: แแ แฌแ แแแจแ แแ แแ แแก แแแแ แแแแแแแแแ แแ แแแ แแแแแฃแ แ แแแแแแแขแแแ. แแ แแชแแกแแ แแก แคแแแแแก แแแแแขแ แแแแแก แกแแ แแแ แแก แแแแแก PWM แแแแขแ แแแแ แ Infineon XDPE132G5C, แฎแแแ แแแแแแฃแ แแ แฎแก แแฅแแก 70 แแแแแ แแแแ แกแแแซแแแแ แแก แกแแคแแฎแฃแ แ Infineon TDA21472.

แ แแช แจแแแฎแแแ แแ แแชแแกแแ แแก SoC-แก, แแแก แแแแแแก แฌแงแแ แแแ แแแกแฃแฎแแกแแแแแแแแ แชแแแแ International Rectifier IR35204 แกแแแคแแแแแแ PWM แแแแขแ แแแแ แ, แ แแช แกแแแแแแ แฏแแแจแ แกแแจแฃแแแแแแก แแซแแแแก TRX40 Aorus Master-แก แกแแญแแ แแแแแก แจแแแแฎแแแแแจแ, แแ แแชแแกแแ แก แแแแฌแแแแก 1330 A-แแแ แแแแฃแ แ แแแแแแ.

แแญแแแแ แแจแแ, แ แแ แแฎแแแ Ryzen Threadripper แงแแแแแแ แแแแ แแแแแฎแแแ แแแแแ แกแแแแแฎแแแ แแแแ แแ แแชแแกแแ แแแแ, แแฃแแชแ แซแแแแแ แชแแขแ แแแคแแก แแฅแแก แแกแแแ แแแฌแแแแแ แแแแแแก แกแฅแแแแแ, แแฃแแแแช แแฎแแแแ Socket sTR4 แแแแขแคแแ แแแก แจแแแฎแแแแ. แกแแแแแแแแแแจแ, แแฎแแแแ แแแก แฃแคแ แแก แซแแแแก, Aorus Xtreme-แก แแ Designare-แก, แแกแแแ MSI TRX40 Creator-แก, แจแแฃแซแแแแ แแแแแฃแ แแแชแแ แแแฃแฌแแแ Gigabyte TRX40 Aorus Master-แก แแแแฅแขแ แแแแแ แแแแก แแแแแกแแแ แแกแแ.

แแแแแแก แแแแแแก แแแ แแ, Gigabyte TRX40 Aorus Master-แก แแกแแแ แแฅแแก แแแ แแ แแแฎแแกแแแแแแแแแ, แ แแช แกแแจแฃแแแแแแก แแซแแแแ แแ แแแคแแก แแฅแกแแแ แแแแแขแแแแกแแแแก แแแแแงแแแแแ. แแแ แแฆแญแฃแ แแแแแ แแ แ BIOS แฉแแแแ, แ แแแแแแ แจแแ แแก แแแแแ แแแ แจแแกแแซแแแแแแแ แแแแ แแขแฃแ แฃแแ แแแแแแ แแแแแแก แแแแแงแแแแแแ. แแแแแแ แแฃแแแ, BIOS แฉแแแแแแแแ แแ แ-แแ แแ แแแแแแขแแแแแฃแแแ โแกแแฌแแแจแโ, แ แแช แแแกแ แแแ แขแแแ แฉแแแแชแแแแแแก แจแแกแแซแแแแแแแแแ แแแฃแแแแแแก. แฃแคแ แ แแแขแแช, แแ แแแแแแแแแก แจแแแแฎแแแแแจแ, firmware-แแก แแแแแฎแแแแ แจแแกแแซแแแแแแแ แกแ แฃแแแแ แแแขแแแแแแฃแ แแ: แกแแกแขแแแแก แฉแแ แแแ แแ แกแญแแ แแแแ.

แแแแแแแแแ แแแแ แแ แแแแแแแก แแ แแแคแแก แแแแแแขแแก แกแ แฃแแคแแกแแแแแ POST แแแแแก แแแแแแแขแแ แ, แแกแแแ แแแแ แแขแฃแ แฃแแ แฉแแ แแแแก แแ แแแแแขแแแ แแแแก แฆแแแแแแแ, แ แแช แแแแคแแ แขแก แแแขแแแก TRX40 Aorus Master-แแก แฆแแ แกแแแแแแแ แแแแแงแแแแแแก. แกแฎแแแแ แจแแ แแก, แแ แกแชแแแแ แจแ แแกแแแ แแแกแแฎแแ แฎแแแแแแ, แ แแ แแแคแแก แฅแแแแ แแแฌแแแ แแแคแแ แฃแแแ แแแฃแแแแแก แคแฃแ แชแแแ โแแแแแแแ แแแแแกโ แกแแคแแ แแ, แ แแช แแ แ แแฎแแแแ แแแแ แแแก แแแแแ แแกแแแแแแแก แกแแแงแแ แแก, แแ แแแแ แแแแ แแแแแแก แกแแกแขแแแแก แแแแแขแแแแ แแแกแแฃแ แแแแแแแขแกแแช แฌแแ แแแแแแแแก.

แแแแแแแก, แแแแฃแแแแกแขแแแ แแแแแแแแแ แแแแคแแกแแแแ แแแคแแแ แฌแแ แขแแแแแแก แแ แกแแแแแแก แแฃแแขแแแแขแ แแก แแแแแงแแแแแแ แแแแแแ แ แซแแแแแแแก แแแแแขแแ แแแแแกแแแแก.

Gigabyte-แแก แแแแแแ แแแแ แแกแแแ แแแแแแก แแแ, แ แแแ แแแแฎแแแ แแแแแกแแแแก แกแแแแแแแแแ แแแแฆแแ แแแแ แแขแฃแ แฃแแ แแแแแขแแ แแแแแก แแแแแ แแแแกแแก. แแแคแ แแฆแญแฃแ แแแแแ แแฅแแกแ แขแแแแแ แแขแฃแ แแก แกแแแกแแ แแ แแ แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแจแแ แแ แแ แ แแแ แ แกแแแกแแ แ (แแแงแแแแ) แแ แแกแแแ แจแแแแซแแแแ แแแ แแแ แแ แ แแ แแชแแกแแ แ แแ แแฅแแกแ แแแ แแฃแกแแก แแแแขแแแแขแแ แ, แ แแแแ แช แกแแ-แแแแแแแ, แแกแแแ แแแฎ-แแแแแแแ แจแแแ แแแแแ. แแฃแแชแ, แแแแ แแแคแแก แจแแฃแซแแแ แแแแก แแแแแแแแ, แแแแ แแ TRX40 Aorus Master แแแแแแ แฉแแแ แแแแ, แ แแ แแแก แแฅแแก แฃแแแแแแฃแ แ แแแกแขแแแชแแฃแ แ แฎแแแก แฌแแแแแก แกแแแกแแ แ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแแแแแ แแ แแแแแขแ แแแแ แแ แ แแฎแแแแ แขแแแแแ แแขแฃแ แ, แแ แแแแ แแแแ แแชแแฃแแ แกแแกแขแแแแก แแแแ แแแแแ แแ แแแฃแแ แฎแแแฃแ แแก แแแแแช.

แแแแแ แแ แแ แแแฎแแกแแแแแแแแ, แ แแแแช แจแแแซแแแแ แแแแแแแ แแแก TRX40 Aorus Master-แแก แแแขแแแชแแฃแ แ แแแแฎแแแ แแแแแแ, แแ แแก แแแกแ แซแแแแแ แแขแแแแฃแ แ แแแขแแแ แแ แแแฃแแ แแฃแแแ. แคแแฅแขแแ, แ แแ Realtek ALC1220 แแแแแแแก แแแ แแ, แ แแแแแแช แแแแแฎแแกแแแแแแแแแ แซแแแ แแแฆแแ แแแฃแแ แแแคแแแแกแแแแก, แฎแแแก แกแฅแแแ แแกแแแ แจแแแชแแแก แแ Realtek ALC4050H แฉแแแก. แแแแแแ แแก แแ แแก, แ แแ TRX40 แกแแกแขแแแแก แแแแแแฃแ แแแแแแแฅแขแก แแ แแฅแแก แกแแแฃแแแ แ แแฃแแแ แแแขแแ แคแแแกแ, แแแแขแแ แแฌแแ แแแแแแแแแ แฃแแแ แแแซแแแแแ แแแ แแแแฃแแ แจแแแแแแแแ แแแแแ Ryzen Threadripper-แแก แแแคแแแจแ. แแแแแแแแแ, แแแแกแแฎแแแแแ Gigabyte แแแคแแแ, แฎแแแแ แแแกแฃแฎแแกแแแแแแแแ แแ แ แแแขแแแ แแ แแแฃแแ แฎแแแก แแแ แแแ, แ แแแแแแแช แแแแแแจแแ แแแฃแแแ USB 2.0 แแแขแแ แคแแแกแแ แแ แแกแแแ แฌแแ แแแแแแแแแแ Realtek ALC4050H แฉแแแแแแ.

แแ แแ แแแ แแแ แแแกแแฎแฃแ แแแ แฃแแแแ แแแแแแแ แแ แกแแแฃแ แแแแแแแฃแ แแแ แขแแแก - แแแแ แแฃแจแแแแแกแแแแก แกแแญแแ แแ Realtek ALC1220 แแแแแแ, แฎแแแ แแแ แแฃแกแแก แฌแแแ แแแแแแแก แแแแแกแแแแแก แฃแแ แฃแแแแแงแแคแก แแแแ แ แฎแแแก แแแ แแแ, แ แแแแแก แแฃแจแแแแแจแแช แฃแจแฃแแแแ แแแแแฌแแแแแแก ESS SABRE9218 DAC, แ แแแแแกแแช แจแแฃแซแแแ แแแฆแแแ แฌแแแแฆแแแแก แงแฃแ แกแแกแแแแแแแก แแแแแชแแแ.

TRX40 Aorus Master แแกแแแ แแ แแกแขแแแแแ แขแฃแแแ แแฎแแ แชแแแแแแก แฅแกแแแฃแ แแแขแแ แคแแแกแแแก. แฉแแแฃแแแแ แแแ Intel WGI211AT แแแแแแแขแแแแ แแแแขแ แแแแ แแก แแแ แแ, แแแคแแก แแแแแแขแ แแแแแ แแ แแ แฉแแแ - Aquantia-แก AQtion AQC111C. แแ แฉแแแก แจแแฃแซแแแ แกแแแแแแแแ แฅแกแแแแก แแฎแแ แแแญแแ แ แกแขแแแแแ แขแฃแแ แแ แแฎแแแ แฌแงแแแแแก แแแจแแแแแแ 5 แแ 2,5 แแแแขแ/แฌแ แกแแฉแฅแแ แแ, แ แแช Gigabyte แแแคแแก แแแแกแแแแแก แฎแแแก แแฎแแแ แแแแแแก แฅแกแแแฃแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแกแแแ. แแแแแแแก, แแแแช แฃแแแ แแขแแกแแแแก แแแแญแแแก แฃแแแแแแ แแแแจแแ แแแก, TRX40 Aorus Master แแแแแแแแแ แฌแแแแกแฌแแ แแแแแกแขแแแแ แแแฃแ Intel Wi-Fi 6 AX200 แแแแฃแแก. แแก แแแแฃแแ แแแแกแแแแแแ IEEE 802.11ax แกแขแแแแแ แขแแแ แแ 2T2R แแแแคแแแฃแ แแชแแแจแ แจแแฃแซแแแ แแแแแชแแแแ แแแแแชแแแแก 2,4 แแแแขแ/แฌแ แกแแฉแฅแแ แแก แฃแแ แฃแแแแแงแแคแ. แแก แแกแแแ แแฎแแ แก แฃแญแแ แก Bluetooth 5 แกแขแแแแแ แขแก.
แ แแแแ แช แฉแแแก, แงแแแแ แแ แแแแแ แแชแฎแแแแแ แแแขแแ แคแแแกแแก แแแแแแแแแแ แกแ แฃแแแ แฃแแแ แแแกแแแแแก Gigabyte TRX40 Aorus Master-แแก แฃแแแแ แแแแแแก. แกแแแแแแแแแแจแ แแ แแ แ, แแแ แแฅแแ, แแก แกแแแแแแ แแแแแกแฃแคแแแ แแฆแแแฉแแแ. Gigabyte-แแ แแแแแฌแงแแแขแ แ แแแแแแแแ USB แแแ แขแแก แจแแฌแแ แแ แแ แจแแแแแแ, แฃแแแแ แแแแแแแ แแแแแแแช แแ แแแฉแแแ VRM แ แแแแแขแแ แแก แแแแแแ แแแแแแแแแแฅแแ แแแแขแแแแขแแ แแกแแแแก.

แแฃแแชแ, แแ แแแแแแ แแแฅแแแ, แ แแ แซแแแแแ แชแแขแ USB แแแ แขแแ แแแ แฉแแแแแ, แ แแแแแ แกแแแ แแ แฏแแแจแ, แฃแแแแ แแแแแแแ แจแแแแ USB 3.2 Gen2 Type-A, แแ แแ USB 3.2 Gen2 Type-C แแ แแ แ USB 2.0 แแ แแก. แแแ แแ แแแแกแ, แแแ แแแแ แแแ แแ แแก แแ แ RJ-45 แฅแกแแแแก แแแแแฅแขแแ แ (แแแแแแแขแแแแ แแ แฎแฃแแแแแแแแขแแแแ), แแ แ Wi-Fi แแแขแแแแก แแแแแฅแขแแ แ, แฎแฃแแ แแแแแแแฃแ แ แแฃแแแ แแฃแแ, แแแขแแแฃแ แ S/PDIF แแแแแแแแแแ แแ แแ แ แฆแแแแแ: BIOS แแแ แแแแขแ แแแแก แแแแแขแแแ แแแแกแ แแ แแแขแแแแแแฃแ แ firmware แแแแแฎแแแแแกแแแแก. แแฆแกแแแแจแแแแแ, แ แแ I/O Shield-แแก แฃแแแแ แแแแแแแก แจแขแแคแกแแแ แฌแแแแกแฌแแ แแ แแก แแแแแกแขแแแแ แแแฃแแ แแแคแแแ, แ แแช แแแแ แขแแแแแก แกแแกแขแแแแก แแฌแงแแแแก แแแ แแฃแกแจแ.
แฌแงแแ แ: 3dnews.ru


