Video Player

 

Description

This double transducer is designed to convert light intensity to magnetic field strength, which in turn is converted to rotational speed. The photocell on the far left side of the stage measures surrounding light intensity. This value is then inputted into a 180-degree hobby servo motor that moves the attached magnet to different angle values. At higher light intensity, the magnet is at a lower position angle and is thus closer to the triple-axis magnetometer positioned in the middle of the breadboard. At lower light intensity, the magnet is positioned farther away from the compass. Only the magnetic field strength in the  y-axis is measured because of the more linear correlation between the readings in the y-axis and the servo’s angle position. The magnetic field value then serves as an input for the 360-degree servo motor positioned at the far right of the stage. The rotational speed of the 360-degree servo motor increases as the magnet gets closer to the compass and the magnetic field strength is greater. Thus, increasing light intensity on the left side of the stage increases the rotational speed on the far right side.

Top view of Double Transducer: Light Intensity -> Magnetic Field -> Rotational Speed

Light intensity input values are obtained using a photoresistor

I2C LCD displays the input and output values of the double transducer

The servo with the magnet attached adjusts its position depending on light intensity. Position is measured using a triple-axis compass.

Position of the magnet varies the rotational speed of this 360 hobby servo.

 

Progress Images

Project before components were positioned onto the board.

The first few components are zip tied to the board.

Wires are rearranged because the LCD was facing the wrong decision.

Battery is added so that it doesn’t rely on a laptop.

Discussion

Working with some of the components were easy, as we had worked with them before. We had no problems working with the photoresistor or servo motors. The challenge came from working with the magnetometer. Neither of us had ever worked with a compass before. Learning how it worked required research, and finding the right library was a difficult process. The library we initially found was unnecessarily complicated and only worked part of the time. It required a lot of fiddling with to determine what exactly was the problem.  Figuring out how a new component worked and finding an appropriate library for the device was a new experience for us.

The project required a lot of tweaking to the maximum and minimum values in our code. Ensuring the inputs never went out of range and that the outputs were exactly what we wanted required us to constantly make slight edits and see how that affected the project. In addition to that, we had to make temporary code to test the range of values. Slight shifts in max and min values completely changed the rotation speed output, requiring us to carefully puzzle out the perfect range. The process gave us a new appreciation for constants in our code and valuable experience in testing a project.

 

Schematic

 

Code

  1. /*
  2. Project 1: Light Intensity to Rotation Speed
  3. Leah Walko
  4. Gracia Genero
  6. Description: A double transducer that turns light intensity into
  7. magnetic fields into rotation speed. A photoresistor picks up the
  8. intensity of the light. That value changes the location of a magnet.
  9. In turn, this affects the magnetic fields read by a compass, and based
  10. off that value a servo motor rotates at a faster or slower speed.
  12. Credit: QMC5883LCompass library creator, MRPrograms, for their xyz
  13. example code, and to the course's lectures and website.
  15. Pin mapping:
  17. pin | mode | description
  18. ------|--------|--------------------------------------------
  19. A1 | input | photocell to measure light intensity
  20. A4 | input | triple axis compass SDA input
  21. A5 | input | triple axis compass SCL input
  22. 10 | output | Servo motor that moves the magnet around
  23. 11 | output | 360 degrees servo motor with variable rotation speed
  24. SCL | output | I2C LCD
  25. SDA | output | I2C LCD
  27. */
  29. // servo library
  30. #include <Servo.h>
  32. // compass and lcd libraries
  33. #include <Wire.h>
  34. #include <LiquidCrystal_I2C.h>
  35. #include <QMC5883LCompass.h>
  38. // pin values
  39. const int PHOTOPIN = A1;
  40. const int MOTORMAGPIN = 10;
  41. const int MOTORPIN = 11;
  43. // range of possible values
  44. const int ROTVAL_MAX = 89;
  45. const int ROTVAL_MIN = 0;
  46. const int MAGANGLE_MAX = 50;
  47. const int MAGANGLE_MIN = 0;
  48. const int LIGHT_MAX = 1023;
  49. const int LIGHT_MIN = 0;
  50. const int MAGVAL_MAX = 2700;
  51. const int MAGVAL_MIN = -7500;
  53. // timer for updating LCD
  54. const int INTERVAL = 1000;
  55. unsigned long timer = 0;
  57. // LCD values
  58. int screenInput = 0;
  59. int screenMInput = 0;
  60. int screenMOutput = 0;
  61. int screenOutput = 0;
  63. // compass values
  64. int x;
  65. int y;
  66. int z;
  68. // motor objects
  69. Servo magnetMotor; // create a motor "object" called magnetMotor
  70. Servo rotatingMotor; // create a motor "object" called rotatingMotor
  72. // compass and LCD objects
  73. QMC5883LCompass compass; // create a compass "object" called compass
  74. LiquidCrystal_I2C screen(0x27, 16, 2); // create a LCD "object" called screen
  76. void setup() {
  78. // setup the screen
  79. screen.init();
  80. screen.backlight(); // turn on the backlight to start
  81. screen.home(); // set cursor to home position
  82. screen.print("i:"); // print out the unchanging parts of the values
  83. screen.setCursor(6, 0);
  84. screen.print("m:");
  85. screen.setCursor(12, 1);
  86. screen.print("o:");
  87. delay(2000); // do nothing for 2 seconds
  89. // setup the input pin -> photocell
  90. pinMode(PHOTOPIN, INPUT);
  92. // Initializing compass
  93. compass.init();
  95. // setup the output -> motor moving the magnet + motor rotating
  96. magnetMotor.attach(MOTORMAGPIN);
  97. rotatingMotor.attach(MOTORPIN);
  98. rotatingMotor.write(90);
  100. Serial.begin(9600);
  102. }
  104. void loop() {
  106. // get info on light intensity
  107. int lightVal = analogRead(PHOTOPIN);
  109. // calculate the location of the magnet and move the motor to that angle
  110. int magAngle = map(lightVal, LIGHT_MIN, LIGHT_MAX, MAGANGLE_MIN, MAGANGLE_MAX);
  111. magnetMotor.write(magAngle);
  113. // get the compass value
  114. // Read compass values
  115. compass.read();
  116. // Return XYZ readings from the compass
  117. x = compass.getX();
  118. y = compass.getY();
  119. z = compass.getZ();
  121. // calculate magnetic value
  122. int magVal = y;
  124. // calculate rotation speed
  125. int rotateVal = map(magVal, MAGVAL_MIN, MAGVAL_MAX, ROTVAL_MIN, ROTVAL_MAX);
  127. // servo rotates at a speed of rotateVal (0 is faster, 90 is slower)
  128. rotatingMotor.write(rotateVal);
  130. // Update LCD screen values
  131. screenInput = map(lightVal, LIGHT_MIN, LIGHT_MAX, 0, 99);
  132. screenMInput = map(magAngle, MAGANGLE_MIN, MAGANGLE_MAX, 0, 99);
  133. screenMOutput = map(magVal, MAGVAL_MIN, MAGVAL_MAX, 0, 99);
  134. screenOutput = map(rotateVal, ROTVAL_MIN, ROTVAL_MAX, 0, 99);
  136. // Display updated LCD screen values only at specific time intervals
  137. if (millis() >= timer) {
  138. // print light val input
  139. screen.setCursor(2, 0);
  140. screen.print(screenInput);
  142. // print the magnetic field output value
  143. screen.setCursor(8, 0);
  144. screen.print(screenMInput);
  146. // print the magnetic field input value
  147. screen.setCursor(8, 1);
  148. screen.print(screenMOutput);
  150. // print the rotation speed output value
  151. screen.setCursor(14, 1);
  152. screen.print(screenOutput);
  154. // reset timer
  155. timer = millis() + INTERVAL;
  157. // serial output for testing purposes
  158. Serial.println((String)"X: " + x +
  159. "; Y: " + y +
  160. "; Z: " + z);
  162. Serial.println((String)"room brightness: " + lightVal +
  163. "; magVal: " + magVal +
  164. "; rotateVal: " + rotateVal +
  165. "; magAngle: " + magAngle );
  166. }
  167. }