A DC motor with a plastic gearbox (called a 'TT' motor) is an easy, low-cost way to get your projects moving. The TT DC Gearbox Motor with a gear ratio of 1:48 is Perfect for plugging into a breadboard or terminal blocks.

Package Includes:

• 1 x Motor DC Single Shaft TT DC Gear Motor 1:48 

Features:

• The gear ratio of 1:48
• Low cost and easy to use
• Suitable for small robotics projects and other DIY electronics projects

Description:

TT motors, also known as plastic gearbox motors, are small electric motors often used in small robotics projects and other DIY electronics projects. They are low-cost and easy to use, making them a popular choice for beginners and hobbyists. The gear ratio of a TT motor refers to the relationship between the motor's output shaft's speed and the input power's speed. In this case, the gear ratio of 1:48 means that the output shaft of the motor will rotate at 1/48th of the speed of the input power. The breadboard-friendly connectors on the motor allow it to be easily connected to a breadboard or terminal blocks, making it easy to incorporate into a circuit.

Principle of Work:

The working principle of a TT motor with a gear ratio of 1:48 is similar to that of any other electric motor. When an electric current is applied to the motor's windings, it creates a magnetic field. This magnetic field interacts with the magnetic field of a permanent magnet in the motor, causing the rotor (the part of the motor that rotates) to turn.

The gears in a TT motor are used to change the speed and torque of the output shaft. The gear ratio refers to the relationship between the number of teeth on the input gear (the gear that is driven by the motor) and the number of teeth on the output gear (the gear that drives the load). In this case, the gear ratio of 1:48 means that for every 48 revolutions of the input gear, the output gear will make one revolution.

The gear ratio determines the speed and torque of the output shaft. A higher gear ratio will result in a slower but more powerful output, while a lower gear ratio will result in faster but less powerful output. The specific gear ratio of a TT motor is chosen based on the desired speed and torque for the application it is being used in.

 

Pinout of the Motor:

 

TT motors with a gear ratio of 1:48 can be connected to a circuit in a variety of ways, depending on the specific requirements of the application. The most common way to connect these motors is to use a simple DC power source, such as a battery or a DC power supply, and control the direction of the motor by reversing the polarity of the power applied to it.

To reverse the direction of a TT motor with a gear ratio of 1:48, you can simply switch the connections of the positive and negative wires. For example, if the positive wire is currently connected to the positive terminal of the power source and the negative wire is connected to the negative terminal, switching these connections will reverse the direction of the motor.

Alternatively, you can use a microcontroller or other control device to control the direction of the motor by switching the polarity of the power applied to it using digital outputs. This allows for more precise control over the direction and speed of the motor.

 

Applications: 

• Driving small robotic vehicles or platforms
• Controlling the movement of robotic arms or other manipulators
• Actuating small mechanisms or devices, such as doors or levers
• Providing power for small fans or pumps

Circuit:

Library:

no need for the library to control the Motor

Code: 

Use a transistor to control the speed of a motor.
We'll also teach you how to use the serial port to input data (see the serialSpeed() function below). Motors are at the heart of thousands of everyday objects, and Arduino can control them. In this example, we'll utilize pulse-width modulation (PWM) to control the speed of a motor.

The Arduino pins are powerful enough to power small LEDs (up to 40 milliAmps), but not motors or other power-hungry components. (This motor requires 50-100mA).
We'll use a transistor to perform the heavy work because the motor requires more current than an Arduino pin can deliver.
A solid-state switch is a transistor. When we apply a modest quantity of current to it,

it can switch a much larger current.

The transistors in your kit (2N2222) can switch up to 200mA.

You can turn a transistor on and off using the digitalWrite()
function, but you can also use the analogWrite() function to
vary the speed of the motor. The analogWrite() function pulses
a pin, varying the width of the pulse from 0% to 100%. We call
this technique "PWM", for "Pulse-Width Modulation".

One thing to keep in mind is that when you lower the speed of
a motor using PWM, you're also reducing the torque (strength)
of the motor. For PWM values below 50 or so, the motor won't have
enough torque to start spinning. It will start spinning when you
raise the speed a bit.

Hardware connections:

Transistor:

The transistor has three pins. Looking at the flat side with the
pins down, the order is COLLECTOR, BASE, EMITTER.

Connect the black wire on the motor to the
COLLECTOR pin on the transistor.

Connect the BASE pin through a 330 Ohm resistor to
digital pin 9.

Connect the EMITTER pin to GND.

Motor:

You've already connected the black wire on the motor to the
COLLECTOR pin on the transistor.

Connect the other (red) wire on the motor to 5V.

Flyback diode:

When the motor is spinning and suddenly turned off, the
the magnetic field inside it collapses, generating a voltage spike.
This can damage the transistor. To prevent this, we use a
"flyback diode", which diverts the voltage spike "around" the
transistor.

Connect the side of the diode with the band (cathode) to 5V
Connect the other side of the diode (anode) to the black wire
on the motor.

 

// We'll be controlling the motor from pin 9.
// This must be one of the PWM-capable pins.

const int motorPin = 9;


void setup()
{
  // Set up the motor pin to be an output:

  pinMode(motorPin, OUTPUT);

  // Set up the serial port:

  Serial.begin(9600);
}


void loop()
{
  // Here we've used comments to disable some of the examples.
  // To try different things, uncomment one of the following lines
  // and comment the other ones. See the functions below to learn
  // what they do and how they work.

  // motorOnThenOff();
  // motorOnThenOffWithSpeed();
  // motorAcceleration();
     serialSpeed();
}


// This function turns the motor on and off like the blinking LED.
// Try different values to affect the timing.

void motorOnThenOff()
{
  int onTime = 3000;  // milliseconds to turn the motor on
  int offTime = 3000; // milliseconds to turn the motor off

  digitalWrite(motorPin, HIGH); // turn the motor on (full speed)
  delay(onTime);                // delay for onTime milliseconds
  digitalWrite(motorPin, LOW);  // turn the motor off
  delay(offTime);               // delay for offTime milliseconds
}


// This function alternates between two speeds.
// Try different values to affect the timing and speed.

void motorOnThenOffWithSpeed()
{
  int Speed1 = 200;  // between 0 (stopped) and 255 (full speed)
  int Time1 = 3000;  // milliseconds for speed 1

  int Speed2 = 50;   // between 0 (stopped) and 255 (full speed)
  int Time2 = 3000;  // milliseconds to turn the motor off

  analogWrite(motorPin, Speed1);  // turns the motor On
  delay(Time1);                   // delay for onTime milliseconds
  analogWrite(motorPin, Speed2);  // turns the motor Off
  delay(Time2);                   // delay for offTime milliseconds
}


// This function slowly accelerates the motor to full speed,
// then back down to zero.

void motorAcceleration()
{
  int speed;
  int delayTime = 20; // milliseconds between each speed step

  // accelerate the motor

  for(speed = 0; speed <= 255; speed++)
  {
    analogWrite(motorPin,speed);    // set the new speed
    delay(delayTime);               // delay between speed steps
  }

  // decelerate the motor

  for(speed = 255; speed >= 0; speed--)
  {
    analogWrite(motorPin,speed);    // set the new speed
    delay(delayTime);               // delay between speed steps
  }
}


// This function will let you type a speed into the serial
// monitor window. Open the serial monitor using the magnifying-
// glass icon at the top right of the Arduino window. Then
// type your desired speed into the small text entry bar at the
// top of the window and click "Send" or press return. The motor
// will then operate at that speed. The valid range is 0 to 255.

void serialSpeed()
{
  int speed;

  Serial.println("Type a speed (0-255) into the box above,");
  Serial.println("then click [send] or press [return]");
  Serial.println();  // Print a blank line

  // In order to type out the above message only once,
  // we'll run the rest of this function in an infinite loop:

  while(true)  // "true" is always true, so this will loop forever.
  {
    // First we check to see if incoming data is available:

    while (Serial.available() > 0)
    {
      // If it is, we'll use parseInt() to pull out any numbers:

      speed = Serial.parseInt();

      // Because analogWrite() only works with numbers from
      // 0 to 255, we'll be sure the input is in that range:

      speed = constrain(speed, 0, 255);

      // We'll print out a message to let you know that the
      // number was received:

      Serial.print("Setting speed to ");
      Serial.println(speed);

      // And finally, we'll set the speed of the motor!

      analogWrite(motorPin, speed);
    }
  }
}

     

Technical Details:

• Working Voltage: DC3-6v
• Speed: 200RPM
• Ratio: 1:48
• Gear Material: Plastic
• Axis Number: Single Axis
• The direction of rotation: Bi-direction
• Gearbox position: All directions
• Storage Humidity Range with the exception of gearbox: 30%~70%
• Operation temperature range: +10℃~+50℃
• Storage temperature Range: -10℃~+40℃
• Gearbox Diagram

Resources:

• Tutorial

Comparisons: