You are currently browsing the archive for the documentation category.
2, wiring the 2 stepper motors. Both of them areunipolar.
The unipolar stepper motor has five or six wires and four coils (actually two coils divided by center connections on each coil). The center connections of the coils are tied together and used as the power connection. They are called unipolar steppers because power always comes in on this one pole. (source: http://www.tigoe.net/pcomp/code/category/code/arduinowiring/51 )
3, connecting the encoder
http://www.nubotics.com/support/index.html
4, soldering onto little piece of perfboard to make the plug-in modula on arduino
5, test the encoder, and we got accurate readings: every rotation of the steppers, the encoder increments “62″
6, first version of housing gears, motors and encoder.
6, final version of housing
7, standing up (here is the tricky thing.the gravity made the gears works a little bit different, when moving towards up, like 9 o clock, the pointer stepping may loose steps, so we did re-housing, making it more secure and stable, and checking motors again)
8, spray the face and mount onto the clock.
// Variables for calculating PERIOD and SEX pointers
//float speedPointer();
//#include <avr/pgmspace.h>
int encoder[108];
//PROGMEM prog_uchar encoder[106];
//prog_uchar encoder[106] PROGMEM;
//unsigned char lastEncoder0Pos;
int displayRead;
int lastEncoder0Pos;
unsigned char encoder0Pos;
int steps;
int timePeriod=120;
int passedDays=15;
int cycleCount;
int gear20=18;
int gear24=96;
int delayRate;
int pointerPos=0;
//int sexPoint=0;
//int reading[107];
int initialSteps;
int delayMillis;
int savedMillis;
int ellapsedMillis;
int displayEncoder;
//int lastEncoder0Pos;
int lastChange;
//Variables for communicating to Processing
int firstByte; // value for Period
int secondByte; // value for Initial Date
int serialInArray[3]; // array for storing 3 bytes as they arrive from processing
int serialCount = 0; // for counting the number of bytes received
// ENCODER Variables
#define encoder0PinA 2
#define encoder0PinB 3
//volatile int encoder0Pos = 0;
// Stepper Motor Variables
int counter=0;
#include <Stepper.h>
//Motor Steps for Motor 1
#define motor1Steps 24 // change this depending on the number of steps
// Steps fo motor 2
#define motor2Steps 20 // per revolution of your motor
// Pins 4 to 7 for Motor 1
#define motorPin1 8
#define motorPin2 9
#define motorPin3 10
#define motorPin4 11
//Pins 8-11 for Motor 2
#define motorPin5 4
#define motorPin6 5
#define motorPin7 6
#define motorPin8 7
// initialize of the Stepper library:
Stepper myStepper(motor1Steps, motorPin1,motorPin2,motorPin3,motorPin4);
Stepper myStepper2(motor2Steps,motorPin5,motorPin6,motorPin7,motorPin8);
void setup() {
// set the motor speed at 60 RPMS:
myStepper.setSpeed(10);
myStepper2.setSpeed(60);
// Initialize the Serial port:
Serial.begin(9600);
// myStepper.step(10);
//SETUP FOR ENCODER
pinMode(encoder0PinA, INPUT);
digitalWrite(encoder0PinA, HIGH); // turn on pullup resistor
pinMode(encoder0PinB, INPUT);
digitalWrite(encoder0PinB, HIGH); // turn on pullup resistor
attachInterrupt(0, doEncoder, CHANGE); // encoder pin on interrupt 0 - pin 2
Serial.begin (9600);
Serial.println(”start”); // a personal quirk
savedMillis=millis();
initialSteps=-106.67*passedDays/timePeriod;
delayMillis=9.375*timePeriod;
myStepper2.step(int(initialSteps));
Serial.println(initialSteps);
}
void loop() {
lastChange = millis();
/*
if (Serial.available() > 0) {
// read the most recent byte (which will be from 0 to 255)
if(Serial.read()==65){
timePeriod = Serial.read();
passedDays = Serial.read();
}
}
*/
/*
serialInArray[serialCount] = Serial.read(); // read a byte sent by processing
serialCount++; // increment number of bytes received
if (serialCount > 2 ) { // when 3 bytes received
firstByte = serialInArray[1]; // get value for PERIOD
secondByte = serialInArray[2]; // get value for INITIAL DATE
serialCount = 0;
}
*/
//delayMillis=1000*gear20*timePeriod/(gear24*motor2Steps);
// delayMillis=0;
// Serial.println(delayMillis);
//+” “+delayMillis+” “+savedMillis);
ellapsedMillis=millis()-savedMillis;
if(ellapsedMillis>=delayMillis){
// Serial.println(ellapsedMillis);
myStepper2.step(-1);
savedMillis=millis();
pointerPos+=1;
// if(pointerPos==30){
// Serial.println(”pointerPos”);
// Serial.println(pointerPos);
// }
//encoder[pointerPos]=encoder0Pos;
//encoder0Pos=lastEncoder0Pos;
//Serial.println(pointerPos);
// displayEncoder = pgm_read_byte_near(lastEncoder0Pos);
// Serial.println(displayEncoder);
///////// STEPPER1.STEP()
// lastEncoder0Pos = encoder0Pos;
// note the last time the encoder changed:
//lastEncoder0Pos=encoder[pointerPos];
// if (encoder0Pos != encoder[pointerPos] && encoder[pointerPos]>0) {
if (encoder[pointerPos]>0) {
// save the last change in the encoder:
// if(pointerPos<30){
Serial.println(”encoder[pointerPos]” );
Serial.println(encoder[pointerPos]);
// }
// Serial.println(”encoder0Pos”);
// Serial.println(encoder0Pos, DEC);
// Serial.println(”lastEncoder0Pos”);
// Serial.println(lastEncoder0Pos);
steps=int(.375*(-encoder0Pos+encoder[pointerPos]));
Serial.println(steps);
myStepper.step(steps);
}
/*
if(encoder0Pos>lastEncoder0Pos){
steps=int(.375*(64-encoder0Pos+lastEncoder0Pos));
Serial.println(”steps1″);
Serial.println(steps);
// Serial.println(.375*(64-encoder0Pos+encoder[pointerPos]));
}else{
steps=int(.375*(lastEncoder0Pos-encoder0Pos));
Serial.println(”steps2″);
Serial.println(steps);
// Serial.println(((encoder[pointerPos]-encoder0Pos));
}
}
*/
if (millis() - lastChange >= delayMillis*0.8) {
// if (millis() - lastChange >= 1000) {
// save the reading
encoder[pointerPos]=encoder0Pos;
// Serial.println(”writingingto”);
// Serial.println(lastEncoder0Pos);
//prog_uchar encoder[pointerPos]=lastEncoder0Pos;
}
}
if (pointerPos == 106){
cycleCount+=1;
pointerPos=0;
if (cycleCount==3){
myStepper2.step(3);
}
Serial.println(”cycleCount”);
}
/*
for (int i=0; i<pointerPos; i++){
encoder[i]=displayRead;
Serial.println(displayRead);
if (displayRead>1 && i==pointerPos){
if (displayRead != encoder0Pos)
myStepper.step(1);
}
}
*/
/*
for( int i=0; i<pointerPos; i++){
encoder[i]=lastEncoder0Pos;
if (lastEncoder0Pos >0){
if (encoder0Pos != lastEncoder0Pos)
{
myStepper.step(1);
}
}
}
*/
}
void doEncoder(){
if (digitalRead(encoder0PinA) == HIGH) { // found a low-to-high on channel A
if (digitalRead(encoder0PinB) == LOW) { // check channel B to see which way
// encoder is turning
encoder0Pos = encoder0Pos - 1; // CCW
}
else {
encoder0Pos = encoder0Pos + 1; // CW
}
}
else // found a high-to-low on channel A
{
if (digitalRead(encoder0PinB) == LOW) { // check channel B to see which way
// encoder is turning
encoder0Pos = encoder0Pos + 1; // CW
}
else {
encoder0Pos = encoder0Pos - 1; // CCW
}
}
if(encoder0Pos>64){
encoder0Pos=1;
}
if(encoder0Pos<1){
encoder0Pos=64;
}
// Serial.println (encoder0Pos, DEC); // debug - remember to comment out
}
/*
Stepper Motor Controller
language: Wiring/Arduino
This program drives a unipolar or bipolar stepper motor.
The motor is attached to digital pins 8 and 9 of the Arduino.
The motor moves 100 steps in one direction, then 100 in the other.
Created 11 Mar. 2007
Modified 7 Apr. 2007
by Tom Igoe
*/
// define the pins that the motor is attached to. You can use
// any digital I/O pins.
int inByte = 0;
#include
#define motorSteps 48 // change this depending on the number of steps
// per revolution of your motor
#define motorPin1 8
#define motorPin2 9
#define motorPin3 10
#define motorPin4 11
#define ledPin 13
// initialize of the Stepper library:
Stepper myStepper(motorSteps, motorPin1,motorPin2,motorPin3,motorPin4);
void setup() {
// set the motor speed at 60 RPMS:
myStepper.setSpeed(120);
// Initialize the Serial port:
Serial.begin(9600);
// set up the LED pin:
}
void loop() {
// Step forward 100 steps:
if (Serial.available() > 0) {
// get incoming byte:
inByte = Serial.read();
// Serial.println("Forward");
// Serial.print(BYTE);
}
myStepper.step(inByte);
delay(500);
}
/*
Stepper Motor Controller
language: Wiring/Arduino
This program drives a unipolar or bipolar stepper motor.
The motor is attached to digital pins 8 and 9 of the Arduino.
The motor moves 100 steps in one direction, then 100 in the other.
Created 11 Mar. 2007
Modified 7 Apr. 2007
by Tom Igoe
*/
// define the pins that the motor is attached to. You can use
// any digital I/O pins.
#include
#define motorSteps 200 // change this depending on the number of steps
// per revolution of your motor
#define motorPin1 8
#define motorPin2 9
#define ledPin 13
// initialize of the Stepper library:
Stepper myStepper(motorSteps, motorPin1,motorPin2);
void setup() {
// set the motor speed at 60 RPMS:
myStepper.setSpeed(60);
// Initialize the Serial port:
Serial.begin(9600);
// set up the LED pin:
pinMode(ledPin, OUTPUT);
// blink the LED:
blink(3);
}
}
Yellow = Power
Violet = Ground
Red= PinA (which in the code is Pin #2)
White=PinB(which in the code is Pin#3) (be carefull with white because it falls apart… but is always the pin at the side of the red.
So the Stepper Motors, at the end are 5 wires, I still dont discover what the white wire does (I tried to connect to ground, and nope). So the Black Wire in both steppers is POWER and at it works much better with 5V than with 12V (more easy impossible).
The pins for the two Steppers I have them divided: from 4 to 7 is the stepper with the golden tip, from 8 to 11 the one with the pointi white tip. The Stepper in which I have mounted the encoder is the one with the white tip.
The following post will explain the process that we had to get to our last idea (we hope) for the Final Project for Physical Computing. It has being one of the most interesting brain storming and not being afraid to explore every idea that came to us. After defining parameter for the main purpose for the project we first taught in the Abacus, but still we didn’t like that the Abacus was still and did not have a rich interaction with the user, also it took the person outside of their routine and didn’t engage them. So we went off and came with the idea of the pajamas. What we liked about the pijamas is that depending in your mood you will use a tight or loose pajama, also the interaction of doing an action that was rutinary and being conscious about it.
The problem with the pijama was still that it did not have a rich interaction, and that there where many other factors that can influence the decision of choosing a pajama. So we incorporated the idea of the Mirror. The mirror is an important device for women and we interact a lot with it, so we wanted to track how much time a women spent in front of a mirror. Several projects came out with the idea of the mirror but still it was lacking of our purpose. So we took us, and thought about different handles, that again every day you will use a handle to open the door, and well giving a person different handles with different shapes and colors, that the person will have to use depending in their mood.
Again with this idea we could not control outside elements such as, Who is opening the door? What if the person does not even think about it at all? This brought the idea of a shade that depending in how you moved it and touch it, it will register certain information. But again, now we had a rich interaction but we where lacking of substance, or another way to say it meaning. We presented this ideas to Tom, who question them, and help us out to come with what we originally wanted, he put us back on track after discussing the Abacus idea (this was one of the fist ideas) he mention that we could do of the scale was of a three that you could modify its extremes depending on your mood.with the same concept of the abacus a scale with different rows, we really like this idea, and further developed. The problem with the scale was a design problem, because we were thinking of an abacous in which you could pass the marbles from side to side. So nothing seemed to work without taking out many ideas of the design. One idea that came out
This project was color based. And we worked a lot with this idea, conceptualizing the three and even doing user testing. We developed different color scales one in which we used the hue theory other using complementary colors and other using the basic colors. We where now “completely sure” of our idea and even thinking of buying material, when we started questioning again, the meaning, and our intention. 
Another idea came in the way of the need to improve communication between couples, and that this idea was not achieving this. So we work with a bottle as an output that could compare a couple’s feelings. Now the three will not be just for women, it would be for the couple. We went back with the scale idea, and tought of a zig-zag scale nested in a wood box, this will allow us to move the marbles along and to equilibrate both sides.
After again questioning the purpose of the project we came up with the idea of using the clock to express your emotions, here we were exploring the couples problems and things that they could not know about each other or could not speak out loud. We added the concept of the period and how one handle will be dedicated to track the women’s period and tell the men when the women is getting their period. We stood with this idea, and met to buy materials and explore different methods with it.