mso4000 0.1.0__py3-none-any.whl

mso4000-0.1.0.dist-info/METADATA

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: mso4000
+Version: 0.1.0
+Summary: Simple library for Tektronix MSO4000 series oscilloscopes
+Author-email: Asaf Ayalon <ayalon.asaf.c0@s.mail.nagoya-u.ac.jp>
+License-Expression: MIT
+Keywords: oscilloscope,tektronix,mso4000,visa,measurement
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyvisa>=1.11.0
+Requires-Dist: numpy>=1.16.0
+Provides-Extra: dev
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# MSO4000 Library
+
+Simple, clean library for Tektronix MSO4000 series oscilloscopes.
+
+## Features
+
+- ✅ Connection checking
+- ✅ Single waveform capture
+- ✅ Multiple waveform recording to CSV
+- ✅ Simple, clean API
+
+## Installation
+
+Install from PyPI:
+
+```bash
+pip install mso4000
+```
+
+## Quick Start
+
+### 1. Check Connection
+
+```python
+from mso4000 import check_connection
+
+success, info = check_connection()
+if success:
+    print(f"Connected: {info}")
+else:
+    print(f"Error: {info}")
+```
+
+### 2. Record Waveforms to CSV (One-liner)
+
+```python
+from mso4000 import quick_record
+
+# Record 10 waveforms and save to CSV
+filename = quick_record(channel=1, max_records=10)
+print(f"Saved to: {filename}")
+```
+
+### 3. Full Control
+
+```python
+from mso4000 import MSO4000
+
+# Create scope interface
+scope = MSO4000(channel=1)
+
+# Connect
+if scope.connect():
+    # Capture single waveform
+    waveform = scope.capture_waveform()
+    print(f"Captured {len(waveform)} samples")
+    
+    # Or record multiple to CSV
+    filename = scope.record_to_csv(max_records=20)
+    print(f"Saved to: {filename}")
+    
+    # Close connection
+    scope.close()
+```
+
+## API Reference
+
+### `MSO4000` Class
+
+#### `__init__(channel=1)`
+Initialize the oscilloscope interface.
+
+**Parameters:**
+- `channel` (int): Channel number (1-4), default 1
+
+#### `check_connection() -> Tuple[bool, Optional[str]]`
+Check if oscilloscope is connected.
+
+**Returns:**
+- `(True, device_info)` if connected
+- `(False, error_message)` if not connected
+
+#### `connect() -> bool`
+Connect to oscilloscope and configure for waveform transfer.
+
+**Returns:**
+- `True` if successful
+- `False` if failed
+
+#### `capture_waveform() -> Optional[np.ndarray]`
+Capture a single waveform.
+
+**Returns:**
+- `numpy.ndarray` of voltage values, or `None` if failed
+
+#### `record_to_csv(filename=None, max_records=None, delay=0.5) -> Optional[str]`
+Record multiple waveforms and save to CSV.
+
+**Parameters:**
+- `filename` (str, optional): Output filename (auto-generated if None)
+- `max_records` (int, optional): Maximum waveforms to record (None = until Ctrl+C)
+- `delay` (float): Delay between captures in seconds (default 0.5)
+
+**Returns:**
+- Filename of saved CSV, or `None` if failed
+
+#### `close()`
+Close connection to oscilloscope.
+
+### Convenience Functions
+
+#### `check_connection() -> Tuple[bool, Optional[str]]`
+Quick function to check connection.
+
+#### `quick_record(channel=1, max_records=None, filename=None) -> Optional[str]`
+Quick function to connect and record waveforms.
+
+**Parameters:**
+- `channel` (int): Channel number (1-4)
+- `max_records` (int, optional): Maximum waveforms (None = until Ctrl+C)
+- `filename` (str, optional): Output filename (auto-generated if None)
+
+**Returns:**
+- Filename of saved CSV, or `None` if failed
+
+## CSV Output Format
+
+The CSV file contains:
+- **Column 1:** Sample index (0 to N-1)
+- **Column 2:** Time in seconds (relative to waveform start)
+- **Columns 3+:** Voltage values for each recorded waveform
+
+Example:
+```csv
+Sample_Index,Time_sec,Waveform_1_V,Waveform_2_V,Waveform_3_V
+0,0.000000,-0.123456,0.234567,-0.345678
+1,0.000010,-0.125432,0.236789,-0.347890
+...
+```
+
+## Examples
+
+See `example_mso4000.py` for complete examples.
+
+## Requirements
+
+- Python 3.6+
+- pyvisa
+- numpy
+
+## Notes
+
+- The library automatically selects USB resources (skips serial ports)
+- Uses binary encoding (RIBINARY) for efficient data transfer
+- Default timeout is 30 seconds for waveform transfers
+- Press Ctrl+C to stop recording
+
+## License
+
+MIT License - See LICENSE file for details
+

mso4000-0.1.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+mso4000.py,sha256=z6MNxykotPq9fFsd681l3uCDudVYjOqSyM_uB33YwJI,10448
+mso4000-0.1.0.dist-info/licenses/LICENSE,sha256=8_up1FX6vk2DRcusQEZ4pWJGkgkjvEkD14xB1hdLe3c,1067
+mso4000-0.1.0.dist-info/METADATA,sha256=w3CXDeUypQwCPFNejVe6qqzICsumThfDQmxcROcNcDU,4666
+mso4000-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mso4000-0.1.0.dist-info/top_level.txt,sha256=fl0KrUGzNDpxXFv9VzGSrI5WswtF3DqQeLMdHQ3slN0,8
+mso4000-0.1.0.dist-info/RECORD,,

mso4000-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mso4000-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

mso4000-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mso4000

mso4000.py

@@ -0,0 +1,313 @@
+"""
+Simple library for Tektronix MSO4000 series oscilloscopes
+Provides connection checking and waveform recording to CSV
+"""
+import pyvisa
+import numpy as np
+import time
+import csv
+from datetime import datetime
+from typing import Optional, Tuple, List
+
+
+class MSO4000:
+    """Simple interface for Tektronix MSO4000 series oscilloscopes"""
+    
+    def __init__(self, channel: int = 1):
+        """
+        Initialize MSO4000 interface
+        
+        Args:
+            channel: Channel number (1-4)
+        """
+        self.channel = channel
+        self.scope = None
+        self.rm = None
+        self.timebase = None
+        self.ch_scale = None
+    
+    def check_connection(self) -> Tuple[bool, Optional[str]]:
+        """
+        Check if oscilloscope is connected and accessible
+        
+        Returns:
+            Tuple of (success: bool, device_info: str or None)
+        """
+        try:
+            self.rm = pyvisa.ResourceManager()
+            resources = self.rm.list_resources()
+            
+            # Prefer USB resources
+            usb_resources = [r for r in resources if r.startswith('USB')]
+            if not usb_resources:
+                return False, "No USB oscilloscope found"
+            
+            resource_name = usb_resources[0]
+            self.scope = self.rm.open_resource(resource_name)
+            self.scope.timeout = 5000
+            
+            # Query identification
+            idn = self.scope.query("*IDN?")
+            device_info = idn.strip()
+            
+            return True, device_info
+            
+        except Exception as e:
+            return False, f"Connection error: {e}"
+    
+    def connect(self) -> bool:
+        """
+        Connect to oscilloscope and configure for waveform transfer
+        
+        Returns:
+            True if successful, False otherwise
+        """
+        success, info = self.check_connection()
+        if not success:
+            print(f"❌ {info}")
+            return False
+        
+        try:
+            print(f"✓ Connected to: {info}")
+            
+            # Configure for waveform transfer
+            self.scope.write("*CLS")
+            self.scope.write(f":DATA:SOURCE CH{self.channel}")
+            self.scope.write(":DATA:ENCDG RIBINARY")
+            self.scope.write(":WFMOUTPRE:BYT_NR 2")
+            self.scope.write(":DATA INIT")
+            
+            # Get scale info
+            self.timebase = float(self.scope.query(":HORIZONTAL:SCALE?"))
+            self.ch_scale = float(self.scope.query(f":CH{self.channel}:SCALE?"))
+            
+            print(f"✓ Configured: Timebase={self.timebase} s/div, CH{self.channel}={self.ch_scale} V/div")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Configuration error: {e}")
+            return False
+    
+    def capture_waveform(self) -> Optional[np.ndarray]:
+        """
+        Capture a single waveform from the oscilloscope
+        
+        Returns:
+            Voltage array (numpy array) or None if failed
+        """
+        if not self.scope:
+            print("❌ Not connected. Call connect() first.")
+            return None
+        
+        try:
+            self.scope.timeout = 30000  # 30 seconds for data transfer
+            
+            # Trigger and get waveform
+            self.scope.write(":TRIGGER:FORCE")
+            time.sleep(0.2)
+            
+            # Get data using write + read_raw for binary data
+            self.scope.write("CURVE?")
+            curve_data_bytes = self.scope.read_raw()
+            
+            # Parse binary data
+            curve_data_str = curve_data_bytes.decode('latin1', errors='ignore')
+            
+            if curve_data_str.startswith('#'):
+                digit_count = int(curve_data_str[1])
+                byte_count = int(curve_data_str[2:2+digit_count])
+                header_len = 2 + digit_count
+                
+                # Extract binary data
+                binary_data = curve_data_bytes[header_len:header_len+byte_count]
+                
+                # Convert to array (16-bit signed integers, big-endian)
+                voltage_array = np.frombuffer(binary_data, dtype='>i2')
+                
+                # Scale to voltage
+                voltage_scaled = (voltage_array / 32768.0) * self.ch_scale * 5.0
+            else:
+                # ASCII fallback
+                values = [float(x) for x in curve_data_str.split(',')]
+                voltage_scaled = np.array(values)
+            
+            return voltage_scaled
+            
+        except Exception as e:
+            print(f"❌ Error capturing waveform: {e}")
+            return None
+    
+    def record_to_csv(self, filename: Optional[str] = None, 
+                      max_records: Optional[int] = None,
+                      delay: float = 0.5) -> Optional[str]:
+        """
+        Record multiple waveforms and save to CSV
+        
+        Args:
+            filename: Output CSV filename (auto-generated if None)
+            max_records: Maximum number of waveforms to record (None = until interrupted)
+            delay: Delay between captures in seconds
+            
+        Returns:
+            Filename of saved CSV or None if failed
+        """
+        if not self.scope:
+            print("❌ Not connected. Call connect() first.")
+            return None
+        
+        if filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"waveform_data_{timestamp}.csv"
+        
+        all_data = []
+        timestamps = []
+        record_count = 0
+        
+        print(f"\n📝 Recording waveforms... (Press Ctrl+C to stop)")
+        print(f"   Output: {filename}\n")
+        
+        try:
+            while True:
+                if max_records and record_count >= max_records:
+                    print(f"\n✓ Record limit reached ({max_records} records)")
+                    break
+                
+                print(f"[{record_count+1}] Capturing... ", end="", flush=True)
+                
+                voltage_data = self.capture_waveform()
+                
+                if voltage_data is not None:
+                    all_data.append(voltage_data)
+                    timestamps.append(time.time())
+                    record_count += 1
+                    
+                    min_v = voltage_data.min()
+                    max_v = voltage_data.max()
+                    mean_v = voltage_data.mean()
+                    print(f"✓ {len(voltage_data):6d} samples | "
+                          f"Min: {min_v:8.4f}V | Max: {max_v:8.4f}V | Mean: {mean_v:8.4f}V")
+                    
+                    time.sleep(delay)
+                else:
+                    print("✗ FAILED")
+                    time.sleep(1)
+        
+        except KeyboardInterrupt:
+            print("\n⏹ Recording interrupted by user")
+        
+        if not all_data:
+            print("❌ No data to export!")
+            return None
+        
+        # Export to CSV
+        print(f"\n💾 Exporting to {filename}...")
+        
+        try:
+            with open(filename, 'w', newline='') as csvfile:
+                max_samples = max(len(wf) for wf in all_data)
+                
+                # Create header
+                headers = ['Sample_Index', 'Time_sec'] + \
+                         [f'Waveform_{i+1}_V' for i in range(record_count)]
+                
+                writer = csv.writer(csvfile)
+                writer.writerow(headers)
+                
+                # Calculate time per point
+                num_points = len(all_data[0]) if all_data else 1
+                time_per_point = (self.timebase * 10.0) / num_points
+                
+                # Write data
+                for sample_idx in range(max_samples):
+                    row = [sample_idx, sample_idx * time_per_point]
+                    
+                    for waveform in all_data:
+                        if sample_idx < len(waveform):
+                            row.append(waveform[sample_idx])
+                        else:
+                            row.append('')
+                    
+                    writer.writerow(row)
+            
+            print(f"✓ Exported {record_count} waveforms, {max_samples} samples each")
+            
+            import os
+            file_size = os.path.getsize(filename)
+            print(f"✓ File size: {file_size / 1024 / 1024:.2f} MB")
+            
+            return filename
+            
+        except Exception as e:
+            print(f"❌ Error exporting: {e}")
+            return None
+    
+    def close(self):
+        """Close connection to oscilloscope"""
+        if self.scope:
+            self.scope.close()
+            self.scope = None
+            print("✓ Connection closed")
+
+
+# Convenience functions
+def check_connection() -> Tuple[bool, Optional[str]]:
+    """
+    Quick function to check if oscilloscope is connected
+    
+    Returns:
+        Tuple of (success: bool, device_info: str or None)
+    """
+    scope = MSO4000()
+    return scope.check_connection()
+
+
+def quick_record(channel: int = 1, max_records: Optional[int] = None,
+                filename: Optional[str] = None) -> Optional[str]:
+    """
+    Quick function to connect and record waveforms
+    
+    Args:
+        channel: Channel number (1-4)
+        max_records: Maximum number of waveforms (None = until interrupted)
+        filename: Output CSV filename (auto-generated if None)
+        
+    Returns:
+        Filename of saved CSV or None if failed
+    """
+    scope = MSO4000(channel=channel)
+    
+    if not scope.connect():
+        return None
+    
+    try:
+        filename = scope.record_to_csv(filename=filename, max_records=max_records)
+        return filename
+    finally:
+        scope.close()
+
+
+if __name__ == "__main__":
+    # Example usage
+    print("=" * 70)
+    print("MSO4000 Library - Example Usage")
+    print("=" * 70 + "\n")
+    
+    # Check connection
+    print("[1] Checking connection...")
+    success, info = check_connection()
+    if success:
+        print(f"✓ {info}\n")
+    else:
+        print(f"❌ {info}\n")
+        exit(1)
+    
+    # Record waveforms
+    print("[2] Recording waveforms...")
+    scope = MSO4000(channel=1)
+    
+    if scope.connect():
+        filename = scope.record_to_csv(max_records=5)  # Record 5 waveforms
+        if filename:
+            print(f"\n✓ Success! Data saved to: {filename}")
+        scope.close()
+