ਇੱਕ ਬਿੱਲੀ ਦੇ ਅੰਦਰ ਗੈਂਡਾ - ਕੋਪੀਕੈਟ ਇਮੂਲੇਟਰ ਵਿੱਚ ਫਰਮਵੇਅਰ ਚਲਾਓ

ਮੀਟਿੰਗ ਦੇ ਹਿੱਸੇ ਵਜੋਂ 0x0A DC7831 DEF CON ਨਿਜ਼ਨੀ ਨੋਵਗੋਰੋਡ 16 ਫਰਵਰੀ ਨੂੰ, ਅਸੀਂ ਬਾਈਨਰੀ ਕੋਡ ਇਮੂਲੇਸ਼ਨ ਦੇ ਬੁਨਿਆਦੀ ਸਿਧਾਂਤਾਂ ਅਤੇ ਸਾਡੇ ਆਪਣੇ ਵਿਕਾਸ ਬਾਰੇ ਇੱਕ ਰਿਪੋਰਟ ਪੇਸ਼ ਕੀਤੀ - ਇੱਕ ਹਾਰਡਵੇਅਰ ਪਲੇਟਫਾਰਮ ਏਮੂਲੇਟਰ ਕਾਪੀਕੈਟ.

ਇਸ ਲੇਖ ਵਿੱਚ ਅਸੀਂ ਦੱਸਾਂਗੇ ਕਿ ਈਮੂਲੇਟਰ ਵਿੱਚ ਡਿਵਾਈਸ ਫਰਮਵੇਅਰ ਨੂੰ ਕਿਵੇਂ ਚਲਾਉਣਾ ਹੈ, ਡੀਬਗਰ ਨਾਲ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਦਾ ਪ੍ਰਦਰਸ਼ਨ ਕਰਨਾ ਹੈ, ਅਤੇ ਫਰਮਵੇਅਰ ਦਾ ਇੱਕ ਛੋਟਾ ਗਤੀਸ਼ੀਲ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ ਹੈ।

prehistory

ਬਹੁਤ ਦੂਰ ਇੱਕ ਗਲੈਕਸੀ ਵਿੱਚ ਬਹੁਤ ਸਮਾਂ ਪਹਿਲਾਂ

ਕੁਝ ਸਾਲ ਪਹਿਲਾਂ ਸਾਡੀ ਪ੍ਰਯੋਗਸ਼ਾਲਾ ਵਿੱਚ ਇੱਕ ਡਿਵਾਈਸ ਦੇ ਫਰਮਵੇਅਰ ਦੀ ਜਾਂਚ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਸੀ. ਫਰਮਵੇਅਰ ਨੂੰ ਬੂਟਲੋਡਰ ਨਾਲ ਸੰਕੁਚਿਤ ਅਤੇ ਅਨਪੈਕ ਕੀਤਾ ਗਿਆ ਸੀ। ਉਸਨੇ ਇਹ ਬਹੁਤ ਗੁੰਝਲਦਾਰ ਤਰੀਕੇ ਨਾਲ ਕੀਤਾ, ਮੈਮੋਰੀ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਕਈ ਵਾਰ ਸ਼ਿਫਟ ਕੀਤਾ। ਅਤੇ ਫਰਮਵੇਅਰ ਨੇ ਫਿਰ ਪੈਰੀਫਿਰਲਾਂ ਨਾਲ ਸਰਗਰਮੀ ਨਾਲ ਗੱਲਬਾਤ ਕੀਤੀ. ਅਤੇ ਇਹ ਸਭ MIPS ਕੋਰ 'ਤੇ ਹੈ।

ਉਦੇਸ਼ ਕਾਰਨਾਂ ਕਰਕੇ, ਉਪਲਬਧ ਇਮੂਲੇਟਰ ਸਾਡੇ ਲਈ ਅਨੁਕੂਲ ਨਹੀਂ ਸਨ, ਪਰ ਅਸੀਂ ਫਿਰ ਵੀ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਸੀ। ਫਿਰ ਅਸੀਂ ਆਪਣਾ ਖੁਦ ਦਾ ਈਮੂਲੇਟਰ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ, ਜੋ ਘੱਟੋ ਘੱਟ ਕਰੇਗਾ ਅਤੇ ਸਾਨੂੰ ਮੁੱਖ ਫਰਮਵੇਅਰ ਨੂੰ ਅਨਪੈਕ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦੇਵੇਗਾ। ਅਸੀਂ ਇਸ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਅਤੇ ਇਹ ਕੰਮ ਕੀਤਾ. ਅਸੀਂ ਸੋਚਿਆ, ਜੇ ਅਸੀਂ ਮੁੱਖ ਫਰਮਵੇਅਰ ਨੂੰ ਕਰਨ ਲਈ ਪੈਰੀਫਿਰਲ ਜੋੜਦੇ ਹਾਂ ਤਾਂ ਕੀ ਹੋਵੇਗਾ। ਇਹ ਬਹੁਤ ਜ਼ਿਆਦਾ ਦੁਖੀ ਨਹੀਂ ਹੋਇਆ - ਅਤੇ ਇਹ ਕੰਮ ਵੀ ਹੋਇਆ. ਅਸੀਂ ਦੁਬਾਰਾ ਸੋਚਿਆ ਅਤੇ ਇੱਕ ਪੂਰਾ ਇਮੂਲੇਟਰ ਬਣਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ.

ਨਤੀਜਾ ਇੱਕ ਕੰਪਿਊਟਰ ਸਿਸਟਮ ਈਮੂਲੇਟਰ ਸੀ ਕਾਪੀਕੈਟ.

ਕੋਪੀਕੈਟ ਕਿਉਂ?

ਸ਼ਬਦਾਂ ਦਾ ਨਾਟਕ ਹੈ।

1. copycat (ਅੰਗਰੇਜ਼ੀ, ਨਾਂਵ [ˈkɒpɪkæt]) - ਨਕਲ ਕਰਨ ਵਾਲਾ, ਨਕਲ ਕਰਨ ਵਾਲਾ
2. ਬਿੱਲੀ (ਅੰਗਰੇਜ਼ੀ, ਨਾਂਵ [ˈkæt]) - ਬਿੱਲੀ, ਬਿੱਲੀ - ਪ੍ਰੋਜੈਕਟ ਦੇ ਸਿਰਜਣਹਾਰਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦਾ ਪਸੰਦੀਦਾ ਜਾਨਵਰ
3. ਅੱਖਰ “K” ਕੋਟਲਿਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਭਾਸ਼ਾ ਤੋਂ ਹੈ

ਕਾਪੀਕੈਟ

ਈਮੂਲੇਟਰ ਬਣਾਉਣ ਵੇਲੇ, ਬਹੁਤ ਖਾਸ ਟੀਚੇ ਨਿਰਧਾਰਤ ਕੀਤੇ ਗਏ ਸਨ:

• ਤੇਜ਼ੀ ਨਾਲ ਨਵੇਂ ਪੈਰੀਫਿਰਲ, ਮੋਡੀਊਲ, ਪ੍ਰੋਸੈਸਰ ਕੋਰ ਬਣਾਉਣ ਦੀ ਯੋਗਤਾ;
• ਵੱਖ-ਵੱਖ ਮੋਡੀਊਲਾਂ ਤੋਂ ਵਰਚੁਅਲ ਡਿਵਾਈਸ ਨੂੰ ਇਕੱਠਾ ਕਰਨ ਦੀ ਸਮਰੱਥਾ;
• ਕਿਸੇ ਵੀ ਬਾਈਨਰੀ ਡੇਟਾ (ਫਰਮਵੇਅਰ) ਨੂੰ ਇੱਕ ਵਰਚੁਅਲ ਡਿਵਾਈਸ ਦੀ ਮੈਮੋਰੀ ਵਿੱਚ ਲੋਡ ਕਰਨ ਦੀ ਸਮਰੱਥਾ;
• ਸਨੈਪਸ਼ਾਟ (ਸਿਸਟਮ ਸਟੇਟ ਦੇ ਸਨੈਪਸ਼ਾਟ) ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਯੋਗਤਾ;
• ਬਿਲਟ-ਇਨ ਡੀਬਗਰ ਦੁਆਰਾ ਈਮੂਲੇਟਰ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੀ ਸਮਰੱਥਾ;
• ਵਿਕਾਸ ਲਈ ਵਧੀਆ ਆਧੁਨਿਕ ਭਾਸ਼ਾ।

ਨਤੀਜੇ ਵਜੋਂ, ਕੋਟਲਿਨ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਚੁਣਿਆ ਗਿਆ ਸੀ, ਬੱਸ ਆਰਕੀਟੈਕਚਰ (ਇਹ ਉਦੋਂ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਮੋਡੀਊਲ ਇੱਕ ਦੂਜੇ ਨਾਲ ਵਰਚੁਅਲ ਡਾਟਾ ਬੱਸਾਂ ਰਾਹੀਂ ਸੰਚਾਰ ਕਰਦੇ ਹਨ), ਡਿਵਾਈਸ ਵਰਣਨ ਫਾਰਮੈਟ ਵਜੋਂ JSON, ਅਤੇ ਡੀਬਗਰ ਨਾਲ ਗੱਲਬਾਤ ਲਈ ਪ੍ਰੋਟੋਕੋਲ ਵਜੋਂ GDB RSP।

ਵਿਕਾਸ ਦੋ ਸਾਲਾਂ ਤੋਂ ਥੋੜਾ ਜਿਹਾ ਹੋ ਰਿਹਾ ਹੈ ਅਤੇ ਸਰਗਰਮੀ ਨਾਲ ਜਾਰੀ ਹੈ। ਇਸ ਸਮੇਂ ਦੌਰਾਨ, MIPS, x86, V850ES, ARM, ਅਤੇ PowerPC ਪ੍ਰੋਸੈਸਰ ਕੋਰ ਲਾਗੂ ਕੀਤੇ ਗਏ ਸਨ।

ਪ੍ਰੋਜੈਕਟ ਵਧ ਰਿਹਾ ਹੈ ਅਤੇ ਇਸ ਨੂੰ ਵਿਆਪਕ ਜਨਤਾ ਲਈ ਪੇਸ਼ ਕਰਨ ਦਾ ਸਮਾਂ ਹੈ. ਅਸੀਂ ਪ੍ਰੋਜੈਕਟ ਦਾ ਵਿਸਤ੍ਰਿਤ ਵੇਰਵਾ ਬਾਅਦ ਵਿੱਚ ਕਰਾਂਗੇ, ਪਰ ਹੁਣ ਲਈ ਅਸੀਂ ਕੋਪੀਕੈਟ ਦੀ ਵਰਤੋਂ ਕਰਨ 'ਤੇ ਧਿਆਨ ਦੇਵਾਂਗੇ।

ਸਭ ਤੋਂ ਬੇਚੈਨ ਲਈ, ਇਮੂਲੇਟਰ ਦਾ ਇੱਕ ਪ੍ਰੋਮੋ ਸੰਸਕਰਣ ਡਾਊਨਲੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਲਿੰਕ ਨੂੰ.

ਇਮੂਲੇਟਰ ਵਿੱਚ ਰਾਈਨੋ

ਯਾਦ ਕਰੀਏ ਕਿ ਇਸ ਤੋਂ ਪਹਿਲਾਂ SMARTRHINO-2018 ਕਾਨਫਰੰਸ ਲਈ, ਰਿਵਰਸ ਇੰਜੀਨੀਅਰਿੰਗ ਹੁਨਰ ਸਿਖਾਉਣ ਲਈ ਇੱਕ ਟੈਸਟ ਯੰਤਰ “Rhinoceros” ਬਣਾਇਆ ਗਿਆ ਸੀ। ਵਿੱਚ ਸਥਿਰ ਫਰਮਵੇਅਰ ਵਿਸ਼ਲੇਸ਼ਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਦਾ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਸੀ ਇਸ ਲੇਖ.

ਹੁਣ ਆਉ "ਸਪੀਕਰ" ਜੋੜਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ ਅਤੇ ਈਮੂਲੇਟਰ ਵਿੱਚ ਫਰਮਵੇਅਰ ਨੂੰ ਚਲਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ।

ਸਾਨੂੰ ਲੋੜ ਹੋਵੇਗੀ:
1) Java 1.8
2) ਪਾਈਥਨ ਅਤੇ ਮੋਡੀਊਲ ਜੀਪ ਏਮੂਲੇਟਰ ਦੇ ਅੰਦਰ ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ। ਤੁਸੀਂ ਵਿੰਡੋਜ਼ ਲਈ WHL ਮੋਡੀਊਲ Jep ਬਣਾ ਸਕਦੇ ਹੋ ਇੱਥੇ ਡਾਊਨਲੋਡ ਕਰੋ.

ਵਿੰਡੋਜ਼ ਲਈ:
1) com0com
2) ਪੁਟੀ

ਲੀਨਕਸ ਲਈ:
1) ਸੋਕਟ

ਤੁਸੀਂ Eclipse, 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"]
  ]
}

ਪੈਰਾਮੀਟਰ ਵੱਲ ਧਿਆਨ ਦਿਓ ਫਰਮਵੇਅਰ ਅਧਿਆਇ ਵਿਚ params ਇੱਕ ਫਾਈਲ ਦਾ ਨਾਮ ਹੈ ਜੋ ਇੱਕ ਵਰਚੁਅਲ ਡਿਵਾਈਸ ਵਿੱਚ ਫਰਮਵੇਅਰ ਦੇ ਰੂਪ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।

ਵਰਚੁਅਲ ਜੰਤਰ ਅਤੇ ਮੁੱਖ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਨਾਲ ਇਸ ਦੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਹੇਠ ਲਿਖੇ ਚਿੱਤਰ ਦੁਆਰਾ ਦਰਸਾਇਆ ਜਾ ਸਕਦਾ ਹੈ:

ਇਮੂਲੇਟਰ ਦੇ ਮੌਜੂਦਾ ਟੈਸਟ ਉਦਾਹਰਨ ਵਿੱਚ ਮੁੱਖ OS ਦੀਆਂ COM ਪੋਰਟਾਂ (ਬਲਿਊਟੁੱਥ ਮੋਡੀਊਲ ਲਈ ਡੀਬੱਗ UART ਅਤੇ UART) ਨਾਲ ਗੱਲਬਾਤ ਸ਼ਾਮਲ ਹੈ। ਇਹ ਅਸਲ ਪੋਰਟ ਹੋ ਸਕਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨਾਲ ਡਿਵਾਈਸਾਂ ਕਨੈਕਟ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ ਜਾਂ ਵਰਚੁਅਲ COM ਪੋਰਟਾਂ (ਇਸਦੇ ਲਈ ਤੁਹਾਨੂੰ ਸਿਰਫ ਲੋੜ ਹੈ com0com/socat).

ਇਸ ਸਮੇਂ ਬਾਹਰੋਂ ਈਮੂਲੇਟਰ ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਦੇ ਦੋ ਮੁੱਖ ਤਰੀਕੇ ਹਨ:

• GDB RSP ਪ੍ਰੋਟੋਕੋਲ (ਅਨੁਸਾਰ, ਇਸ ਪ੍ਰੋਟੋਕੋਲ ਦਾ ਸਮਰਥਨ ਕਰਨ ਵਾਲੇ ਸਾਧਨ Eclipse / IDA / radare2 ਹਨ);
• ਅੰਦਰੂਨੀ ਇਮੂਲੇਟਰ ਕਮਾਂਡ ਲਾਈਨ (ਆਰਗਪਾਰਸ ਜਾਂ ਪਾਈਥਨ)।

ਵਰਚੁਅਲ COM ਪੋਰਟ

ਇੱਕ ਟਰਮੀਨਲ ਦੁਆਰਾ ਸਥਾਨਕ ਮਸ਼ੀਨ ਉੱਤੇ ਇੱਕ ਵਰਚੁਅਲ ਡਿਵਾਈਸ ਦੇ UART ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਸੰਬੰਧਿਤ ਵਰਚੁਅਲ COM ਪੋਰਟਾਂ ਦੀ ਇੱਕ ਜੋੜਾ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇੱਕ ਪੋਰਟ ਇਮੂਲੇਟਰ ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਦੂਜੀ ਇੱਕ ਟਰਮੀਨਲ ਪ੍ਰੋਗਰਾਮ (PuTTY ਜਾਂ ਸਕ੍ਰੀਨ) ਦੁਆਰਾ ਵਰਤੀ ਜਾਂਦੀ ਹੈ:

com0com ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਵਰਚੁਅਲ COM ਪੋਰਟਾਂ ਨੂੰ com0com ਕਿੱਟ (ਕੰਸੋਲ ਸੰਸਕਰਣ -) ਤੋਂ ਸੈੱਟਅੱਪ ਸਹੂਲਤ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੰਰਚਿਤ ਕੀਤਾ ਗਿਆ ਹੈ C: ਪ੍ਰੋਗਰਾਮ ਫਾਈਲਾਂ (x86)com0comsetupс.exe, ਜਾਂ GUI ਸੰਸਕਰਣ - C: ਪ੍ਰੋਗਰਾਮ ਫਾਈਲਾਂ (x86)com0comsetupg.exe):

ਬਕਸਿਆਂ ਦੀ ਜਾਂਚ ਕਰੋ ਬਫਰ ਓਵਰਰਨ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ ਸਾਰੀਆਂ ਬਣਾਈਆਂ ਗਈਆਂ ਵਰਚੁਅਲ ਪੋਰਟਾਂ ਲਈ, ਨਹੀਂ ਤਾਂ ਈਮੂਲੇਟਰ COM ਪੋਰਟ ਤੋਂ ਜਵਾਬ ਦੀ ਉਡੀਕ ਕਰੇਗਾ।

socat ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ

UNIX ਸਿਸਟਮਾਂ 'ਤੇ, ਵਰਚੁਅਲ COM ਪੋਰਟਾਂ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਈਮੂਲੇਟਰ ਦੁਆਰਾ socat ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਬਣਾਈਆਂ ਜਾਂਦੀਆਂ ਹਨ; ਅਜਿਹਾ ਕਰਨ ਲਈ, ਸਿਰਫ ਈਮੂਲੇਟਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨ ਵੇਲੇ ਪੋਰਟ ਨਾਮ ਵਿੱਚ ਅਗੇਤਰ ਦਿਓ। socat:.

ਅੰਦਰੂਨੀ ਕਮਾਂਡ ਲਾਈਨ ਇੰਟਰਫੇਸ (ਆਰਗਪਾਰਸ ਜਾਂ ਪਾਈਥਨ)

ਕਿਉਂਕਿ ਕੋਪੀਕੈਟ ਇੱਕ ਕੰਸੋਲ ਐਪਲੀਕੇਸ਼ਨ ਹੈ, ਇਮੂਲੇਟਰ ਇਸਦੇ ਆਬਜੈਕਟ ਅਤੇ ਵੇਰੀਏਬਲਾਂ ਨਾਲ ਇੰਟਰਫੇਸ ਕਰਨ ਲਈ ਦੋ ਕਮਾਂਡ ਲਾਈਨ ਇੰਟਰਫੇਸ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ: ਆਰਗਪਾਰਸ ਅਤੇ ਪਾਈਥਨ।

ਅਰਗਪਾਰਸ ਇੱਕ CLI ਹੈ ਜੋ ਕੋਪੀਕੈਟ ਵਿੱਚ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਹਮੇਸ਼ਾ ਹਰ ਕਿਸੇ ਲਈ ਉਪਲਬਧ ਹੁੰਦਾ ਹੈ।

ਇੱਕ ਵਿਕਲਪਿਕ CLI ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਹੈ। ਇਸਨੂੰ ਵਰਤਣ ਲਈ, ਤੁਹਾਨੂੰ ਜੇਪ ਪਾਈਥਨ ਮੋਡੀਊਲ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਅਤੇ ਪਾਇਥਨ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਏਮੂਲੇਟਰ ਨੂੰ ਸੰਰਚਿਤ ਕਰਨ ਦੀ ਲੋੜ ਹੈ (ਉਪਭੋਗਤਾ ਦੇ ਮੁੱਖ ਸਿਸਟਮ 'ਤੇ ਸਥਾਪਿਤ ਪਾਈਥਨ ਇੰਟਰਪ੍ਰੇਟਰ ਵਰਤਿਆ ਜਾਵੇਗਾ)।

ਪਾਈਥਨ ਮੋਡੀਊਲ ਜੇਪੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ

ਲੀਨਕਸ ਜੇਪ ਦੇ ਤਹਿਤ ਪਾਈਪ ਦੁਆਰਾ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

pip install jep

ਵਿੰਡੋਜ਼ 'ਤੇ ਜੇਪ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਵਿੰਡੋਜ਼ SDK ਅਤੇ ਸੰਬੰਧਿਤ Microsoft ਵਿਜ਼ੁਅਲ ਸਟੂਡੀਓ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ ਤੁਹਾਡੇ ਲਈ ਥੋੜਾ ਆਸਾਨ ਬਣਾ ਦਿੱਤਾ ਹੈ ਅਤੇ WHL ਬਣਾਉਂਦਾ ਹੈ ਵਿੰਡੋਜ਼ ਲਈ ਪਾਈਥਨ ਦੇ ਮੌਜੂਦਾ ਸੰਸਕਰਣਾਂ ਲਈ ਜੇਈਪੀ, ਇਸ ਲਈ ਮੋਡੀਊਲ ਨੂੰ ਫਾਈਲ ਤੋਂ ਸਥਾਪਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

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 - ਵਿੰਡੋਜ਼ ਲਈ, ਕਾਪੀ ਕੈਟ - ਲੀਨਕਸ ਲਈ) ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚ DEFAULT_JVM_OPTS ਇੱਕ ਵਾਧੂ ਪੈਰਾਮੀਟਰ ਸ਼ਾਮਲ ਕਰੋ Djava.library.path — ਇਸ ਵਿੱਚ ਇੰਸਟਾਲ ਕੀਤੇ Jep ਮੋਡੀਊਲ ਦਾ ਮਾਰਗ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਵਿੰਡੋਜ਼ ਲਈ ਨਤੀਜਾ ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਇੱਕ ਲਾਈਨ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ:

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 ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੀਨਕਸ ਦੇ ਅਧੀਨ ਚਲਾਉਣ ਲਈ ਕਮਾਂਡ:

./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 — TCP ਪੋਰਟ ਜੋ GDB ਸਰਵਰ ਤੱਕ ਪਹੁੰਚ ਲਈ ਖੁੱਲ੍ਹਾ ਹੋਵੇਗਾ;
• -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 ਪ੍ਰੋ ਨਾਲ ਗੱਲਬਾਤ

ਟੈਸਟਿੰਗ ਨੂੰ ਸਰਲ ਬਣਾਉਣ ਲਈ, ਅਸੀਂ ਫਾਰਮ ਵਿੱਚ IDA ਵਿੱਚ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਸਰੋਤ ਫਾਈਲ ਵਜੋਂ Rhino ਫਰਮਵੇਅਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ ELF ਫਾਈਲ (ਮੈਟਾ ਜਾਣਕਾਰੀ ਉੱਥੇ ਸਟੋਰ ਕੀਤੀ ਜਾਂਦੀ ਹੈ)।

ਤੁਸੀਂ ਮੈਟਾ ਜਾਣਕਾਰੀ ਤੋਂ ਬਿਨਾਂ ਮੁੱਖ ਫਰਮਵੇਅਰ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।

IDA ਪ੍ਰੋ ਵਿੱਚ ਕੋਪੀਕੈਟ ਲਾਂਚ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਡੀਬੱਗਰ ਮੀਨੂ ਵਿੱਚ ਆਈਟਮ 'ਤੇ ਜਾਓ “ਡੀਬਗਰ ਸਵਿੱਚ ਕਰੋ..."ਅਤੇ ਚੁਣੋ"ਰਿਮੋਟ GDB ਡੀਬੱਗਰ". ਅੱਗੇ, ਕਨੈਕਸ਼ਨ ਸੈਟ ਅਪ ਕਰੋ: ਮੀਨੂ ਡੀਬੱਗਰ - ਪ੍ਰਕਿਰਿਆ ਵਿਕਲਪ...

ਮੁੱਲ ਸੈੱਟ ਕਰੋ:

• ਐਪਲੀਕੇਸ਼ਨ - ਕੋਈ ਵੀ ਮੁੱਲ
• ਹੋਸਟ-ਨਾਂ: 127.0.0.1 (ਜਾਂ ਰਿਮੋਟ ਮਸ਼ੀਨ ਦਾ IP ਪਤਾ ਜਿੱਥੇ ਕੋਪੀਕੈਟ ਚੱਲ ਰਿਹਾ ਹੈ)
• ਪੋਰਟ: 23946

ਹੁਣ ਡੀਬਗਿੰਗ ਬਟਨ ਉਪਲਬਧ ਹੋ ਜਾਂਦਾ ਹੈ (F9 ਕੁੰਜੀ):

ਈਮੂਲੇਟਰ ਵਿੱਚ ਡੀਬੱਗਰ ਮੋਡੀਊਲ ਨਾਲ ਜੁੜਨ ਲਈ ਇਸਨੂੰ ਕਲਿੱਕ ਕਰੋ। IDA ਡੀਬਗਿੰਗ ਮੋਡ ਵਿੱਚ ਚਲਾ ਜਾਂਦਾ ਹੈ, ਵਾਧੂ ਵਿੰਡੋਜ਼ ਉਪਲਬਧ ਹੋ ਜਾਂਦੀਆਂ ਹਨ: ਰਜਿਸਟਰਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ, ਸਟੈਕ ਬਾਰੇ।

ਹੁਣ ਅਸੀਂ ਡੀਬਗਰ ਦੀਆਂ ਸਾਰੀਆਂ ਮਿਆਰੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ:

• ਨਿਰਦੇਸ਼ਾਂ ਦਾ ਕਦਮ-ਦਰ-ਕਦਮ ਐਗਜ਼ੀਕਿਊਸ਼ਨ (ਵਿੱਚ ਕਦਮ и ਵੱਧ ਕਦਮ - ਕ੍ਰਮਵਾਰ F7 ਅਤੇ F8 ਕੁੰਜੀਆਂ);
• ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸ਼ੁਰੂ ਕਰਨਾ ਅਤੇ ਰੋਕਣਾ;
• ਕੋਡ ਅਤੇ ਡੇਟਾ (F2 ਕੁੰਜੀ) ਦੋਵਾਂ ਲਈ ਬ੍ਰੇਕਪੁਆਇੰਟ ਬਣਾਉਣਾ।

ਡੀਬਗਰ ਨਾਲ ਜੁੜਨ ਦਾ ਮਤਲਬ ਫਰਮਵੇਅਰ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਨਹੀਂ ਹੈ। ਮੌਜੂਦਾ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਸਥਿਤੀ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ 0x08006A74 - ਫੰਕਸ਼ਨ ਦੀ ਸ਼ੁਰੂਆਤ ਰੀਸੈਟ_ਹੈਂਡਲਰ. ਜੇਕਰ ਤੁਸੀਂ ਸੂਚੀ ਨੂੰ ਹੇਠਾਂ ਸਕ੍ਰੋਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਕਾਲ ਦੇਖ ਸਕਦੇ ਹੋ ਮੁੱਖ. ਤੁਸੀਂ ਕਰਸਰ ਨੂੰ ਇਸ ਲਾਈਨ (ਪਤਾ 0x08006ABE) ਅਤੇ ਕਾਰਵਾਈ ਕਰੋ ਕਰਸਰ ਤੱਕ ਚਲਾਓ (ਕੁੰਜੀ F4)।

ਅੱਗੇ, ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਵਿੱਚ ਦਾਖਲ ਹੋਣ ਲਈ F7 ਦਬਾ ਸਕਦੇ ਹੋ ਮੁੱਖ.

ਜੇਕਰ ਤੁਸੀਂ ਕਮਾਂਡ ਚਲਾਉਂਦੇ ਹੋ ਪ੍ਰਕਿਰਿਆ ਜਾਰੀ ਰੱਖੋ (F9 ਕੁੰਜੀ), ਫਿਰ "ਕਿਰਪਾ ਕਰਕੇ ਉਡੀਕ ਕਰੋ" ਵਿੰਡੋ ਇੱਕ ਸਿੰਗਲ ਬਟਨ ਨਾਲ ਦਿਖਾਈ ਦੇਵੇਗੀ ਸਸਪੈਂਡ:

ਜਦੋਂ ਤੁਸੀਂ ਦਬਾਉਂਦੇ ਹੋ ਸਸਪੈਂਡ ਫਰਮਵੇਅਰ ਕੋਡ ਦੀ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਮੁਅੱਤਲ ਕਰ ਦਿੱਤਾ ਗਿਆ ਹੈ ਅਤੇ ਕੋਡ ਵਿੱਚ ਉਸੇ ਪਤੇ ਤੋਂ ਜਾਰੀ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ ਜਿੱਥੇ ਇਸਨੂੰ ਰੋਕਿਆ ਗਿਆ ਸੀ।

ਜੇਕਰ ਤੁਸੀਂ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਜਾਰੀ ਰੱਖਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਵਰਚੁਅਲ COM ਪੋਰਟਾਂ ਨਾਲ ਜੁੜੇ ਟਰਮੀਨਲਾਂ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਲਾਈਨਾਂ ਦੇਖੋਗੇ:

"ਸਟੇਟ ਬਾਈਪਾਸ" ਲਾਈਨ ਦੀ ਮੌਜੂਦਗੀ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਵਰਚੁਅਲ ਬਲੂਟੁੱਥ ਮੋਡੀਊਲ ਉਪਭੋਗਤਾ ਦੇ COM ਪੋਰਟ ਤੋਂ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਮੋਡ ਵਿੱਚ ਬਦਲ ਗਿਆ ਹੈ।

ਹੁਣ ਬਲੂਟੁੱਥ ਟਰਮੀਨਲ (ਤਸਵੀਰ ਵਿੱਚ COM29) ਵਿੱਚ ਤੁਸੀਂ ਰਾਈਨੋ ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਅਨੁਸਾਰ ਕਮਾਂਡਾਂ ਦਰਜ ਕਰ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, "MEOW" ਕਮਾਂਡ ਬਲੂਟੁੱਥ ਟਰਮੀਨਲ 'ਤੇ "mur-mur" ਸਤਰ ਵਾਪਸ ਕਰੇਗੀ:

ਮੈਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਕਲ ਨਾ ਕਰੋ

ਇੱਕ ਇਮੂਲੇਟਰ ਬਣਾਉਂਦੇ ਸਮੇਂ, ਤੁਸੀਂ ਕਿਸੇ ਖਾਸ ਡਿਵਾਈਸ ਦੇ ਵੇਰਵੇ/ਇਮੂਲੇਸ਼ਨ ਦਾ ਪੱਧਰ ਚੁਣ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਨ ਲਈ, ਬਲੂਟੁੱਥ ਮੋਡੀਊਲ ਨੂੰ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਨਕਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

• ਡਿਵਾਈਸ ਨੂੰ ਕਮਾਂਡਾਂ ਦੇ ਪੂਰੇ ਸੈੱਟ ਨਾਲ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਕਲ ਕੀਤਾ ਗਿਆ ਹੈ;
• AT ਕਮਾਂਡਾਂ ਦੀ ਨਕਲ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਅਤੇ ਡੇਟਾ ਸਟ੍ਰੀਮ ਮੁੱਖ ਸਿਸਟਮ ਦੇ COM ਪੋਰਟ ਤੋਂ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ;
• ਵਰਚੁਅਲ ਡਿਵਾਈਸ ਅਸਲੀ ਡਿਵਾਈਸ ਨੂੰ ਪੂਰਾ ਡਾਟਾ ਰੀਡਾਇਰੈਕਸ਼ਨ ਪ੍ਰਦਾਨ ਕਰਦੀ ਹੈ;
• ਇੱਕ ਸਧਾਰਨ ਸਟੱਬ ਵਜੋਂ ਜੋ ਹਮੇਸ਼ਾ "ਠੀਕ ਹੈ" ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਈਮੂਲੇਟਰ ਦਾ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਦੂਜੀ ਪਹੁੰਚ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ - ਵਰਚੁਅਲ ਬਲੂਟੁੱਥ ਮੋਡੀਊਲ ਕੌਂਫਿਗਰੇਸ਼ਨ ਕਰਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਇਹ ਮੁੱਖ ਸਿਸਟਮ ਦੇ COM ਪੋਰਟ ਤੋਂ ਈਮੂਲੇਟਰ ਦੇ UART ਪੋਰਟ 'ਤੇ ਡਾਟਾ "ਪ੍ਰੌਕਸਿੰਗ" ਮੋਡ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।

ਆਉ ਕੋਡ ਦੇ ਸਧਾਰਨ ਸਾਧਨ ਦੀ ਸੰਭਾਵਨਾ 'ਤੇ ਵਿਚਾਰ ਕਰੀਏ ਜੇ ਪੈਰੀਫੇਰੀ ਦੇ ਕੁਝ ਹਿੱਸੇ ਨੂੰ ਲਾਗੂ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ DMA ਨੂੰ ਡਾਟਾ ਟ੍ਰਾਂਸਫਰ ਨੂੰ ਕੰਟਰੋਲ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਟਾਈਮਰ ਨਹੀਂ ਬਣਾਇਆ ਗਿਆ ਹੈ (ਚੈੱਕ ਫੰਕਸ਼ਨ ਵਿੱਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ws2812b_ਉਡੀਕ ਕਰੋ'ਤੇ ਸਥਿਤ 0x08006840), ਫਿਰ ਫਰਮਵੇਅਰ ਹਮੇਸ਼ਾ ਫਲੈਗ ਦੇ ਰੀਸੈਟ ਹੋਣ ਦੀ ਉਡੀਕ ਕਰੇਗਾ ਰੁੱਝੇ'ਤੇ ਸਥਿਤ 0x200004C4ਜੋ ਕਿ DMA ਡੇਟਾ ਲਾਈਨ ਦੇ ਕਬਜ਼ੇ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

ਅਸੀਂ ਫਲੈਗ ਨੂੰ ਹੱਥੀਂ ਰੀਸੈਟ ਕਰਕੇ ਇਸ ਸਥਿਤੀ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰ ਸਕਦੇ ਹਾਂ ਰੁੱਝੇ ਇਸ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਦੇ ਤੁਰੰਤ ਬਾਅਦ. IDA ਪ੍ਰੋ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਬਣਾ ਸਕਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਬ੍ਰੇਕਪੁਆਇੰਟ ਵਿੱਚ ਕਾਲ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਫਲੈਗ ਵਿੱਚ ਮੁੱਲ 1 ਲਿਖਣ ਤੋਂ ਬਾਅਦ ਬ੍ਰੇਕਪੁਆਇੰਟ ਨੂੰ ਆਪਣੇ ਆਪ ਕੋਡ ਵਿੱਚ ਪਾ ਸਕਦੇ ਹੋ। ਰੁੱਝੇ.

ਬ੍ਰੇਕਪੁਆਇੰਟ ਹੈਂਡਲਰ

ਪਹਿਲਾਂ, ਆਓ IDA ਵਿੱਚ ਇੱਕ ਪਾਈਥਨ ਫੰਕਸ਼ਨ ਬਣਾਈਏ। ਮੀਨੂ ਫਾਈਲ - ਸਕ੍ਰਿਪਟ ਕਮਾਂਡ...

ਖੱਬੇ ਪਾਸੇ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਨਵਾਂ ਸਨਿੱਪਟ ਸ਼ਾਮਲ ਕਰੋ, ਇਸਨੂੰ ਇੱਕ ਨਾਮ ਦਿਓ (ਉਦਾਹਰਨ ਲਈ, ਬੀਪੀਟੀ),
ਸੱਜੇ ਪਾਸੇ ਟੈਕਸਟ ਖੇਤਰ ਵਿੱਚ, ਫੰਕਸ਼ਨ ਕੋਡ ਦਰਜ ਕਰੋ:

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 ਕਾਰਜਾਂ ਵਿਚਕਾਰ ਗਤੀਸ਼ੀਲ ਤੌਰ 'ਤੇ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਕਿਵੇਂ ਸਥਾਪਿਤ ਕਰਨਾ ਹੈ। ਤੁਹਾਨੂੰ ਪਹਿਲਾਂ ਕੋਡ ਦੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕਣਾ ਚਾਹੀਦਾ ਹੈ ਜੇਕਰ ਇਹ ਚੱਲ ਰਿਹਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਫੰਕਸ਼ਨ 'ਤੇ ਜਾਂਦੇ ਹੋ ਬਲੂਟੁੱਥ_ਟਾਸਕ_ਐਂਟਰੀ "LED" ਕਮਾਂਡ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਸ਼ਾਖਾ ਨੂੰ (ਪਤਾ 0x080057B8), ਫਿਰ ਤੁਸੀਂ ਦੇਖ ਸਕਦੇ ਹੋ ਕਿ ਪਹਿਲਾਂ ਕੀ ਬਣਾਇਆ ਗਿਆ ਹੈ ਅਤੇ ਫਿਰ ਸਿਸਟਮ ਕਤਾਰ ਵਿੱਚ ਭੇਜਿਆ ਗਿਆ ਹੈ ledControlQueueHandle ਕੁਝ ਸੁਨੇਹਾ।

ਤੁਹਾਨੂੰ ਵੇਰੀਏਬਲ ਤੱਕ ਪਹੁੰਚ ਕਰਨ ਲਈ ਇੱਕ ਬ੍ਰੇਕਪੁਆਇੰਟ ਸੈੱਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ledControlQueueHandle'ਤੇ ਸਥਿਤ 0x20000624 ਅਤੇ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ ਜਾਰੀ ਰੱਖੋ:

ਨਤੀਜੇ ਵਜੋਂ, ਸਟਾਪ ਪਹਿਲਾਂ ਪਤੇ 'ਤੇ ਹੋਵੇਗਾ 0x080057CA ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ osMailAlloc, ਫਿਰ ਪਤੇ 'ਤੇ 0x08005806 ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ osMailPut, ਫਿਰ ਕੁਝ ਦੇਰ ਬਾਅਦ - ਪਤੇ 'ਤੇ 0x08005BD4 (ਫੰਕਸ਼ਨ ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ osMailGet), ਜੋ ਕਿ ਫੰਕਸ਼ਨ ਨਾਲ ਸਬੰਧਤ ਹੈ leds_task_entry (LED-ਟਾਸਕ), ਯਾਨੀ, ਕੰਮ ਬਦਲ ਗਏ ਹਨ, ਅਤੇ ਹੁਣ LED-ਟਾਸਕ ਨੂੰ ਕੰਟਰੋਲ ਪ੍ਰਾਪਤ ਹੋਇਆ ਹੈ।

ਇਸ ਸਰਲ ਤਰੀਕੇ ਨਾਲ ਤੁਸੀਂ ਇਹ ਸਥਾਪਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ RTOS ਟਾਸਕ ਇੱਕ ਦੂਜੇ ਨਾਲ ਕਿਵੇਂ ਇੰਟਰੈਕਟ ਕਰਦੇ ਹਨ।

ਬੇਸ਼ੱਕ, ਅਸਲ ਵਿੱਚ, ਕਾਰਜਾਂ ਦੀ ਆਪਸੀ ਤਾਲਮੇਲ ਵਧੇਰੇ ਗੁੰਝਲਦਾਰ ਹੋ ਸਕਦੀ ਹੈ, ਪਰ ਇੱਕ ਇਮੂਲੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਇਸ ਪਰਸਪਰ ਪ੍ਰਭਾਵ ਨੂੰ ਟਰੈਕ ਕਰਨਾ ਘੱਟ ਮਿਹਨਤੀ ਹੋ ਜਾਂਦਾ ਹੈ।

ਇੱਥੇ ਤੁਸੀਂ IDA ਪ੍ਰੋ ਦੇ ਨਾਲ ਏਮੂਲੇਟਰ ਲਾਂਚ ਕਰਨ ਅਤੇ ਇੰਟਰੈਕਟ ਕਰਨ ਦਾ ਇੱਕ ਛੋਟਾ ਵੀਡੀਓ ਦੇਖ ਸਕਦੇ ਹੋ।

Radare2 ਨਾਲ ਲਾਂਚ ਕਰੋ

ਤੁਸੀਂ Radare2 ਵਰਗੇ ਯੂਨੀਵਰਸਲ ਟੂਲ ਨੂੰ ਨਜ਼ਰਅੰਦਾਜ਼ ਨਹੀਂ ਕਰ ਸਕਦੇ।

r2 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇਮੂਲੇਟਰ ਨਾਲ ਜੁੜਨ ਲਈ, ਕਮਾਂਡ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗੀ:

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

ਹੁਣ ਉਪਲਬਧ ਲਾਂਚ ਕਰੋ (dc) ਅਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਨੂੰ ਰੋਕੋ (Ctrl+C)।

ਬਦਕਿਸਮਤੀ ਨਾਲ, ਇਸ ਸਮੇਂ, ਹਾਰਡਵੇਅਰ gdb ਸਰਵਰ ਅਤੇ ਮੈਮੋਰੀ ਲੇਆਉਟ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ r2 ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਹਨ; ਇਸ ਕਰਕੇ, ਬ੍ਰੇਕਪੁਆਇੰਟ ਅਤੇ ਸਟੈਪਸ ਕੰਮ ਨਹੀਂ ਕਰਦੇ (ਕਮਾਂਡ ds). ਸਾਨੂੰ ਉਮੀਦ ਹੈ ਕਿ ਇਹ ਜਲਦੀ ਹੀ ਠੀਕ ਹੋ ਜਾਵੇਗਾ।

ਈਲੈਪਸ ਨਾਲ ਚੱਲ ਰਿਹਾ ਹੈ

ਇਮੂਲੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਵਿਕਲਪਾਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ ਡਿਬੈੱਲ ਕੀਤੇ ਜਾ ਰਹੇ ਡਿਵਾਈਸ ਦੇ ਫਰਮਵੇਅਰ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ। ਸਪਸ਼ਟਤਾ ਲਈ, ਅਸੀਂ ਰਾਈਨੋ ਫਰਮਵੇਅਰ ਦੀ ਵੀ ਵਰਤੋਂ ਕਰਾਂਗੇ। ਤੁਸੀਂ ਫਰਮਵੇਅਰ ਸਰੋਤਾਂ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰ ਸਕਦੇ ਹੋ ਇੱਥੋਂ.

ਅਸੀਂ ਇੱਕ IDE ਦੇ ਰੂਪ ਵਿੱਚ ਸੈੱਟ ਤੋਂ Eclipse ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ 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 (ਪੀਸੀ ਰਜਿਸਟਰ ਨੂੰ ਪਤੇ 'ਤੇ ਮੈਮੋਰੀ ਤੋਂ ਮੁੱਲ 'ਤੇ ਸੈੱਟ ਕਰੋ 0x08000004 - ਪਤਾ ਉੱਥੇ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈ ਰੀਸੈਟ ਹੈਂਡਲਰ).

ਧਿਆਨ ਦੇਵੋ, ਜੇਕਰ ਤੁਸੀਂ Eclipse ਤੋਂ ਫਰਮਵੇਅਰ ਫਾਈਲ ਨੂੰ ਡਾਊਨਲੋਡ ਨਹੀਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਵਿਕਲਪ ਚਿੱਤਰ ਲੋਡ ਕਰੋ и ਕਮਾਂਡਾਂ ਚਲਾਓ ਦਰਸਾਉਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ।

ਡੀਬੱਗ 'ਤੇ ਕਲਿੱਕ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਡੀਬੱਗਰ ਮੋਡ ਵਿੱਚ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ:

• ਕਦਮ-ਦਰ-ਕਦਮ ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ
  
• ਬ੍ਰੇਕਪੁਆਇੰਟ ਨਾਲ ਗੱਲਬਾਤ ਕਰਨਾ
  

ਟਿੱਪਣੀ. ਗ੍ਰਹਿਣ ਵਿੱਚ, ਹਮ... ਕੁਝ ਵਿਅੰਗ ਹਨ... ਅਤੇ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਨਾਲ ਰਹਿਣਾ ਪਵੇਗਾ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਡੀਬਗਰ ਨੂੰ ਸ਼ੁਰੂ ਕਰਦੇ ਸਮੇਂ ਸੁਨੇਹਾ “0x0″ ਲਈ ਕੋਈ ਸਰੋਤ ਉਪਲਬਧ ਨਹੀਂ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਸਟੈਪ ਕਮਾਂਡ (F5) ਨੂੰ ਚਲਾਓ।

ਸੰਪੂਰਨ ਹੋਣ ਦੇ ਬਜਾਏ

ਮੂਲ ਕੋਡ ਦੀ ਨਕਲ ਕਰਨਾ ਬਹੁਤ ਦਿਲਚਸਪ ਗੱਲ ਹੈ। ਇੱਕ ਡਿਵਾਈਸ ਡਿਵੈਲਪਰ ਲਈ ਇੱਕ ਅਸਲੀ ਡਿਵਾਈਸ ਤੋਂ ਬਿਨਾਂ ਫਰਮਵੇਅਰ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਸੰਭਵ ਹੋ ਜਾਂਦਾ ਹੈ। ਇੱਕ ਖੋਜਕਰਤਾ ਲਈ, ਇਹ ਗਤੀਸ਼ੀਲ ਕੋਡ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨ ਦਾ ਇੱਕ ਮੌਕਾ ਹੈ, ਜੋ ਕਿ ਇੱਕ ਡਿਵਾਈਸ ਦੇ ਨਾਲ ਵੀ ਸੰਭਵ ਨਹੀਂ ਹੁੰਦਾ.

ਅਸੀਂ ਮਾਹਿਰਾਂ ਨੂੰ ਇੱਕ ਅਜਿਹਾ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ ਜੋ ਸੁਵਿਧਾਜਨਕ, ਔਸਤਨ ਸਧਾਰਨ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਥਾਪਤ ਕਰਨ ਅਤੇ ਚਲਾਉਣ ਲਈ ਬਹੁਤ ਜ਼ਿਆਦਾ ਮਿਹਨਤ ਅਤੇ ਸਮਾਂ ਨਹੀਂ ਲੱਗਦਾ ਹੈ।

ਹਾਰਡਵੇਅਰ ਇਮੂਲੇਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਆਪਣੇ ਅਨੁਭਵ ਬਾਰੇ ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ। ਅਸੀਂ ਤੁਹਾਨੂੰ ਚਰਚਾ ਕਰਨ ਲਈ ਸੱਦਾ ਦਿੰਦੇ ਹਾਂ ਅਤੇ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਦੇ ਕੇ ਖੁਸ਼ ਹੋਵਾਂਗੇ।

ਸਿਰਫ਼ ਰਜਿਸਟਰਡ ਉਪਭੋਗਤਾ ਹੀ ਸਰਵੇਖਣ ਵਿੱਚ ਹਿੱਸਾ ਲੈ ਸਕਦੇ ਹਨ। ਸਾਈਨ - ਇਨ, ਤੁਹਾਡਾ ਸੁਆਗਤ ਹੈ.

ਤੁਸੀਂ ਇਮੂਲੇਟਰ ਕਿਸ ਲਈ ਵਰਤ ਰਹੇ ਹੋ?

• ਮੈਂ (ਡੀਬੱਗ) ਫਰਮਵੇਅਰ ਵਿਕਸਿਤ ਕਰਦਾ ਹਾਂ

• ਮੈਂ ਫਰਮਵੇਅਰ ਦੀ ਖੋਜ ਕਰ ਰਿਹਾ/ਰਹੀ ਹਾਂ

• ਮੈਂ ਗੇਮਾਂ ਲਾਂਚ ਕਰਦਾ ਹਾਂ (ਡੈਂਡੀ, ਸੇਗਾ, ਪੀਐਸਪੀ)

• ਕੁਝ ਹੋਰ (ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ)

7 ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਵੋਟ ਪਾਈ। 2 ਉਪਭੋਗਤਾ ਪਰਹੇਜ਼ ਰਹੇ।

ਮੂਲ ਕੋਡ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਤੁਸੀਂ ਕਿਹੜੇ ਸੌਫਟਵੇਅਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ?

• QEMU

• ਯੂਨੀਕੋਰਨ ਇੰਜਣ

• ਪ੍ਰੋਟੇਸ

• ਕੁਝ ਹੋਰ (ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ)

6 ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਵੋਟ ਪਾਈ। 2 ਉਪਭੋਗਤਾ ਪਰਹੇਜ਼ ਰਹੇ।

ਤੁਸੀਂ ਜਿਸ ਈਮੂਲੇਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹੋ, ਉਸ ਵਿੱਚ ਤੁਸੀਂ ਕੀ ਸੁਧਾਰ ਕਰਨਾ ਚਾਹੋਗੇ?

• ਮੈਨੂੰ ਗਤੀ ਚਾਹੀਦੀ ਹੈ

• ਮੈਂ ਸੈੱਟਅੱਪ/ਲਾਂਚ ਦੀ ਸੌਖ ਚਾਹੁੰਦਾ ਹਾਂ

• ਮੈਨੂੰ ਇਮੂਲੇਟਰ (API, ਹੁੱਕ) ਨਾਲ ਇੰਟਰੈਕਟ ਕਰਨ ਲਈ ਹੋਰ ਵਿਕਲਪ ਚਾਹੀਦੇ ਹਨ

• ਮੈਂ ਹਰ ਚੀਜ਼ ਤੋਂ ਖੁਸ਼ ਹਾਂ

• ਕੁਝ ਹੋਰ (ਟਿੱਪਣੀਆਂ ਵਿੱਚ ਲਿਖੋ)

8 ਉਪਭੋਗਤਾਵਾਂ ਨੇ ਵੋਟ ਪਾਈ। 1 ਵਰਤੋਂਕਾਰ ਬਚਿਆ।

ਸਰੋਤ: www.habr.com