ಬೆಕ್ಕಿನೊಳಗೆ ಘೇಂಡಾಮೃಗ - ಕಾಪಿಕ್ಯಾಟ್ ಎಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ರನ್ ಮಾಡಿ

ಸಭೆಯ ಭಾಗವಾಗಿ 0x0A DC7831 DEF CON ನಿಜ್ನಿ ನವ್ಗೊರೊಡ್ ಫೆಬ್ರವರಿ 16 ರಂದು, ಬೈನರಿ ಕೋಡ್ ಎಮ್ಯುಲೇಶನ್ ಮತ್ತು ನಮ್ಮ ಸ್ವಂತ ಅಭಿವೃದ್ಧಿಯ ಮೂಲ ತತ್ವಗಳ ಕುರಿತು ನಾವು ವರದಿಯನ್ನು ಪ್ರಸ್ತುತಪಡಿಸಿದ್ದೇವೆ - ಹಾರ್ಡ್‌ವೇರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಎಮ್ಯುಲೇಟರ್ ಕಾಪಿಕ್ಯಾಟ್.

ಈ ಲೇಖನದಲ್ಲಿ ನಾವು ಎಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ಸಾಧನ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಬೇಕು, ಡೀಬಗರ್‌ನೊಂದಿಗೆ ಸಂವಹನವನ್ನು ಪ್ರದರ್ಶಿಸುವುದು ಮತ್ತು ಫರ್ಮ್‌ವೇರ್‌ನ ಸಣ್ಣ ಡೈನಾಮಿಕ್ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಹೇಗೆ ಮಾಡುವುದು ಎಂದು ವಿವರಿಸುತ್ತೇವೆ.

ಪೂರ್ವೇತಿಹಾಸದ

ದೂರದ ನಕ್ಷತ್ರಪುಂಜದಲ್ಲಿ ಬಹಳ ಹಿಂದೆಯೇ

ಒಂದೆರಡು ವರ್ಷಗಳ ಹಿಂದೆ ನಮ್ಮ ಪ್ರಯೋಗಾಲಯದಲ್ಲಿ ಸಾಧನದ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ತನಿಖೆ ಮಾಡುವ ಅಗತ್ಯವಿತ್ತು. ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಸಂಕುಚಿತಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಬೂಟ್‌ಲೋಡರ್‌ನೊಂದಿಗೆ ಅನ್ಪ್ಯಾಕ್ ಮಾಡಲಾಗಿದೆ. ಅವರು ಇದನ್ನು ಬಹಳ ಸಂಕೀರ್ಣವಾದ ರೀತಿಯಲ್ಲಿ ಮಾಡಿದರು, ಮೆಮೊರಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ಹಲವಾರು ಬಾರಿ ಬದಲಾಯಿಸಿದರು. ಮತ್ತು ಫರ್ಮ್ವೇರ್ ಸ್ವತಃ ನಂತರ ಪೆರಿಫೆರಲ್ಗಳೊಂದಿಗೆ ಸಕ್ರಿಯವಾಗಿ ಸಂವಹನ ನಡೆಸಿತು. ಮತ್ತು ಇದೆಲ್ಲವೂ MIPS ಕೋರ್‌ನಲ್ಲಿ.

ವಸ್ತುನಿಷ್ಠ ಕಾರಣಗಳಿಗಾಗಿ, ಲಭ್ಯವಿರುವ ಎಮ್ಯುಲೇಟರ್‌ಗಳು ನಮಗೆ ಸರಿಹೊಂದುವುದಿಲ್ಲ, ಆದರೆ ನಾವು ಇನ್ನೂ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಬಯಸುತ್ತೇವೆ. ನಂತರ ನಾವು ನಮ್ಮದೇ ಆದ ಎಮ್ಯುಲೇಟರ್ ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ, ಅದು ಕನಿಷ್ಠವನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು ಮುಖ್ಯ ಫರ್ಮ್ವೇರ್ ಅನ್ನು ಅನ್ಪ್ಯಾಕ್ ಮಾಡಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಾವು ಅದನ್ನು ಪ್ರಯತ್ನಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದು ಕೆಲಸ ಮಾಡಿದೆ. ಮುಖ್ಯ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ನಾವು ಪೆರಿಫೆರಲ್‌ಗಳನ್ನು ಸೇರಿಸಿದರೆ ಏನು ಎಂದು ನಾವು ಯೋಚಿಸಿದ್ದೇವೆ. ಇದು ತುಂಬಾ ನೋಯಿಸಲಿಲ್ಲ - ಮತ್ತು ಅದು ಸಹ ಕೆಲಸ ಮಾಡಿದೆ. ನಾವು ಮತ್ತೊಮ್ಮೆ ಯೋಚಿಸಿದ್ದೇವೆ ಮತ್ತು ಪೂರ್ಣ ಪ್ರಮಾಣದ ಎಮ್ಯುಲೇಟರ್ ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ.

ಫಲಿತಾಂಶವು ಕಂಪ್ಯೂಟರ್ ಸಿಸ್ಟಮ್ಸ್ ಎಮ್ಯುಲೇಟರ್ ಆಗಿತ್ತು ಕಾಪಿಕ್ಯಾಟ್.

ಕಾಪಿಕ್ಯಾಟ್ ಏಕೆ?

ಮಾತಿನ ಮೇಲೆ ಆಟವಿದೆ.

1. ಕಾಪಿ ಕ್ಯಾಟ್ (ಇಂಗ್ಲಿಷ್, ನಾಮಪದ [ˈkɒpɪkæt]) - ಅನುಕರಿಸುವವನು, ಅನುಕರಿಸುವವನು
2. ಬೆಕ್ಕು (ಇಂಗ್ಲಿಷ್, ನಾಮಪದ [ˈkæt]) - ಬೆಕ್ಕು, ಬೆಕ್ಕು - ಯೋಜನೆಯ ಸೃಷ್ಟಿಕರ್ತರಲ್ಲಿ ಒಬ್ಬರ ನೆಚ್ಚಿನ ಪ್ರಾಣಿ
3. "ಕೆ" ಅಕ್ಷರವು ಕೋಟ್ಲಿನ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಯಿಂದ ಬಂದಿದೆ

ಕಾಪಿಕ್ಯಾಟ್

ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ರಚಿಸುವಾಗ, ನಿರ್ದಿಷ್ಟ ಗುರಿಗಳನ್ನು ಹೊಂದಿಸಲಾಗಿದೆ:

• ಹೊಸ ಪೆರಿಫೆರಲ್ಸ್, ಮಾಡ್ಯೂಲ್‌ಗಳು, ಪ್ರೊಸೆಸರ್ ಕೋರ್‌ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ರಚಿಸುವ ಸಾಮರ್ಥ್ಯ;
• ವಿವಿಧ ಮಾಡ್ಯೂಲ್ಗಳಿಂದ ವರ್ಚುವಲ್ ಸಾಧನವನ್ನು ಜೋಡಿಸುವ ಸಾಮರ್ಥ್ಯ;
• ಯಾವುದೇ ಬೈನರಿ ಡೇಟಾವನ್ನು (ಫರ್ಮ್‌ವೇರ್) ವರ್ಚುವಲ್ ಸಾಧನದ ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯ;
• ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಸಾಮರ್ಥ್ಯ (ಸಿಸ್ಟಮ್ ಸ್ಟೇಟ್‌ನ ಸ್ನ್ಯಾಪ್‌ಶಾಟ್‌ಗಳು);
• ಅಂತರ್ನಿರ್ಮಿತ ಡೀಬಗರ್ ಮೂಲಕ ಎಮ್ಯುಲೇಟರ್ನೊಂದಿಗೆ ಸಂವಹನ ಮಾಡುವ ಸಾಮರ್ಥ್ಯ;
• ಅಭಿವೃದ್ಧಿಗೆ ಉತ್ತಮ ಆಧುನಿಕ ಭಾಷೆ.

ಪರಿಣಾಮವಾಗಿ, ಕೋಟ್ಲಿನ್ ಅನ್ನು ಅನುಷ್ಠಾನಕ್ಕೆ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ, ಬಸ್ ಆರ್ಕಿಟೆಕ್ಚರ್ (ಇದು ಮಾಡ್ಯೂಲ್‌ಗಳು ವರ್ಚುವಲ್ ಡೇಟಾ ಬಸ್‌ಗಳ ಮೂಲಕ ಪರಸ್ಪರ ಸಂವಹನ ನಡೆಸಿದಾಗ), ಸಾಧನದ ವಿವರಣೆ ಸ್ವರೂಪವಾಗಿ JSON ಮತ್ತು ಡೀಬಗರ್‌ನೊಂದಿಗೆ ಸಂವಹನಕ್ಕಾಗಿ ಪ್ರೋಟೋಕಾಲ್ ಆಗಿ GDB RSP.

ಅಭಿವೃದ್ಧಿಯು ಎರಡು ವರ್ಷಗಳಿಂದ ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ನಡೆಯುತ್ತಿದೆ ಮತ್ತು ಸಕ್ರಿಯವಾಗಿ ನಡೆಯುತ್ತಿದೆ. ಈ ಸಮಯದಲ್ಲಿ, MIPS, x86, V850ES, ARM, ಮತ್ತು PowerPC ಪ್ರೊಸೆಸರ್ ಕೋರ್ಗಳನ್ನು ಅಳವಡಿಸಲಾಯಿತು.

ಯೋಜನೆಯು ಬೆಳೆಯುತ್ತಿದೆ ಮತ್ತು ಅದನ್ನು ವ್ಯಾಪಕ ಸಾರ್ವಜನಿಕರಿಗೆ ಪ್ರಸ್ತುತಪಡಿಸುವ ಸಮಯ. ನಾವು ನಂತರ ಯೋಜನೆಯ ವಿವರವಾದ ವಿವರಣೆಯನ್ನು ಮಾಡುತ್ತೇವೆ, ಆದರೆ ಇದೀಗ ನಾವು ಕಾಪಿಕ್ಯಾಟ್ ಅನ್ನು ಬಳಸುವುದರ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ.

ಹೆಚ್ಚು ತಾಳ್ಮೆಯಿಲ್ಲದವರಿಗೆ, ಎಮ್ಯುಲೇಟರ್‌ನ ಪ್ರೋಮೋ ಆವೃತ್ತಿಯನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಲಿಂಕ್.

ಎಮ್ಯುಲೇಟರ್ನಲ್ಲಿ ರೈನೋ

ಹಿಂದಿನ SMARTRHINO-2018 ಸಮ್ಮೇಳನಕ್ಕಾಗಿ, ರಿವರ್ಸ್ ಇಂಜಿನಿಯರಿಂಗ್ ಕೌಶಲ್ಯಗಳನ್ನು ಕಲಿಸಲು "ರೈನೋಸಿರಸ್" ಪರೀಕ್ಷಾ ಸಾಧನವನ್ನು ರಚಿಸಲಾಗಿದೆ ಎಂದು ನಾವು ನೆನಪಿಸಿಕೊಳ್ಳೋಣ. ಸ್ಥಿರ ಫರ್ಮ್‌ವೇರ್ ವಿಶ್ಲೇಷಣೆಯ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸಲಾಗಿದೆ ಈ ಲೇಖನ.

ಈಗ "ಸ್ಪೀಕರ್ಗಳನ್ನು" ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ ಮತ್ತು ಎಮ್ಯುಲೇಟರ್ನಲ್ಲಿ ಫರ್ಮ್ವೇರ್ ಅನ್ನು ರನ್ ಮಾಡಿ.

ನಮಗೆ ಅಗತ್ಯವಿದೆ:
1) ಜಾವಾ 1.8
2) ಪೈಥಾನ್ ಮತ್ತು ಮಾಡ್ಯೂಲ್ ಜೆಪ್ ಎಮ್ಯುಲೇಟರ್ ಒಳಗೆ ಪೈಥಾನ್ ಅನ್ನು ಬಳಸಲು. ನೀವು ವಿಂಡೋಸ್‌ಗಾಗಿ WHL ಮಾಡ್ಯೂಲ್ Jep ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು ಇಲ್ಲಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.

ವಿಂಡೋಸ್‌ಗಾಗಿ:
1) com0com
2) ಪುಟ್ಟಿ

Linux ಗಾಗಿ:
1) ಸೋಕಾಟ್

ನೀವು ಎಕ್ಲಿಪ್ಸ್, IDA Pro ಅಥವಾ radare2 ಅನ್ನು GDB ಕ್ಲೈಂಟ್ ಆಗಿ ಬಳಸಬಹುದು.

ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ?

ಎಮ್ಯುಲೇಟರ್ನಲ್ಲಿ ಫರ್ಮ್ವೇರ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು, ವಾಸ್ತವ ಸಾಧನವನ್ನು "ಸಂಯೋಜನೆ" ಮಾಡುವುದು ಅವಶ್ಯಕ, ಇದು ನಿಜವಾದ ಸಾಧನದ ಅನಲಾಗ್ ಆಗಿದೆ.

ನಿಜವಾದ ಸಾಧನವನ್ನು ("ಘೇಂಡಾಮೃಗ") ಬ್ಲಾಕ್ ರೇಖಾಚಿತ್ರದಲ್ಲಿ ತೋರಿಸಬಹುದು:

ಎಮ್ಯುಲೇಟರ್ ಮಾಡ್ಯುಲರ್ ರಚನೆಯನ್ನು ಹೊಂದಿದೆ ಮತ್ತು ಅಂತಿಮ ವರ್ಚುವಲ್ ಸಾಧನವನ್ನು JSON ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಬಹುದು.

JSON 105 ಸಾಲುಗಳು

{
  "top": true,

  // Plugin name should be the same as file name (or full path from library start)
  "plugin": "rhino",

  // Directory where plugin places
  "library": "user",

  // Plugin parameters (constructor parameters if jar-plugin version)
  "params": [
    { "name": "tty_dbg", "type": "String"},
    { "name": "tty_bt", "type": "String"},
    { "name": "firmware", "type": "String", "default": "NUL"}
  ],

  // Plugin outer ports
  "ports": [  ],

  // Plugin internal buses
  "buses": [
    { "name": "mem", "size": "BUS30" },
    { "name": "nand", "size": "4" },
    { "name": "gpio", "size": "BUS32" }
  ],

  // Plugin internal components
  "modules": [
    {
      "name": "u1_stm32",
      "plugin": "STM32F042",
      "library": "mcu",
      "params": {
        "firmware:String": "params.firmware"
      }
    },
    {
      "name": "usart_debug",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_dbg"
      }
    },
    {
      "name": "term_bt",
      "plugin": "UartSerialTerminal",
      "library": "terminals",
      "params": {
        "tty": "params.tty_bt"
      }
    },
    {
      "name": "bluetooth",
      "plugin": "BT",
      "library": "mcu"
    },

    { "name": "led_0",  "plugin": "LED", "library": "mcu" },
    { "name": "led_1",  "plugin": "LED", "library": "mcu" },
    { "name": "led_2",  "plugin": "LED", "library": "mcu" },
    { "name": "led_3",  "plugin": "LED", "library": "mcu" },
    { "name": "led_4",  "plugin": "LED", "library": "mcu" },
    { "name": "led_5",  "plugin": "LED", "library": "mcu" },
    { "name": "led_6",  "plugin": "LED", "library": "mcu" },
    { "name": "led_7",  "plugin": "LED", "library": "mcu" },
    { "name": "led_8",  "plugin": "LED", "library": "mcu" },
    { "name": "led_9",  "plugin": "LED", "library": "mcu" },
    { "name": "led_10", "plugin": "LED", "library": "mcu" },
    { "name": "led_11", "plugin": "LED", "library": "mcu" },
    { "name": "led_12", "plugin": "LED", "library": "mcu" },
    { "name": "led_13", "plugin": "LED", "library": "mcu" },
    { "name": "led_14", "plugin": "LED", "library": "mcu" },
    { "name": "led_15", "plugin": "LED", "library": "mcu" }
  ],

  // Plugin connection between components
  "connections": [
    [ "u1_stm32.ports.usart1_m", "usart_debug.ports.term_s"],
    [ "u1_stm32.ports.usart1_s", "usart_debug.ports.term_m"],

    [ "u1_stm32.ports.usart2_m", "bluetooth.ports.usart_m"],
    [ "u1_stm32.ports.usart2_s", "bluetooth.ports.usart_s"],

    [ "bluetooth.ports.bt_s", "term_bt.ports.term_m"],
    [ "bluetooth.ports.bt_m", "term_bt.ports.term_s"],

    [ "led_0.ports.pin",  "u1_stm32.buses.pin_output_a", "0x00"],
    [ "led_1.ports.pin",  "u1_stm32.buses.pin_output_a", "0x01"],
    [ "led_2.ports.pin",  "u1_stm32.buses.pin_output_a", "0x02"],
    [ "led_3.ports.pin",  "u1_stm32.buses.pin_output_a", "0x03"],
    [ "led_4.ports.pin",  "u1_stm32.buses.pin_output_a", "0x04"],
    [ "led_5.ports.pin",  "u1_stm32.buses.pin_output_a", "0x05"],
    [ "led_6.ports.pin",  "u1_stm32.buses.pin_output_a", "0x06"],
    [ "led_7.ports.pin",  "u1_stm32.buses.pin_output_a", "0x07"],
    [ "led_8.ports.pin",  "u1_stm32.buses.pin_output_a", "0x08"],
    [ "led_9.ports.pin",  "u1_stm32.buses.pin_output_a", "0x09"],
    [ "led_10.ports.pin", "u1_stm32.buses.pin_output_a", "0x0A"],
    [ "led_11.ports.pin", "u1_stm32.buses.pin_output_a", "0x0B"],
    [ "led_12.ports.pin", "u1_stm32.buses.pin_output_a", "0x0C"],
    [ "led_13.ports.pin", "u1_stm32.buses.pin_output_a", "0x0D"],
    [ "led_14.ports.pin", "u1_stm32.buses.pin_output_a", "0x0E"],
    [ "led_15.ports.pin", "u1_stm32.buses.pin_output_a", "0x0F"]
  ]
}

ನಿಯತಾಂಕಕ್ಕೆ ಗಮನ ಕೊಡಿ ಫರ್ಮ್ವೇರ್ ವಿಭಾಗದಲ್ಲಿ ನಿಯತಾಂಕಗಳು ಫರ್ಮ್‌ವೇರ್ ಆಗಿ ವರ್ಚುವಲ್ ಸಾಧನಕ್ಕೆ ಲೋಡ್ ಮಾಡಬಹುದಾದ ಫೈಲ್‌ನ ಹೆಸರಾಗಿದೆ.

ವರ್ಚುವಲ್ ಸಾಧನ ಮತ್ತು ಮುಖ್ಯ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗಿನ ಅದರ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಈ ಕೆಳಗಿನ ರೇಖಾಚಿತ್ರದಿಂದ ಪ್ರತಿನಿಧಿಸಬಹುದು:

ಎಮ್ಯುಲೇಟರ್‌ನ ಪ್ರಸ್ತುತ ಪರೀಕ್ಷಾ ನಿದರ್ಶನವು ಮುಖ್ಯ OS ನ COM ಪೋರ್ಟ್‌ಗಳೊಂದಿಗಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ (ಬ್ಲೂಟೂತ್ ಮಾಡ್ಯೂಲ್‌ಗಾಗಿ UART ಮತ್ತು UART ಡೀಬಗ್ ಮಾಡಿ). ಇವುಗಳು ಸಾಧನಗಳನ್ನು ಸಂಪರ್ಕಿಸಿರುವ ನೈಜ ಪೋರ್ಟ್‌ಗಳಾಗಿರಬಹುದು ಅಥವಾ ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳಾಗಿರಬಹುದು (ಇದಕ್ಕಾಗಿ ನಿಮಗೆ ಬೇಕಾಗಿರುವುದು com0com/socat).

ಹೊರಗಿನಿಂದ ಎಮ್ಯುಲೇಟರ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಪ್ರಸ್ತುತ ಎರಡು ಮುಖ್ಯ ಮಾರ್ಗಗಳಿವೆ:

• GDB RSP ಪ್ರೋಟೋಕಾಲ್ (ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ, ಈ ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಬೆಂಬಲಿಸುವ ಉಪಕರಣಗಳು ಎಕ್ಲಿಪ್ಸ್ / IDA / radare2);
• ಆಂತರಿಕ ಎಮ್ಯುಲೇಟರ್ ಕಮಾಂಡ್ ಲೈನ್ (ಆರ್ಗ್ಪಾರ್ಸ್ ಅಥವಾ ಪೈಥಾನ್).

ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳು

ಟರ್ಮಿನಲ್ ಮೂಲಕ ಸ್ಥಳೀಯ ಗಣಕದಲ್ಲಿ ವರ್ಚುವಲ್ ಸಾಧನದ UART ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು, ನೀವು ಒಂದು ಜೋಡಿ ಸಂಬಂಧಿತ ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳನ್ನು ರಚಿಸುವ ಅಗತ್ಯವಿದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಒಂದು ಪೋರ್ಟ್ ಅನ್ನು ಎಮ್ಯುಲೇಟರ್ ಬಳಸುತ್ತದೆ, ಮತ್ತು ಎರಡನೆಯದು ಟರ್ಮಿನಲ್ ಪ್ರೋಗ್ರಾಂ (PuTTY ಅಥವಾ ಸ್ಕ್ರೀನ್):

com0com ಅನ್ನು ಬಳಸುವುದು

ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳನ್ನು com0com ಕಿಟ್‌ನಿಂದ ಸೆಟಪ್ ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ (ಕನ್ಸೋಲ್ ಆವೃತ್ತಿ - ಸಿ:ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ಸ್ (x86)com0comsetupс.exe, ಅಥವಾ GUI ಆವೃತ್ತಿ - ಸಿ:ಪ್ರೋಗ್ರಾಂ ಫೈಲ್ಸ್ (x86)com0comsetupg.exe):

ಪೆಟ್ಟಿಗೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ ಬಫರ್ ಅತಿಕ್ರಮಣವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ಎಲ್ಲಾ ರಚಿಸಲಾದ ವರ್ಚುವಲ್ ಪೋರ್ಟ್‌ಗಳಿಗೆ, ಇಲ್ಲದಿದ್ದರೆ ಎಮ್ಯುಲೇಟರ್ COM ಪೋರ್ಟ್‌ನಿಂದ ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿ ಕಾಯುತ್ತದೆ.

ಸೋಕಾಟ್ ಅನ್ನು ಬಳಸುವುದು

UNIX ವ್ಯವಸ್ಥೆಗಳಲ್ಲಿ, socat ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಎಮ್ಯುಲೇಟರ್‌ನಿಂದ ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ; ಇದನ್ನು ಮಾಡಲು, ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ ಪೋರ್ಟ್ ಹೆಸರಿನಲ್ಲಿ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ socat:.

ಆಂತರಿಕ ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ಫೇಸ್ (ಆರ್ಗ್ಪಾರ್ಸ್ ಅಥವಾ ಪೈಥಾನ್)

ಕಾಪಿಕ್ಯಾಟ್ ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿರುವುದರಿಂದ, ಎಮ್ಯುಲೇಟರ್ ಅದರ ವಸ್ತುಗಳು ಮತ್ತು ವೇರಿಯೇಬಲ್‌ಗಳೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಎರಡು ಕಮಾಂಡ್ ಲೈನ್ ಇಂಟರ್ಫೇಸ್ ಆಯ್ಕೆಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ: ಆರ್ಗ್‌ಪಾರ್ಸ್ ಮತ್ತು ಪೈಥಾನ್.

Argparse ಎಂಬುದು ಕಾಪಿಕ್ಯಾಟ್‌ನಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ CLI ಆಗಿದೆ ಮತ್ತು ಇದು ಯಾವಾಗಲೂ ಎಲ್ಲರಿಗೂ ಲಭ್ಯವಿರುತ್ತದೆ.

ಪರ್ಯಾಯ CLI ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಆಗಿದೆ. ಇದನ್ನು ಬಳಸಲು, ನೀವು ಜೆಪ್ ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು ಮತ್ತು ಪೈಥಾನ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ (ಬಳಕೆದಾರರ ಮುಖ್ಯ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಲಾದ ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಅನ್ನು ಬಳಸಲಾಗುತ್ತದೆ).

ಪೈಥಾನ್ ಮಾಡ್ಯೂಲ್ ಜೆಪ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

ಲಿನಕ್ಸ್ ಜೆಪ್ ಅಡಿಯಲ್ಲಿ ಪಿಪ್ ಮೂಲಕ ಸ್ಥಾಪಿಸಬಹುದು:

pip install jep

Windows ನಲ್ಲಿ Jep ಅನ್ನು ಸ್ಥಾಪಿಸಲು, ನೀವು ಮೊದಲು Windows SDK ಮತ್ತು ಅನುಗುಣವಾದ Microsoft Visual Studio ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು. ನಾವು ಅದನ್ನು ನಿಮಗೆ ಸ್ವಲ್ಪ ಸುಲಭಗೊಳಿಸಿದ್ದೇವೆ ಮತ್ತು WHL ನಿರ್ಮಿಸುತ್ತದೆ ವಿಂಡೋಸ್‌ಗಾಗಿ ಪೈಥಾನ್‌ನ ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಗಳಿಗಾಗಿ JEP, ಆದ್ದರಿಂದ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಫೈಲ್‌ನಿಂದ ಸ್ಥಾಪಿಸಬಹುದು:

pip install jep-3.8.2-cp27-cp27m-win_amd64.whl

ಜೆಪ್ ಸ್ಥಾಪನೆಯನ್ನು ಪರಿಶೀಲಿಸಲು, ನೀವು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಚಲಾಯಿಸಬೇಕು:

python -c "import jep"

ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಕೆಳಗಿನ ಸಂದೇಶವನ್ನು ಸ್ವೀಕರಿಸಬೇಕು:

ImportError: Jep is not supported in standalone Python, it must be embedded in Java.

ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ಗಾಗಿ ಎಮ್ಯುಲೇಟರ್ ಬ್ಯಾಚ್ ಫೈಲ್‌ನಲ್ಲಿ (copycat.bat - ವಿಂಡೋಸ್‌ಗಾಗಿ, ಕಾಪಿಕ್ಯಾಟ್ - Linux ಗಾಗಿ) ನಿಯತಾಂಕಗಳ ಪಟ್ಟಿಗೆ DEFAULT_JVM_OPTS ಹೆಚ್ಚುವರಿ ನಿಯತಾಂಕವನ್ನು ಸೇರಿಸಿ Djava.library.path — ಇದು ಸ್ಥಾಪಿಸಲಾದ ಜೆಪ್ ಮಾಡ್ಯೂಲ್‌ಗೆ ಮಾರ್ಗವನ್ನು ಹೊಂದಿರಬೇಕು.

ವಿಂಡೋಸ್‌ನ ಫಲಿತಾಂಶವು ಈ ರೀತಿಯ ಸಾಲಾಗಿರಬೇಕು:

set DEFAULT_JVM_OPTS="-XX:MaxMetaspaceSize=256m" "-XX:+UseParallelGC" "-XX:SurvivorRatio=6" "-XX:-UseGCOverheadLimit" "-Djava.library.path=C:/Python27/Lib/site-packages/jep"

ಕಾಪಿಕ್ಯಾಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ

ಎಮ್ಯುಲೇಟರ್ ಕನ್ಸೋಲ್ JVM ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ. ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಕಮಾಂಡ್ ಲೈನ್ ಸ್ಕ್ರಿಪ್ಟ್ (sh/cmd) ಮೂಲಕ ಉಡಾವಣೆಯನ್ನು ಕೈಗೊಳ್ಳಲಾಗುತ್ತದೆ.

ವಿಂಡೋಸ್ ಅಡಿಯಲ್ಲಿ ಚಲಾಯಿಸಲು ಆಜ್ಞೆ:

binkopycat -g 23946 -n rhino -l user -y library -p firmware=firmwarerhino_pass.bin,tty_dbg=COM26,tty_bt=COM28

Socat ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಿಕೊಂಡು Linux ಅಡಿಯಲ್ಲಿ ಚಲಾಯಿಸಲು ಆಜ್ಞೆ:

./bin/kopycat -g 23946 -n rhino -l user -y library -p firmware=./firmware/rhino_pass.bin, tty_dbg=socat:./COM26,tty_bt=socat:./COM28

• -g 23646 — GDB ಸರ್ವರ್‌ಗೆ ಪ್ರವೇಶಕ್ಕಾಗಿ TCP ಪೋರ್ಟ್ ತೆರೆದಿರುತ್ತದೆ;
• -n rhino - ಮುಖ್ಯ ಸಿಸ್ಟಮ್ ಮಾಡ್ಯೂಲ್ನ ಹೆಸರು (ಜೋಡಿಸಲಾದ ಸಾಧನ);
• -l user - ಮುಖ್ಯ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹುಡುಕಲು ಗ್ರಂಥಾಲಯದ ಹೆಸರು;
• -y library - ಸಾಧನದಲ್ಲಿ ಸೇರಿಸಲಾದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಹುಡುಕುವ ಮಾರ್ಗ;
• firmwarerhino_pass.bin - ಫರ್ಮ್ವೇರ್ ಫೈಲ್ಗೆ ಮಾರ್ಗ;
• COM26 ಮತ್ತು COM28 ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳಾಗಿವೆ.

ಪರಿಣಾಮವಾಗಿ, ಪ್ರಾಂಪ್ಟ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ Python > (ಅಥವಾ Argparse >):

18:07:59 INFO [eFactoryBuilder.create ]: Module top successfully created as top
18:07:59 INFO [ Module.initializeAndRes]: Setup core to top.u1_stm32.cortexm0.arm for top
18:07:59 INFO [ Module.initializeAndRes]: Setup debugger to top.u1_stm32.dbg for top
18:07:59 WARN [ Module.initializeAndRes]: Tracer wasn't found in top...
18:07:59 INFO [ Module.initializeAndRes]: Initializing ports and buses...
18:07:59 WARN [ Module.initializePortsA]: ATTENTION: Some ports has warning use printModulesPortsWarnings to see it...
18:07:59 FINE [ ARMv6CPU.reset ]: Set entry point address to 08006A75
18:07:59 INFO [ Module.initializeAndRes]: Module top is successfully initialized and reset as a top cell!
18:07:59 INFO [ Kopycat.open ]: Starting virtualization of board top[rhino] with arm[ARMv6Core]
18:07:59 INFO [ GDBServer.debuggerModule ]: Set new debugger module top.u1_stm32.dbg for GDB_SERVER(port=23946,alive=true)
Python >

IDA Pro ಜೊತೆಗಿನ ಸಂವಹನ

ಪರೀಕ್ಷೆಯನ್ನು ಸರಳಗೊಳಿಸಲು, ನಾವು ರೂಪದಲ್ಲಿ IDA ಯಲ್ಲಿ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ರೈನೋ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಮೂಲ ಫೈಲ್ ಆಗಿ ಬಳಸುತ್ತೇವೆ ELF ಫೈಲ್ (ಮೆಟಾ ಮಾಹಿತಿಯನ್ನು ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ).

ಮೆಟಾ ಮಾಹಿತಿಯಿಲ್ಲದೆ ನೀವು ಮುಖ್ಯ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಸಹ ಬಳಸಬಹುದು.

IDA Pro ನಲ್ಲಿ Kopycat ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ಡೀಬಗರ್ ಮೆನುವಿನಲ್ಲಿ ಐಟಂಗೆ ಹೋಗಿ "ಡೀಬಗರ್ ಬದಲಿಸಿ..."ಮತ್ತು ಆಯ್ಕೆಮಾಡಿ"ರಿಮೋಟ್ GDB ಡೀಬಗರ್". ಮುಂದೆ, ಸಂಪರ್ಕವನ್ನು ಹೊಂದಿಸಿ: ಮೆನು ಡೀಬಗರ್ - ಪ್ರಕ್ರಿಯೆ ಆಯ್ಕೆಗಳು...

ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸಿ:

• ಅಪ್ಲಿಕೇಶನ್ - ಯಾವುದೇ ಮೌಲ್ಯ
• ಹೋಸ್ಟ್ ಹೆಸರು: 127.0.0.1 (ಅಥವಾ Kopycat ಚಾಲನೆಯಲ್ಲಿರುವ ರಿಮೋಟ್ ಯಂತ್ರದ IP ವಿಳಾಸ)
• ಪೋರ್ಟ್: 23946

ಈಗ ಡೀಬಗ್ ಮಾಡುವ ಬಟನ್ ಲಭ್ಯವಾಗುತ್ತದೆ (F9 ಕೀ):

ಎಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿರುವ ಡೀಬಗರ್ ಮಾಡ್ಯೂಲ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಅದನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿ. IDA ಡೀಬಗ್ ಮೋಡ್‌ಗೆ ಹೋಗುತ್ತದೆ, ಹೆಚ್ಚುವರಿ ವಿಂಡೋಗಳು ಲಭ್ಯವಾಗುತ್ತವೆ: ರೆಜಿಸ್ಟರ್‌ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿ, ಸ್ಟಾಕ್ ಬಗ್ಗೆ.

ಈಗ ನಾವು ಡೀಬಗರ್‌ನ ಎಲ್ಲಾ ಪ್ರಮಾಣಿತ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಬಳಸಬಹುದು:

• ಸೂಚನೆಗಳ ಹಂತ-ಹಂತದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆ (ಪ್ರವೇಶಿಸು и ಮೇಲೆ ಹೆಜ್ಜೆ ಹಾಕಿ - ಕ್ರಮವಾಗಿ F7 ಮತ್ತು F8 ಕೀಗಳು);
• ಮರಣದಂಡನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಮತ್ತು ವಿರಾಮಗೊಳಿಸುವುದು;
• ಕೋಡ್ ಮತ್ತು ಡೇಟಾ ಎರಡಕ್ಕೂ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ರಚಿಸುವುದು (F2 ಕೀ).

ಡೀಬಗರ್‌ಗೆ ಸಂಪರ್ಕಿಸುವುದು ಎಂದರೆ ಫರ್ಮ್‌ವೇರ್ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು ಎಂದಲ್ಲ. ಪ್ರಸ್ತುತ ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸ್ಥಾನವು ವಿಳಾಸವಾಗಿರಬೇಕು 0x08006A74 - ಕಾರ್ಯದ ಪ್ರಾರಂಭ ಮರುಹೊಂದಿಸಿ_ಹ್ಯಾಂಡ್ಲರ್. ನೀವು ಪಟ್ಟಿಯನ್ನು ಕೆಳಗೆ ಸ್ಕ್ರಾಲ್ ಮಾಡಿದರೆ, ನೀವು ಫಂಕ್ಷನ್ ಕರೆಯನ್ನು ನೋಡಬಹುದು ಮುಖ್ಯ. ನೀವು ಕರ್ಸರ್ ಅನ್ನು ಈ ಸಾಲಿನಲ್ಲಿ ಇರಿಸಬಹುದು (ವಿಳಾಸ 0x08006ABE) ಮತ್ತು ಕಾರ್ಯಾಚರಣೆಯನ್ನು ನಿರ್ವಹಿಸಿ ಕರ್ಸರ್ ತನಕ ರನ್ ಮಾಡಿ (ಕೀಲಿ F4).

ಮುಂದೆ, ಕಾರ್ಯವನ್ನು ನಮೂದಿಸಲು ನೀವು F7 ಅನ್ನು ಒತ್ತಬಹುದು ಮುಖ್ಯ.

ನೀವು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದರೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುಂದುವರಿಸಿ (F9 ಕೀ), ನಂತರ "ದಯವಿಟ್ಟು ನಿರೀಕ್ಷಿಸಿ" ವಿಂಡೋ ಒಂದೇ ಗುಂಡಿಯೊಂದಿಗೆ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಅಮಾನತುಗೊಳಿಸಿ:

ನೀವು ಒತ್ತಿದಾಗ ಅಮಾನತುಗೊಳಿಸಿ ಫರ್ಮ್‌ವೇರ್ ಕೋಡ್‌ನ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಅಮಾನತುಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಅದನ್ನು ಅಡ್ಡಿಪಡಿಸಿದ ಕೋಡ್‌ನಲ್ಲಿ ಅದೇ ವಿಳಾಸದಿಂದ ಮುಂದುವರಿಸಬಹುದು.

ನೀವು ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸಿದರೆ, ವರ್ಚುವಲ್ COM ಪೋರ್ಟ್‌ಗಳಿಗೆ ಸಂಪರ್ಕಗೊಂಡಿರುವ ಟರ್ಮಿನಲ್‌ಗಳಲ್ಲಿ ನೀವು ಈ ಕೆಳಗಿನ ಸಾಲುಗಳನ್ನು ನೋಡುತ್ತೀರಿ:

"ಸ್ಟೇಟ್ ಬೈಪಾಸ್" ಸಾಲಿನ ಉಪಸ್ಥಿತಿಯು ವರ್ಚುವಲ್ ಬ್ಲೂಟೂತ್ ಮಾಡ್ಯೂಲ್ ಬಳಕೆದಾರರ COM ಪೋರ್ಟ್ನಿಂದ ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸುವ ಮೋಡ್ಗೆ ಬದಲಾಯಿಸಿದೆ ಎಂದು ಸೂಚಿಸುತ್ತದೆ.

ಈಗ ಬ್ಲೂಟೂತ್ ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ (ಚಿತ್ರದಲ್ಲಿ COM29) ನೀವು ರೈನೋ ಪ್ರೋಟೋಕಾಲ್‌ಗೆ ಅನುಗುಣವಾಗಿ ಆಜ್ಞೆಗಳನ್ನು ನಮೂದಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, "MEOW" ಆಜ್ಞೆಯು "mur-mur" ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಬ್ಲೂಟೂತ್ ಟರ್ಮಿನಲ್‌ಗೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ:

ನನ್ನನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅನುಕರಿಸಿ ಅಲ್ಲ

ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ನಿರ್ಮಿಸುವಾಗ, ನಿರ್ದಿಷ್ಟ ಸಾಧನದ ವಿವರ / ಎಮ್ಯುಲೇಶನ್ ಮಟ್ಟವನ್ನು ನೀವು ಆಯ್ಕೆ ಮಾಡಬಹುದು. ಉದಾಹರಣೆಗೆ, ಬ್ಲೂಟೂತ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ವಿವಿಧ ರೀತಿಯಲ್ಲಿ ಅನುಕರಿಸಬಹುದು:

• ಸಾಧನವು ಸಂಪೂರ್ಣ ಆಜ್ಞೆಗಳೊಂದಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಅನುಕರಿಸುತ್ತದೆ;
• AT ಆಜ್ಞೆಗಳನ್ನು ಅನುಕರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಡೇಟಾ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ಮುಖ್ಯ ಸಿಸ್ಟಮ್ನ COM ಪೋರ್ಟ್ನಿಂದ ಸ್ವೀಕರಿಸಲಾಗುತ್ತದೆ;
• ವರ್ಚುವಲ್ ಸಾಧನವು ನೈಜ ಸಾಧನಕ್ಕೆ ಸಂಪೂರ್ಣ ಡೇಟಾ ಮರುನಿರ್ದೇಶನವನ್ನು ಒದಗಿಸುತ್ತದೆ;
• ಯಾವಾಗಲೂ "ಸರಿ" ಎಂದು ಹಿಂತಿರುಗಿಸುವ ಸರಳ ಸ್ಟಬ್ ಆಗಿ.

ಎಮ್ಯುಲೇಟರ್‌ನ ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಯು ಎರಡನೇ ವಿಧಾನವನ್ನು ಬಳಸುತ್ತದೆ - ವರ್ಚುವಲ್ ಬ್ಲೂಟೂತ್ ಮಾಡ್ಯೂಲ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ, ಅದರ ನಂತರ ಅದು ಮುಖ್ಯ ಸಿಸ್ಟಮ್‌ನ COM ಪೋರ್ಟ್‌ನಿಂದ ಎಮ್ಯುಲೇಟರ್‌ನ UART ಪೋರ್ಟ್‌ಗೆ “ಪ್ರಾಕ್ಸಿಯಿಂಗ್” ಡೇಟಾದ ಮೋಡ್‌ಗೆ ಬದಲಾಗುತ್ತದೆ.

ಪರಿಧಿಯ ಕೆಲವು ಭಾಗವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸದಿದ್ದಲ್ಲಿ ಕೋಡ್‌ನ ಸರಳ ಉಪಕರಣದ ಸಾಧ್ಯತೆಯನ್ನು ಪರಿಗಣಿಸೋಣ. ಉದಾಹರಣೆಗೆ, DMA ಗೆ ಡೇಟಾ ವರ್ಗಾವಣೆಯನ್ನು ನಿಯಂತ್ರಿಸುವ ಜವಾಬ್ದಾರಿಯುತ ಟೈಮರ್ ಅನ್ನು ರಚಿಸದಿದ್ದರೆ (ಚೆಕ್ ಅನ್ನು ಕಾರ್ಯದಲ್ಲಿ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ ws2812b_waitನಲ್ಲಿ ಇದೆ 0x08006840), ನಂತರ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಮರುಹೊಂದಿಸಲು ಫರ್ಮ್‌ವೇರ್ ಯಾವಾಗಲೂ ಕಾಯುತ್ತದೆ ನಿರತನಲ್ಲಿ ಇದೆ 0x200004C4ಇದು DMA ಡೇಟಾ ಲೈನ್‌ನ ಆಕ್ಯುಪೆನ್ಸಿಯನ್ನು ತೋರಿಸುತ್ತದೆ:

ಧ್ವಜವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮರುಹೊಂದಿಸುವ ಮೂಲಕ ನಾವು ಈ ಪರಿಸ್ಥಿತಿಯನ್ನು ನಿಭಾಯಿಸಬಹುದು ನಿರತ ಅದನ್ನು ಸ್ಥಾಪಿಸಿದ ತಕ್ಷಣ. IDA Pro ನಲ್ಲಿ, ನೀವು ಪೈಥಾನ್ ಕಾರ್ಯವನ್ನು ರಚಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ನಲ್ಲಿ ಕರೆಯಬಹುದು ಮತ್ತು ಧ್ವಜಕ್ಕೆ ಮೌಲ್ಯ 1 ಅನ್ನು ಬರೆದ ನಂತರ ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಕೋಡ್‌ನಲ್ಲಿ ಇರಿಸಬಹುದು. ನಿರತ.

ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಹ್ಯಾಂಡ್ಲರ್

ಮೊದಲಿಗೆ, IDA ನಲ್ಲಿ ಪೈಥಾನ್ ಕಾರ್ಯವನ್ನು ರಚಿಸೋಣ. ಮೆನು ಫೈಲ್ - ಸ್ಕ್ರಿಪ್ಟ್ ಆಜ್ಞೆ...

ಎಡಭಾಗದಲ್ಲಿರುವ ಪಟ್ಟಿಯಲ್ಲಿ ಹೊಸ ತುಣುಕನ್ನು ಸೇರಿಸಿ, ಅದಕ್ಕೆ ಹೆಸರನ್ನು ನೀಡಿ (ಉದಾಹರಣೆಗೆ, BPT),
ಬಲಭಾಗದಲ್ಲಿರುವ ಪಠ್ಯ ಕ್ಷೇತ್ರದಲ್ಲಿ, ಕಾರ್ಯ ಕೋಡ್ ಅನ್ನು ನಮೂದಿಸಿ:

def skip_dma():
    print "Skipping wait ws2812..."
    value = Byte(0x200004C4)
    if value == 1:
        PatchDbgByte(0x200004C4, 0)
return False

ಅದರ ನಂತರ ನಾವು ಒತ್ತಿರಿ ರನ್ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ವಿಂಡೋವನ್ನು ಮುಚ್ಚಿ.

ಈಗ ನಲ್ಲಿ ಕೋಡ್‌ಗೆ ಹೋಗೋಣ 0x0800688A, ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಅನ್ನು ಹೊಂದಿಸಿ (F2 ಕೀ), ಅದನ್ನು ಸಂಪಾದಿಸಿ (ಸಂದರ್ಭ ಮೆನು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಎಡಿಟ್ ಮಾಡಿ...), ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಕಾರವನ್ನು ಪೈಥಾನ್‌ಗೆ ಹೊಂದಿಸಲು ಮರೆಯಬೇಡಿ:

ಪ್ರಸ್ತುತ ಫ್ಲ್ಯಾಗ್ ಮೌಲ್ಯವಾಗಿದ್ದರೆ ನಿರತ 1 ಗೆ ಸಮನಾಗಿರುತ್ತದೆ, ನಂತರ ನೀವು ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು skip_dma ಸ್ಕ್ರಿಪ್ಟ್ ಸಾಲಿನಲ್ಲಿ:

ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ, ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್ ಹ್ಯಾಂಡ್ಲರ್ ಕೋಡ್‌ನ ಪ್ರಚೋದನೆಯನ್ನು IDA ವಿಂಡೋದಲ್ಲಿ ಕಾಣಬಹುದು ಔಟ್ಪುಟ್ ಸಾಲಿನ ಮೂಲಕ Skipping wait ws2812.... ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಮರುಹೊಂದಿಸಲು ಈಗ ಫರ್ಮ್‌ವೇರ್ ಕಾಯುವುದಿಲ್ಲ ನಿರತ.

ಎಮ್ಯುಲೇಟರ್ನೊಂದಿಗೆ ಸಂವಹನ

ಅನುಕರಣೆಯ ಸಲುವಾಗಿ ಎಮ್ಯುಲೇಶನ್ ಸಂತೋಷ ಮತ್ತು ಸಂತೋಷವನ್ನು ಉಂಟುಮಾಡುವ ಸಾಧ್ಯತೆಯಿಲ್ಲ. ಮೆಮೊರಿಯಲ್ಲಿ ಡೇಟಾವನ್ನು ನೋಡಲು ಅಥವಾ ಥ್ರೆಡ್‌ಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಸ್ಥಾಪಿಸಲು ಎಮ್ಯುಲೇಟರ್ ಸಂಶೋಧಕರಿಗೆ ಸಹಾಯ ಮಾಡಿದರೆ ಅದು ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ.

RTOS ಕಾರ್ಯಗಳ ನಡುವಿನ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ಹೇಗೆ ಸ್ಥಾಪಿಸುವುದು ಎಂಬುದನ್ನು ನಾವು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ. ಕೋಡ್ ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ಅದರ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ನೀವು ಮೊದಲು ವಿರಾಮಗೊಳಿಸಬೇಕು. ಫಂಕ್ಷನ್ ಗೆ ಹೋದರೆ bluetooth_task_entry "LED" ಆಜ್ಞೆಯ ಸಂಸ್ಕರಣಾ ಶಾಖೆಗೆ (ವಿಳಾಸ 0x080057B8), ನಂತರ ನೀವು ಮೊದಲು ಏನು ರಚಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೋಡಬಹುದು ಮತ್ತು ನಂತರ ಸಿಸ್ಟಮ್ ಕ್ಯೂಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ ledControlQueueHandle ಕೆಲವು ಸಂದೇಶ.

ವೇರಿಯೇಬಲ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ನೀವು ಬ್ರೇಕ್ಪಾಯಿಂಟ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕು ledControlQueueHandleನಲ್ಲಿ ಇದೆ 0x20000624 ಮತ್ತು ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದನ್ನು ಮುಂದುವರಿಸಿ:

ಪರಿಣಾಮವಾಗಿ, ಸ್ಟಾಪ್ ಮೊದಲು ವಿಳಾಸದಲ್ಲಿ ಸಂಭವಿಸುತ್ತದೆ 0x080057CA ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೊದಲು osMailAlloc, ನಂತರ ವಿಳಾಸದಲ್ಲಿ 0x08005806 ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೊದಲು osMailPut, ನಂತರ ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ - ವಿಳಾಸಕ್ಕೆ 0x08005BD4 (ಕಾರ್ಯವನ್ನು ಕರೆಯುವ ಮೊದಲು osMailGet), ಇದು ಕಾರ್ಯಕ್ಕೆ ಸೇರಿದೆ leds_task_entry (ಎಲ್ಇಡಿ-ಕಾರ್ಯ), ಅಂದರೆ, ಕಾರ್ಯಗಳನ್ನು ಬದಲಾಯಿಸಲಾಗಿದೆ, ಮತ್ತು ಈಗ ಎಲ್ಇಡಿ-ಕಾರ್ಯವು ನಿಯಂತ್ರಣವನ್ನು ಪಡೆದುಕೊಂಡಿದೆ.

ಈ ಸರಳ ರೀತಿಯಲ್ಲಿ ನೀವು RTOS ಕಾರ್ಯಗಳು ಪರಸ್ಪರ ಹೇಗೆ ಸಂವಹನ ನಡೆಸುತ್ತವೆ ಎಂಬುದನ್ನು ಸ್ಥಾಪಿಸಬಹುದು.

ಸಹಜವಾಗಿ, ವಾಸ್ತವದಲ್ಲಿ, ಕಾರ್ಯಗಳ ಪರಸ್ಪರ ಕ್ರಿಯೆಯು ಹೆಚ್ಚು ಜಟಿಲವಾಗಿದೆ, ಆದರೆ ಎಮ್ಯುಲೇಟರ್ ಬಳಸಿ, ಈ ಪರಸ್ಪರ ಕ್ರಿಯೆಯನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವುದು ಕಡಿಮೆ ಪ್ರಯಾಸದಾಯಕವಾಗಿರುತ್ತದೆ.

ಇಲ್ಲಿ ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮತ್ತು IDA Pro ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುವ ಕಿರು ವೀಡಿಯೊವನ್ನು ನೀವು ವೀಕ್ಷಿಸಬಹುದು.

Radare2 ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿ

Radare2 ನಂತಹ ಸಾರ್ವತ್ರಿಕ ಸಾಧನವನ್ನು ನೀವು ನಿರ್ಲಕ್ಷಿಸಲಾಗುವುದಿಲ್ಲ.

R2 ಅನ್ನು ಬಳಸಿಕೊಂಡು ಎಮ್ಯುಲೇಟರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು, ಆಜ್ಞೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

radare2 -A -a arm -b 16 -d gdb://localhost:23946 rhino_fw42k6.elf

ಲಾಂಚ್ ಈಗ ಲಭ್ಯವಿದೆ (dc) ಮತ್ತು ವಿರಾಮ ಎಕ್ಸಿಕ್ಯೂಶನ್ (Ctrl+C).

ದುರದೃಷ್ಟವಶಾತ್, ಈ ಸಮಯದಲ್ಲಿ, ಹಾರ್ಡ್‌ವೇರ್ gdb ಸರ್ವರ್ ಮತ್ತು ಮೆಮೊರಿ ಲೇಔಟ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ r2 ಸಮಸ್ಯೆಗಳನ್ನು ಹೊಂದಿದೆ; ಈ ಕಾರಣದಿಂದಾಗಿ, ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳು ಮತ್ತು ಹಂತಗಳು ಕಾರ್ಯನಿರ್ವಹಿಸುವುದಿಲ್ಲ (ಕಮಾಂಡ್ ds) ಇದನ್ನು ಶೀಘ್ರದಲ್ಲೇ ಸರಿಪಡಿಸಲಾಗುವುದು ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.

ಎಕ್ಲಿಪ್ಸ್ ಜೊತೆ ರನ್ನಿಂಗ್

ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಬಳಸುವ ಆಯ್ಕೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ ಸಾಧನದ ಫರ್ಮ್ವೇರ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡುವುದು. ಸ್ಪಷ್ಟತೆಗಾಗಿ, ನಾವು ರೈನೋ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಸಹ ಬಳಸುತ್ತೇವೆ. ನೀವು ಫರ್ಮ್ವೇರ್ ಮೂಲಗಳನ್ನು ಡೌನ್ಲೋಡ್ ಮಾಡಬಹುದು ಇಲ್ಲಿಂದ.

ನಾವು ಸೆಟ್‌ನಿಂದ ಎಕ್ಲಿಪ್ಸ್ ಅನ್ನು IDE ಆಗಿ ಬಳಸುತ್ತೇವೆ STM32 ಗಾಗಿ ಸಿಸ್ಟಮ್ ವರ್ಕ್‌ಬೆಂಚ್.

ಎಕ್ಲಿಪ್ಸ್‌ನಲ್ಲಿ ನೇರವಾಗಿ ಸಂಕಲಿಸಲಾದ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಎಮ್ಯುಲೇಟರ್ ಲೋಡ್ ಮಾಡಲು, ನೀವು ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ firmware=null ಎಮ್ಯುಲೇಟರ್ ಲಾಂಚ್ ಆಜ್ಞೆಗೆ:

binkopycat -g 23946 -n rhino -l user -y modules -p firmware=null,tty_dbg=COM26,tty_bt=COM28

ಡೀಬಗ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಎಕ್ಲಿಪ್ಸ್‌ನಲ್ಲಿ, ಮೆನು ಆಯ್ಕೆಮಾಡಿ ರನ್ - ಡೀಬಗ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು... ತೆರೆಯುವ ವಿಂಡೋದಲ್ಲಿ, ವಿಭಾಗದಲ್ಲಿ GDB ಹಾರ್ಡ್‌ವೇರ್ ಡೀಬಗ್ ಮಾಡುವಿಕೆ ನೀವು ಹೊಸ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ, ನಂತರ "ಮುಖ್ಯ" ಟ್ಯಾಬ್ನಲ್ಲಿ ಪ್ರಸ್ತುತ ಯೋಜನೆ ಮತ್ತು ಡೀಬಗ್ ಮಾಡಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿ:

"ಡೀಬಗ್ಗರ್" ಟ್ಯಾಬ್ನಲ್ಲಿ ನೀವು GDB ಆಜ್ಞೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿದೆ:
${openstm32_compiler_path}arm-none-eabi-gdb

ಮತ್ತು GDB ಸರ್ವರ್ (ಹೋಸ್ಟ್ ಮತ್ತು ಪೋರ್ಟ್) ಗೆ ಸಂಪರ್ಕಿಸಲು ನಿಯತಾಂಕಗಳನ್ನು ನಮೂದಿಸಿ:

"ಸ್ಟಾರ್ಟ್ಅಪ್" ಟ್ಯಾಬ್ನಲ್ಲಿ, ನೀವು ಈ ಕೆಳಗಿನ ನಿಯತಾಂಕಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು:

• ಚೆಕ್ಬಾಕ್ಸ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ಚಿತ್ರವನ್ನು ಲೋಡ್ ಮಾಡಿ (ಇದರಿಂದಾಗಿ ಜೋಡಿಸಲಾದ ಫರ್ಮ್‌ವೇರ್ ಚಿತ್ರವನ್ನು ಎಮ್ಯುಲೇಟರ್‌ಗೆ ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ);
• ಚೆಕ್ಬಾಕ್ಸ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ ಚಿಹ್ನೆಗಳನ್ನು ಲೋಡ್ ಮಾಡಿ;
• ಲಾಂಚ್ ಆಜ್ಞೆಯನ್ನು ಸೇರಿಸಿ: set $pc = *0x08000004 (ವಿಳಾಸದಲ್ಲಿ ಮೆಮೊರಿಯಿಂದ ಮೌಲ್ಯಕ್ಕೆ PC ರಿಜಿಸ್ಟರ್ ಅನ್ನು ಹೊಂದಿಸಿ 0x08000004 - ವಿಳಾಸವನ್ನು ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ರೀಸೆಟ್ ಹ್ಯಾಂಡ್ಲರ್).

ಗಮನ ಕೊಡಿ, ನೀವು ಎಕ್ಲಿಪ್ಸ್‌ನಿಂದ ಫರ್ಮ್‌ವೇರ್ ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಲು ಬಯಸದಿದ್ದರೆ, ನಂತರ ಆಯ್ಕೆಗಳು ಚಿತ್ರವನ್ನು ಲೋಡ್ ಮಾಡಿ и ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಿ ಸೂಚಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಡೀಬಗ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡಿದ ನಂತರ, ನೀವು ಡೀಬಗರ್ ಮೋಡ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡಬಹುದು:

• ಹಂತ ಹಂತದ ಕೋಡ್ ಎಕ್ಸಿಕ್ಯೂಶನ್
  
• ಬ್ರೇಕ್ಪಾಯಿಂಟ್ಗಳೊಂದಿಗೆ ಸಂವಹನ
  

ಹೇಳಿಕೆಯನ್ನು. ಎಕ್ಲಿಪ್ಸ್, ಹ್ಮ್... ಕೆಲವು ಕ್ವಿರ್ಕ್‌ಗಳನ್ನು ಹೊಂದಿದೆ... ಮತ್ತು ನೀವು ಅವರೊಂದಿಗೆ ಬದುಕಬೇಕು. ಉದಾಹರಣೆಗೆ, ಡೀಬಗರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ “0x0″ ಗೆ ಯಾವುದೇ ಮೂಲ ಲಭ್ಯವಿಲ್ಲ” ಎಂಬ ಸಂದೇಶವು ಕಾಣಿಸಿಕೊಂಡರೆ, ನಂತರ ಹಂತ ಆಜ್ಞೆಯನ್ನು (F5) ಕಾರ್ಯಗತಗೊಳಿಸಿ.

ಬದಲಿಗೆ ತೀರ್ಮಾನದ

ಸ್ಥಳೀಯ ಕೋಡ್ ಅನ್ನು ಅನುಕರಿಸುವುದು ಬಹಳ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವಾಗಿದೆ. ನಿಜವಾದ ಸಾಧನವಿಲ್ಲದೆ ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಡಿಬಗ್ ಮಾಡಲು ಸಾಧನ ಡೆವಲಪರ್‌ಗೆ ಸಾಧ್ಯವಾಗುತ್ತದೆ. ಸಂಶೋಧಕರಿಗೆ, ಡೈನಾಮಿಕ್ ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ ನಡೆಸಲು ಇದು ಒಂದು ಅವಕಾಶವಾಗಿದೆ, ಇದು ಸಾಧನದೊಂದಿಗೆ ಯಾವಾಗಲೂ ಸಾಧ್ಯವಿಲ್ಲ.

ಪರಿಣಿತರಿಗೆ ಅನುಕೂಲಕರವಾದ, ಮಧ್ಯಮ ಸರಳವಾದ ಮತ್ತು ಹೊಂದಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು ಹೆಚ್ಚಿನ ಶ್ರಮ ಮತ್ತು ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳದ ಪರಿಕರವನ್ನು ಒದಗಿಸಲು ನಾವು ಬಯಸುತ್ತೇವೆ.

ಹಾರ್ಡ್‌ವೇರ್ ಎಮ್ಯುಲೇಟರ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಅನುಭವದ ಕುರಿತು ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಬರೆಯಿರಿ. ನಾವು ನಿಮ್ಮನ್ನು ಚರ್ಚಿಸಲು ಆಹ್ವಾನಿಸುತ್ತೇವೆ ಮತ್ತು ಪ್ರಶ್ನೆಗಳಿಗೆ ಉತ್ತರಿಸಲು ಸಂತೋಷಪಡುತ್ತೇವೆ.

ನೋಂದಾಯಿತ ಬಳಕೆದಾರರು ಮಾತ್ರ ಸಮೀಕ್ಷೆಯಲ್ಲಿ ಭಾಗವಹಿಸಬಹುದು. ಸೈನ್ ಇನ್ ಮಾಡಿ, ದಯವಿಟ್ಟು.

ನೀವು ಎಮ್ಯುಲೇಟರ್ ಅನ್ನು ಯಾವುದಕ್ಕಾಗಿ ಬಳಸುತ್ತಿರುವಿರಿ?

• ನಾನು (ಡೀಬಗ್) ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತೇನೆ

• ನಾನು ಫರ್ಮ್‌ವೇರ್ ಅನ್ನು ಸಂಶೋಧಿಸುತ್ತಿದ್ದೇನೆ

• ನಾನು ಆಟಗಳನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ (ಡೆಂಡಿ, ಸೆಗಾ, PSP)

• ಬೇರೆ ಏನಾದರೂ (ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಬರೆಯಿರಿ)

7 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 2 ಬಳಕೆದಾರರು ದೂರ ಉಳಿದಿದ್ದಾರೆ.

ಸ್ಥಳೀಯ ಕೋಡ್ ಅನ್ನು ಅನುಕರಿಸಲು ನೀವು ಯಾವ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಬಳಸುತ್ತೀರಿ?

• QEMU

• ಯುನಿಕಾರ್ನ್ ಎಂಜಿನ್

• ಪ್ರೋಟಿಯಸ್

• ಬೇರೆ ಏನಾದರೂ (ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಬರೆಯಿರಿ)

6 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 2 ಬಳಕೆದಾರರು ದೂರ ಉಳಿದಿದ್ದಾರೆ.

ನೀವು ಬಳಸುತ್ತಿರುವ ಎಮ್ಯುಲೇಟರ್‌ನಲ್ಲಿ ನೀವು ಏನನ್ನು ಸುಧಾರಿಸಲು ಬಯಸುತ್ತೀರಿ?

• ನನಗೆ ವೇಗ ಬೇಕು

• ನಾನು ಸೆಟಪ್/ಲಾಂಚ್‌ನ ಸುಲಭತೆಯನ್ನು ಬಯಸುತ್ತೇನೆ

• ಎಮ್ಯುಲೇಟರ್ (API, ಹುಕ್ಸ್) ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ನಾನು ಹೆಚ್ಚಿನ ಆಯ್ಕೆಗಳನ್ನು ಬಯಸುತ್ತೇನೆ

• ನಾನು ಎಲ್ಲದರಲ್ಲೂ ಸಂತೋಷವಾಗಿದ್ದೇನೆ

• ಬೇರೆ ಏನಾದರೂ (ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ ಬರೆಯಿರಿ)

8 ಬಳಕೆದಾರರು ಮತ ಹಾಕಿದ್ದಾರೆ. 1 ಬಳಕೆದಾರರು ದೂರವಿದ್ದಾರೆ.

ಮೂಲ: www.habr.com