# Motor Rotation Based on Turn Input Value

This program demonstrates a simple motor control application using Python. The main objective of the script is to rotate a motor by a specific number of turns, which is determined by the user input. The motor's position is tracked, and it continues to rotate until the desired number of turns is achieved.

## **Key Components:**

1. **USB Connection and Serial Communication**:
   1. The program first detects the available USB serial port by checking the connected devices. This is done using the `serial` module and the `comports()` method. The program checks for the USB Serial Port on Windows, `/dev/ttyUSB` on Linux, and `/dev/tty.usbserial` or `/dev/tty.usbmodem` on macOS, depending on the operating system.
2. **Motor Control with SMD Red**:
   1. The motor control is handled by the `smd.red` library, which provides an interface to communicate with the motor using the Red controller. The `Master` and `Red` objects are used to establish communication with the motor and send commands to it.
3. **Motor Rotation Logic**:
   1. The motor rotation is based on the encoder counts per revolution (CPR). The variable `steps_per_turn` represents the CPR, which is typically a value like `6533` for many motors.
   2. The function `rotate_motor(turns)` takes the number of turns as input, calculates the corresponding target position (in encoder steps), and then continuously rotates the motor until the target position is reached.
   3. The `m.set_velocity()` function is used to set the speed of the motor, and the motor stops once the desired position is achieved.
4. **User Input**:
   1. The program prompts the user to input the number of turns they wish the motor to rotate. The `rotate_motor()` function then handles the rotation based on this input.
5. **Threading and Time Control**:
   1. The program uses a simple `while` loop with `time.sleep(0.01)` to periodically check the motor’s position. This ensures the motor rotates in a controlled manner, and the loop continues until the target position is reached.

## Example Usage:

When the program is executed, it will ask the user to input the number of turns:

```
Enter the number of turns: 5
```

After the user inputs the value (e.g., 5), the motor will rotate the equivalent number of turns. The program will print a message once the motor has completed the rotation:

```
It has been rotated as many times as the number of turns entered. Number of turns: 5
```

## Code

```python
import serial
from smd.red import Master, Red
from threading import Thread
import time
from serial.tools.list_ports import comports
from platform import system

def USB_Port():
	ports = list(comports())
	usb_names = {
		"Windows": ["USB Serial Port"],
		"Linux": ["/dev/ttyUSB"],
		"Darwin": [
			"/dev/tty.usbserial",
			"/dev/tty.usbmodem",
			"/dev/tty.SLAB_USBtoUART",
			"/dev/tty.wchusbserial",
			"/dev/cu.usbserial",
            		"/dev/cu.usbmodem",
			"/dev/cu.SLAB_USBtoUART",
			"/dev/cu.wchusbserial",
		]
	}
	
	os_name = system()
	if ports:
		for port, desc, hwid in sorted(ports):
			if any(name in port or name in desc for name in usb_names.get(os_name, [])):
				return port
		print("Current ports:")
		for port, desc, hwid in ports:
			print(f"Port: {port}, Description: {desc}, Hardware ID: {hwid}")
	else:
		print("No port found")
	return None
	
port = USB_Port()
m = Master(port)
motor = m.attach(Red(0))

def rotate_motor(turns):
    steps_per_turn = 6533  # Set according to the encoder CPR value
    target_position = turns * steps_per_turn  # Calculate the target position
    current_position = m.get_position(0)  # get motor position

    # Rotate the motor until the target position is reached.
    m.set_velocity(id=0, sp=10000)  # Set to maximum speed
    while abs(m.get_position(0) - current_position) < target_position:
        time.sleep(0.01)  # Wait for a short time
    
    m.set_velocity(id=0, sp=0)  # Stop the motor
    
turns = input("Enter the number of turns: ")
rotate_motor(int(turns))
print("It has been rotated as many times as the number of turns entered. Number of turns:"+turns)
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.acrome.net/smd-kits/starter-kit/what-you-can-build/motor-rotation-based-on-turn-input-value.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.