Add ci

.github/workflows/jlinkRemoteServerEmu.dockerfile

@@ -0,0 +1,57 @@
+##
+# Usage example:
+# Build:
+#   docker build -t my-jlink-image -f jlinkRemoteServerEmu.dockerfile .
+# Run (with USB access and custom network):
+#   docker network create --subnet=192.168.100.0/24 jlink-net
+#   docker run -d --rm --name jlink1 --network jlink-net --ip 192.168.100.10 \
+#     --device=/dev/bus/usb:/dev/bus/usb \
+#     my-jlink-image \
+#     -select usb=SERIAL1 -device STM32F103RE -endian little -speed 4000 -if swd
+# Replace SERIAL1 with your J-Link serial number.
+#
+FROM ubuntu:22.04
+
+## Install required packages and JLink dependencies
+RUN apt-get update && \
+    apt-get install -y wget libusb-1.0-0 udev && \
+    rm -rf /var/lib/apt/lists/*
+
+
+# Copy both JLink packages into the container (they must be present in build context)
+# COPY .github/workflows/JLink_Linux_${JLINK_VERSION}_x86_64.deb /tmp/JLink_Linux_${JLINK_VERSION}_x86_64.deb
+# COPY .github/workflows/JLink_Linux_${JLINK_VERSION}_arm64.deb /tmp/JLink_Linux_${JLINK_VERSION}_arm64.deb
+
+# Workaround: replace udevadm with a stub to avoid postinst errors in Docker
+RUN if [ -f /bin/udevadm ]; then mv /bin/udevadm /bin/udevadm.real; fi && \
+    echo '#!/bin/bash' > /bin/udevadm && \
+    echo 'exit 0' >> /bin/udevadm && \
+    chmod +x /bin/udevadm
+
+# Install the appropriate JLink package depending on architecture (force install, then fix deps)
+WORKDIR /tmp
+RUN ARCH=$(uname -m) && \
+    if [ "$ARCH" = "x86_64" ]; then \
+        wget --post-data "accept_license_agreement=accepted" \
+        https://www.segger.com/downloads/jlink/JLink_Linux_V794e_x86_64.deb \
+        -O JLink.deb && \
+        dpkg --force-depends -i JLink.deb && \
+        rm JLink.deb; \
+    elif [ "$ARCH" = "aarch64" ] || [ "$ARCH" = "arm64" ]; then \
+        wget --post-data "accept_license_agreement=accepted" \
+        https://www.segger.com/downloads/jlink/JLink_Linux_V794e_arm64.deb \
+        -O JLink.deb && \
+        dpkg --force-depends -i JLink.deb && \
+        rm JLink.deb; \
+    fi
+
+# Restore real udevadm after J-Link installation
+RUN if [ -f /bin/udevadm.real ]; then rm /bin/udevadm && mv /bin/udevadm.real /bin/udevadm; fi
+
+# Add user (optional)
+RUN useradd -ms /bin/bash jlink
+USER jlink
+
+WORKDIR /home/jlink
+
+ENTRYPOINT ["/opt/SEGGER/JLink/JLinkRemoteServer"]

.github/workflows/test.yml

@@ -0,0 +1,174 @@
+name: Test Builds
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+env:
+  VNET_BASE: 192.168.3
+  VNET_MASK: 24
+jobs:
+  test-build:
+    runs-on: self-hosted
+
+    steps:
+      - name: Cleanup before start
+        if: always()
+        run: |
+          pkill -9 -f JLinkRemoteServer || true
+          docker rm -f jlink100 jlink101 jlink102 2>/dev/null || true
+          docker network rm jlink-net 2>/dev/null || true
+          sleep 2
+
+      - uses: actions/checkout@v4
+
+      - name: Build release distributions
+        run: |
+          python3 -m venv .venv
+          . .venv/bin/activate
+          pip install -e ".[dev]"
+
+      - name: Test 1 — bmlab-scan (no arguments)
+        run: |
+          . .venv/bin/activate
+          bmlab-scan | tee scan1.txt
+          count=$(grep -c "Target:  *STM32F103RE" scan1.txt)
+          awk '/JLink Programmer/ {serial=""} /Serial:/ {serial=$2} /Target: *STM32F103RE/ && serial {print serial}' scan1.txt | sort | uniq > serials.txt
+
+          if [ "$count" -ne 3 ]; then
+            echo "Test 1 failed: expected 3 STM32F103RE, found $count"
+            cat scan1.txt
+            exit 1
+          fi
+
+      - name: Test 2 — bmlab-scan -p jlink
+        run: |
+          . .venv/bin/activate
+          bmlab-scan -p jlink | tee scan2.txt
+          diff scan1.txt scan2.txt
+
+      - name: Test 3 — Start JLinkRemoteServer and scan via network
+        run: |
+          . .venv/bin/activate
+          serial=$(head -n1 serials.txt)
+          nohup JLinkRemoteServer -select usb=$serial -device STM32F103RE -endian little -speed 4000 -if swd > /dev/null 2>&1 &
+          sleep 3
+          bmlab-scan --network 127.0.0.1/32 | tee scan3.txt
+          grep -q "Target:  *STM32F103RE" scan3.txt
+          grep -q "IP: *127.0.0.1" scan3.txt
+          pkill -9 -f JLinkRemoteServer || true
+          sleep 1
+
+      - name: Test 4 — bmlab-scan --network 127.0.0.1/32 -p jlink
+        run: |
+          . .venv/bin/activate
+          serial=$(head -n1 serials.txt)
+          nohup JLinkRemoteServer -select usb=$serial -device STM32F103RE -endian little -speed 4000 -if swd > /dev/null 2>&1 &
+          sleep 3
+          bmlab-scan --network 127.0.0.1/32 -p jlink | tee scan4.txt
+          diff scan3.txt scan4.txt
+          pkill -9 -f JLinkRemoteServer || true
+          sleep 1
+
+      - name: Test 5 — bmlab-scan --network 127.0.0.2/32 (negative)
+        run: |
+          . .venv/bin/activate
+          ! bmlab-scan --network 127.0.0.2/32 | tee scan5.txt | grep -q "STM32F103RE"
+          grep -qi "No JLink Remote Servers found on the network." scan5.txt
+
+      - name: Build JLinkRemoteServer Docker image
+        run: |
+          docker build -t my-jlink-image -f .github/workflows/jlinkRemoteServerEmu.dockerfile .
+
+      - name: Cleanup jlink-net Docker network
+        run: |
+          docker rm -f jlink100 jlink101 jlink102 2>/dev/null || true
+          docker network rm jlink-net 2>/dev/null || true
+
+      - name: Setup JLinkRemoteServer Docker containers
+        run: |
+          docker network rm jlink-net 2>/dev/null || true
+          docker network create --driver bridge --subnet=$VNET_BASE.0/$VNET_MASK --gateway=$VNET_BASE.1 jlink-net
+
+          serial1=$(sed -n '1p' serials.txt)
+          serial2=$(sed -n '2p' serials.txt)
+          serial3=$(sed -n '3p' serials.txt)
+
+          docker run -d --rm \
+            --device=/dev/bus/usb:/dev/bus/usb \
+            --name jlink100 \
+            --network jlink-net \
+            --ip $VNET_BASE.100 \
+            my-jlink-image \
+            -select usb=$serial1 -device STM32F103RE -endian little -speed 4000 -if swd
+          sleep 3
+
+          docker run -d --rm \
+            --device=/dev/bus/usb:/dev/bus/usb \
+            --name jlink101 \
+            --network jlink-net \
+            --ip $VNET_BASE.101 \
+            my-jlink-image \
+            -select usb=$serial2 -device STM32F103RE -endian little -speed 4000 -if swd
+          sleep 3
+
+          docker run -d --rm \
+            --device=/dev/bus/usb:/dev/bus/usb \
+            --name jlink102 \
+            --network jlink-net \
+            --ip $VNET_BASE.102 \
+            my-jlink-image \
+            -select usb=$serial3 -device STM32F103RE -endian little -speed 4000 -if swd
+          sleep 3
+
+      - name: Test 6 — Multiple RemoteServers network scan
+        run: |
+          . .venv/bin/activate
+          bmlab-scan --network $VNET_BASE.0/$VNET_MASK | tee scan6.txt
+
+          f103_count=$(grep -c "Target:.*STM32F103RE" scan6.txt || echo 0)
+
+          if [ "$f103_count" -ne 3 ]; then
+            echo "Expected 3 STM32F103RE devices, found $f103_count"
+            cat scan6.txt
+            exit 1
+          fi
+
+          for ip in 100 101 102; do
+            if ! grep -q "IP:.*$VNET_BASE\.$ip" scan6.txt; then
+              echo "No device found at $VNET_BASE.$ip"
+              cat scan6.txt
+              exit 1
+            fi
+          done
+
+      - name: Test 7 — Network scan with IP range filter
+        run: |
+          . .venv/bin/activate
+          bmlab-scan --network $VNET_BASE.0/$VNET_MASK --start-ip 100 --end-ip 150 | tee scan7.txt
+
+          f103_count=$(grep -c "Target:.*STM32F103RE" scan7.txt || echo 0)
+
+          if [ "$f103_count" -ne 3 ]; then
+            echo "Expected 3 STM32F103RE devices, found $f103_count"
+            cat scan7.txt
+            exit 1
+          fi
+
+          for ip in 100 101 102; do
+            if ! grep -q "IP:.*$VNET_BASE\.$ip" scan7.txt; then
+              echo "No device found at $VNET_BASE.$ip"
+              cat scan7.txt
+              exit 1
+            fi
+          done
+
+      - name: Cleanup after Docker tests
+        if: always()
+        run: |
+          docker rm -f jlink100 jlink101 jlink102 || true
+          docker network rm jlink-net || true
+          pkill -9 -f JLinkRemoteServer || true
+          sleep 2

CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.1.7] - 2026-01-06
+
+### Fixed
+- **Network scanning now correctly detects target MCU for all devices**:
+  - Added thread lock (`threading.Lock`) to serialize JLink connections during parallel scanning
+  - Prevents state conflicts in pylink library when multiple threads connect simultaneously
+  - Previously parallel scans could incorrectly detect STM32F765ZG instead of actual STM32F103RE
+  - Added 500ms delay after disconnect to ensure device is fully released
+- **CI workflow improvements**:
+  - Removed excessive debug output from test steps
+  - Simplified Docker container setup and cleanup
+  - Fixed validation logic: removed redundant device counting, only validate target MCU and IPs
+  - Added network cleanup before creation to prevent "pool overlaps" errors
+  - Strict validation restored: exactly 3 STM32F103RE devices required at specified IPs
+
+### Changed
+- Network scanning: target detection is now serialized with lock protection
+  - Port checks remain parallel for speed
+  - Target MCU detection runs sequentially to prevent pylink state conflicts
+
 ## [0.1.6] - 2026-01-04
 
 ### Changed

src/bmlab_toolkit/jlink_programmer.py

@@ -12,17 +12,17 @@
 from .programmer import Programmer, DBGMCU_IDCODE_ADDRESSES, DEVICE_ID_MAP, DEFAULT_MCU_MAP
 
 # Configure default logging level for JLinkProgrammer
-logging.basicConfig(level=logging.WARNING, format='%(levelname)s - %(message)s')
+logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(message)s')
 
 # Suppress pylink logger to avoid communication timeout errors during disconnect
 pylink_logger = logging.getLogger('pylink')
-pylink_logger.setLevel(logging.WARNING)
+pylink_logger.setLevel(logging.INFO)
 
 
 class JLinkProgrammer(Programmer):
     """JLink programmer implementation."""
 
-    def __init__(self, serial: Optional[int] = None, ip_addr: Optional[str] = None, log_level: int = logging.WARNING):
+    def __init__(self, serial: Optional[int] = None, ip_addr: Optional[str] = None, log_level: int = logging.DEBUG):
         """
         Initialize JLink programmer.
 
@@ -356,20 +356,23 @@ def scan() -> List[Dict[str, Any]]:
 
                 # Try to detect target MCU
                 try:
-                    temp_jlink = pylink.JLink()
-                    temp_jlink.open(serial_no=emu.SerialNumber)
-                    temp_jlink.set_tif(pylink.enums.JLinkInterfaces.SWD)
+                    print(f"serial found {emu.SerialNumber}")
+                    # temp_jlink = pylink.JLink()
+                    # jlink.open(serial_no=emu.SerialNumber)
+                    # jlink.set_tif(pylink.enums.JLinkInterfaces.SWD)
 
                     # Create temporary programmer instance to use detect_target
-                    temp_programmer = JLinkProgrammer.__new__(JLinkProgrammer)
-                    temp_programmer._jlink = temp_jlink
-                    temp_programmer.logger = logging.getLogger(__name__)
+                    temp_programmer = JLinkProgrammer(serial=emu.SerialNumber)
+                    detected = temp_programmer.connect_target()
+                    # temp_programmer._jlink = jlink
+                    # temp_programmer.logger = logging.getLogger(__name__)
 
-                    detected = temp_programmer.detect_target()
+                    # detected = temp_programmer.detect_target()
                     if detected:
+                        print(f"Detected target for JLink S/N {emu.SerialNumber}: {detected}")
                         device_info['target'] = detected
 
-                    temp_jlink.close()
+                    # jlink.close()
                 except Exception:
                     # If detection fails, just skip it
                     pass

src/bmlab_toolkit/scan_cli.py

@@ -8,12 +8,17 @@
 import argparse
 import logging
 import ipaddress
+import threading
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from .constants import SUPPORTED_PROGRAMMERS, DEFAULT_PROGRAMMER, PROGRAMMER_JLINK
 from .jlink_programmer import JLinkProgrammer
 import socket
 import time
 
+# Global lock to serialize JLink connections (prevents state conflicts)
+_jlink_connection_lock = threading.Lock()
+
+
 def scan_network_ip(ip_str, log_level):
     """Scan a single IP for JLink Remote Server."""
     sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -32,32 +37,40 @@ def scan_network_ip(ip_str, log_level):
         return None
 
     # Try to connect and detect MCU
+    # Use lock to prevent parallel connections from interfering with each other
     prog = None
     try:
-        prog = JLinkProgrammer(ip_addr=ip_str, log_level=log_level)
-        mcu = prog.connect_target()
-        if not mcu:
-            # Connection failed
-            prog._jlink.close()
-            print(f"{ip_str}: No target detected")
-            return None
-
-        # Successfully connected - get device info
-        device_info = {
-            'ip': ip_str,
-            'type': 'jlink-remote',
-            'status': 'Connected',
-            'target': mcu if mcu else 'Unknown'
-        }
-
-        return device_info
+        with _jlink_connection_lock:
+            prog = JLinkProgrammer(ip_addr=ip_str, log_level=log_level)
+            mcu = prog.connect_target()
+            if not mcu:
+                # Connection failed
+                prog._jlink.close()
+                print(f"{ip_str}: No target detected")
+                return None
+
+            # Successfully connected - get device info
+            device_info = {
+                'ip': ip_str,
+                'type': 'jlink-remote',
+                'status': 'Connected',
+                'target': mcu if mcu else 'Unknown'
+            }
+
+            # Disconnect immediately after getting info
+            prog.disconnect_target()
+            # Delay to ensure device is fully released before next scan
+            time.sleep(0.5)
+
+            return device_info
     except Exception as e:
         # Connection or detection failed
         return None
     finally:
         # Always close the connection
         try:
-            prog.disconnect_target()
+            if prog:
+                prog.disconnect_target()
         except:
             pass
 
@@ -198,6 +211,7 @@ def main():
 
             # USB scan mode
             else:
+                print(f"Scanning for USB JLink programmers...\n")
                 devices = JLinkProgrammer.scan()
 
             if not devices: