tag:blogger.com,1999:blog-21797562643751997482024-03-14T08:11:46.659+10:30Test BlogDan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.comBlogger18125tag:blogger.com,1999:blog-2179756264375199748.post-91834997862130227512010-05-23T10:59:00.030+09:302010-05-23T12:44:37.460+09:30test<pre class="brush: c">///////////////////////////////////////////////////////////
// Stepper Motor skecth for use with the EasyDriver v4.2 //
///////////////////////////////////////////////////////////
// Dan Thompson 2010
//
// Use this code at your own risk.
//
// For all the product details visit http://greta.dhs.org/EasyDriver/
// For the full tutorial visit http://danthompsonsblog.blogspot.com/
////// ED_v4 Step Mode Chart //////
// //
// MS1 MS2 Resolution //
// L L Full step (2 phase) //
// H L Half step //
// L H Quarter step //
// H H Eighth step //
// //
////////////////////////////////////
int DIR = 3; // PIN 3 = DIR
int STEP = 2; // PIN 2 = STEP
int MS1 = 13; // PIN 13 = MS
int MS2 = 9; // PIN 9 = MS2
int SLEEP = 12; // PIN 12 = SLP
void setup() {
Serial.begin(9600); // open the serial connection at 9600bps
pinMode(DIR, OUTPUT); // set pin 3 to output
pinMode(STEP, OUTPUT); // set pin 2 to output
pinMode(MS1, OUTPUT); // set pin 13 to output
pinMode(MS2, OUTPUT); // set pin 9 to output
pinMode(SLEEP, OUTPUT); // set pin 12 to output
}
void loop()
{
int modeType = 1; // This number increases by multiple of 2 each through the while loop..
// ..to identify our step mode type.
while (modeType<=8){ // loops the following block of code 4 times before repeating .
digitalWrite(DIR, LOW); // Set the direction change LOW to HIGH to go in opposite direction
digitalWrite(MS1, MS1_MODE(modeType)); // Set state of MS1 based on the returned value from the MS1_MODE() switch statement.
digitalWrite(MS2, MS2_MODE(modeType)); // Set state of MS2 based on the returned value from the MS2_MODE() switch statement.
digitalWrite(SLEEP, HIGH); // Set the Sleep mode to AWAKE.
int i = 0; // Set the counter variable.
while(i<(modeType*200)) // Iterate for 200, then 400, then 800, then 1600 steps.
// Then reset to 200 and start again.
{
digitalWrite(STEP, LOW); // This LOW to HIGH change is what creates the..
digitalWrite(STEP, HIGH); // .."Rising Edge" so the easydriver knows to when to step.
delayMicroseconds(1600/modeType); // This delay time determines the speed of the stepper motor.
// Delay shortens from 1600 to 800 to 400 to 200 then resets
i++;
}
modeType = modeType * 2; // Multiply the current modeType value by 2 and make the result the new value for modeType.
// This will make the modeType variable count 1,2,4,8 each time we pass though the while loop.
delay(500);
}
digitalWrite(SLEEP, LOW); // switch off the power to stepper
Serial.print("SLEEPING..");
delay(1000);
Serial.print("z");
delay(1000);
Serial.print("z");
delay(1000);
Serial.print("z");
delay(1000);
Serial.println("");
digitalWrite(SLEEP, HIGH);
Serial.println("AWAKE!!!"); // Switch on the power to stepper
delay(1000);
}
int MS1_MODE(int MS1_StepMode){ // A function that returns a High or Low state number for MS1 pin
switch(MS1_StepMode){ // Switch statement for changing the MS1 pin state
// Different input states allowed are 1,2,4 or 8
case 1:
MS1_StepMode = 0;
Serial.println("Step Mode is Full...");
break;
case 2:
MS1_StepMode = 1;
Serial.println("Step Mode is Half...");
break;
case 4:
MS1_StepMode = 0;
Serial.println("Step Mode is Quarter...");
break;
case 8:
MS1_StepMode = 1;
Serial.println("Step Mode is Eighth...");
break;
}
return MS1_StepMode;
}
int MS2_MODE(int MS2_StepMode){ // A function that returns a High or Low state number for MS2 pin
switch(MS2_StepMode){ // Switch statement for changing the MS2 pin state
// Different input states allowed are 1,2,4 or 8
case 1:
MS2_StepMode = 0;
break;
case 2:
MS2_StepMode = 0;
break;
case 4:
MS2_StepMode = 1;
break;
case 8:
MS2_StepMode = 1;
break;
}
return MS2_StepMode;
}
</pre>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-2722235969026045242010-05-23T09:57:00.001+09:302010-05-23T09:57:50.941+09:30test<pre name="code" class="c">///////////////////////////////////////////////////////////
// Stepper Motor skecth for use with the EasyDriver v4.2 //
///////////////////////////////////////////////////////////
// Dan Thompson 2010
//
// Use this code at your own risk.
//
// For all the product details visit http://greta.dhs.org/EasyDriver/
// For the full tutorial visit http://danthompsonsblog.blogspot.com/
////// ED_v4 Step Mode Chart //////
// //
// MS1 MS2 Resolution //
// L L Full step (2 phase) //
// H L Half step //
// L H Quarter step //
// H H Eighth step //
// //
////////////////////////////////////
int DIR = 3; // PIN 3 = DIR
int STEP = 2; // PIN 2 = STEP
int MS1 = 13; // PIN 13 = MS
int MS2 = 9; // PIN 9 = MS2
int SLEEP = 12; // PIN 12 = SLP
void setup() {
Serial.begin(9600); // open the serial connection at 9600bps
pinMode(DIR, OUTPUT); // set pin 3 to output
pinMode(STEP, OUTPUT); // set pin 2 to output
pinMode(MS1, OUTPUT); // set pin 13 to output
pinMode(MS2, OUTPUT); // set pin 9 to output
pinMode(SLEEP, OUTPUT); // set pin 12 to output
}
</pre>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-42044535943836763232010-05-22T17:48:00.001+09:302010-05-22T17:49:24.009+09:30test<pre><span style="color: #7E7E7E;">///////////////////////////////////////////////////////////</span>
<span style="color: #7E7E7E;">// Stepper Motor skecth for use with the EasyDriver v4.2 //</span>
<span style="color: #7E7E7E;">///////////////////////////////////////////////////////////</span>
<span style="color: #7E7E7E;">// Dan Thompson 2010</span>
<span style="color: #7E7E7E;">//</span>
<span style="color: #7E7E7E;">// Use this code at your own risk.</span>
<span style="color: #7E7E7E;">//</span>
<span style="color: #7E7E7E;">// For all the product details visit http://greta.dhs.org/EasyDriver/</span>
<span style="color: #7E7E7E;">// For the full tutorial visit http://danthompsonsblog.blogspot.com/</span>
<span style="color: #7E7E7E;">////// ED_v4 Step Mode Chart //////</span>
<span style="color: #7E7E7E;">// //</span>
<span style="color: #7E7E7E;">// MS1 MS2 Resolution //</span>
<span style="color: #7E7E7E;">// L L Full step (2 phase) //</span>
<span style="color: #7E7E7E;">// H L Half step //</span>
<span style="color: #7E7E7E;">// L H Quarter step //</span>
<span style="color: #7E7E7E;">// H H Eighth step //</span>
<span style="color: #7E7E7E;">// //</span>
<span style="color: #7E7E7E;">////////////////////////////////////</span>
<span style="color: #CC6600;">int</span> DIR = 3; <span style="color: #7E7E7E;">// PIN 3 = DIR</span>
<span style="color: #CC6600;">int</span> STEP = 2; <span style="color: #7E7E7E;">// PIN 2 = STEP</span>
<span style="color: #CC6600;">int</span> MS1 = 13; <span style="color: #7E7E7E;">// PIN 13 = MS</span>
<span style="color: #CC6600;">int</span> MS2 = 9; <span style="color: #7E7E7E;">// PIN 9 = MS2</span>
<span style="color: #CC6600;">int</span> SLEEP = 12; <span style="color: #7E7E7E;">// PIN 12 = SLP</span>
<span style="color: #CC6600;">void</span> <span style="color: #CC6600;"><b>setup</b></span>() {
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">begin</span>(9600); <span style="color: #7E7E7E;">// open the serial connection at 9600bps</span>
<span style="color: #CC6600;">pinMode</span>(DIR, <span style="color: #006699;">OUTPUT</span>); <span style="color: #7E7E7E;">// set pin 3 to output</span>
<span style="color: #CC6600;">pinMode</span>(STEP, <span style="color: #006699;">OUTPUT</span>); <span style="color: #7E7E7E;">// set pin 2 to output</span>
<span style="color: #CC6600;">pinMode</span>(MS1, <span style="color: #006699;">OUTPUT</span>); <span style="color: #7E7E7E;">// set pin 13 to output</span>
<span style="color: #CC6600;">pinMode</span>(MS2, <span style="color: #006699;">OUTPUT</span>); <span style="color: #7E7E7E;">// set pin 9 to output</span>
<span style="color: #CC6600;">pinMode</span>(SLEEP, <span style="color: #006699;">OUTPUT</span>); <span style="color: #7E7E7E;">// set pin 12 to output</span>
}
<span style="color: #CC6600;">void</span> <span style="color: #CC6600;"><b>loop</b></span>()
{
<span style="color: #CC6600;">int</span> modeType = 1; <span style="color: #7E7E7E;">// This number increases by multiple of 2 each through the while loop..</span>
<span style="color: #7E7E7E;">// ..to identify our step mode type. </span>
<span style="color: #CC6600;">while</span> (modeType<=8){ <span style="color: #7E7E7E;">// loops the following block of code 4 times before repeating .</span>
<span style="color: #CC6600;">digitalWrite</span>(DIR, <span style="color: #006699;">LOW</span>); <span style="color: #7E7E7E;">// Set the direction change LOW to HIGH to go in opposite direction</span>
<span style="color: #CC6600;">digitalWrite</span>(MS1, MS1_MODE(modeType)); <span style="color: #7E7E7E;">// Set state of MS1 based on the returned value from the MS1_MODE() switch statement.</span>
<span style="color: #CC6600;">digitalWrite</span>(MS2, MS2_MODE(modeType)); <span style="color: #7E7E7E;">// Set state of MS2 based on the returned value from the MS2_MODE() switch statement.</span>
<span style="color: #CC6600;">digitalWrite</span>(SLEEP, <span style="color: #006699;">HIGH</span>); <span style="color: #7E7E7E;">// Set the Sleep mode to AWAKE.</span>
<span style="color: #CC6600;">int</span> i = 0; <span style="color: #7E7E7E;">// Set the counter variable. </span>
<span style="color: #CC6600;">while</span>(i<(modeType*200)) <span style="color: #7E7E7E;">// Iterate for 200, then 400, then 800, then 1600 steps. </span>
<span style="color: #7E7E7E;">// Then reset to 200 and start again.</span>
{
<span style="color: #CC6600;">digitalWrite</span>(STEP, <span style="color: #006699;">LOW</span>); <span style="color: #7E7E7E;">// This LOW to HIGH change is what creates the..</span>
<span style="color: #CC6600;">digitalWrite</span>(STEP, <span style="color: #006699;">HIGH</span>); <span style="color: #7E7E7E;">// .."Rising Edge" so the easydriver knows to when to step.</span>
<span style="color: #CC6600;">delayMicroseconds</span>(1600/modeType); <span style="color: #7E7E7E;">// This delay time determines the speed of the stepper motor. </span>
<span style="color: #7E7E7E;">// Delay shortens from 1600 to 800 to 400 to 200 then resets </span>
i++;
}
modeType = modeType * 2; <span style="color: #7E7E7E;">// Multiply the current modeType value by 2 and make the result the new value for modeType.</span>
<span style="color: #7E7E7E;">// This will make the modeType variable count 1,2,4,8 each time we pass though the while loop.</span>
<span style="color: #CC6600;">delay</span>(500);
}
<span style="color: #CC6600;">digitalWrite</span>(SLEEP, <span style="color: #006699;">LOW</span>); <span style="color: #7E7E7E;">// switch off the power to stepper</span>
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">print</span>(<span style="color: #006699;">"SLEEPING.."</span>);
<span style="color: #CC6600;">delay</span>(1000);
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">print</span>(<span style="color: #006699;">"z"</span>);
<span style="color: #CC6600;">delay</span>(1000);
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">print</span>(<span style="color: #006699;">"z"</span>);
<span style="color: #CC6600;">delay</span>(1000);
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">print</span>(<span style="color: #006699;">"z"</span>);
<span style="color: #CC6600;">delay</span>(1000);
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">println</span>(<span style="color: #006699;">""</span>);
<span style="color: #CC6600;">digitalWrite</span>(SLEEP, <span style="color: #006699;">HIGH</span>);
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">println</span>(<span style="color: #006699;">"AWAKE!!!"</span>); <span style="color: #7E7E7E;">// Switch on the power to stepper</span>
<span style="color: #CC6600;">delay</span>(1000);
}
<span style="color: #CC6600;">int</span> MS1_MODE(<span style="color: #CC6600;">int</span> MS1_StepMode){ <span style="color: #7E7E7E;">// A function that returns a High or Low state number for MS1 pin</span>
<span style="color: #CC6600;">switch</span>(MS1_StepMode){ <span style="color: #7E7E7E;">// Switch statement for changing the MS1 pin state</span>
<span style="color: #7E7E7E;">// Different input states allowed are 1,2,4 or 8</span>
<span style="color: #CC6600;">case</span> 1:
MS1_StepMode = 0;
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">println</span>(<span style="color: #006699;">"Step Mode is Full..."</span>);
<span style="color: #CC6600;">break</span>;
<span style="color: #CC6600;">case</span> 2:
MS1_StepMode = 1;
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">println</span>(<span style="color: #006699;">"Step Mode is Half..."</span>);
<span style="color: #CC6600;">break</span>;
<span style="color: #CC6600;">case</span> 4:
MS1_StepMode = 0;
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">println</span>(<span style="color: #006699;">"Step Mode is Quarter..."</span>);
<span style="color: #CC6600;">break</span>;
<span style="color: #CC6600;">case</span> 8:
MS1_StepMode = 1;
<span style="color: #CC6600;"><b>Serial</b></span>.<span style="color: #CC6600;">println</span>(<span style="color: #006699;">"Step Mode is Eighth..."</span>);
<span style="color: #CC6600;">break</span>;
}
<span style="color: #CC6600;">return</span> MS1_StepMode;
}
<span style="color: #CC6600;">int</span> MS2_MODE(<span style="color: #CC6600;">int</span> MS2_StepMode){ <span style="color: #7E7E7E;">// A function that returns a High or Low state number for MS2 pin</span>
<span style="color: #CC6600;">switch</span>(MS2_StepMode){ <span style="color: #7E7E7E;">// Switch statement for changing the MS2 pin state</span>
<span style="color: #7E7E7E;">// Different input states allowed are 1,2,4 or 8</span>
<span style="color: #CC6600;">case</span> 1:
MS2_StepMode = 0;
<span style="color: #CC6600;">break</span>;
<span style="color: #CC6600;">case</span> 2:
MS2_StepMode = 0;
<span style="color: #CC6600;">break</span>;
<span style="color: #CC6600;">case</span> 4:
MS2_StepMode = 1;
<span style="color: #CC6600;">break</span>;
<span style="color: #CC6600;">case</span> 8:
MS2_StepMode = 1;
<span style="color: #CC6600;">break</span>;
}
<span style="color: #CC6600;">return</span> MS2_StepMode;
}
</pre>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-8272771385058148912010-04-07T09:55:00.001+09:302010-04-07T09:55:24.224+09:30testLink<a href="http://dl.dropbox.com/u/1750722/Code/Python/motor.html">My Link</a>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-50311564002167605592010-04-06T23:16:00.017+09:302010-04-07T00:14:13.854+09:30<code style="syntax"><span style='color:#3f7f59; '>################################################</span><br />
<span style='color:#3f7f59; '># Module: motor.py</span><br />
<span style='color:#3f7f59; '># Created: 21 April 2009</span><br />
<span style='color:#3f7f59; '># Author: Daniel Thompson</span><br />
<span style='color:#3f7f59; '># http://danthompsonsblog.blogspot.com/</span><br />
<span style='color:#3f7f59; '># Version: 0.2</span><br />
<span style='color:#3f7f59; '># License: GPLv3</span><br />
<span style='color:#3f7f59; '># http://www.fsf.org/licensing/</span><br />
<span style='color:#3f7f59; '>'''Provides a serial connection abstraction layer</span><br />
<span style='color:#3f7f59; '>for use with Arduino "MultipleSteppers" sketch.</span><br />
<span style='color:#3f7f59; '>'''</span><br />
<span style='color:#3f7f59; '>#######################fhgjfhjfghjfghjgfhjfghjgfhjghjghjghj#########################</span><br />
<span style='color:#7f0055; font-weight:bold; '>import</span> motor<br />
<span style='color:#7f0055; font-weight:bold; '>import</span> serial<br />
<br />
<span style='color:#3f7f59; '>#setup the serial port</span><br />
usbport = <span style='color:#2a00ff; '>'COM4'</span><br />
ser = serial.Serial(usbport, 115200, timeout=1)<br />
<br />
<span style='color:#3f7f59; '># convert a decimal (denary, base 10) integer to a binary string (base 2)</span><br />
<span style='color:#7f0055; font-weight:bold; '>def</span> d2b(n):<br />
<span style='color:#3f7f59; '>'''convert denary integer n to binary string bStr'''</span><br />
bStr = <span style='color:#2a00ff; '>''</span><br />
<span style='color:#7f0055; font-weight:bold; '>if</span> n < 0: <span style='color:#7f0055; font-weight:bold; '>raise</span> ValueError, <span style='color:#2a00ff; '>"must be a positive integer"</span><br />
<span style='color:#7f0055; font-weight:bold; '>if</span> n == 0:<br />
<span style='color:#7f0055; font-weight:bold; '>return</span> <span style='color:#2a00ff; '>'0'</span><br />
<span style='color:#7f0055; font-weight:bold; '>while</span> n > 0:<br />
bStr = str(n % 2) + bStr<br />
n = n >> 1<br />
<span style='color:#7f0055; font-weight:bold; '>return</span> bStr<br />
<br />
<span style='color:#3f7f59; '>'''Returns the number of bit bytes (eighths) in binary string.</span><br />
<span style='color:#3f7f59; '>Always rounds up, never rounds down.'''</span><br />
<span style='color:#7f0055; font-weight:bold; '>def</span> binaryCount(number):<br />
sNumber = str(number)<br />
length = len(sNumber)<br />
numBytes = length / 8.0<br />
numBytesInt = length / 8<br />
<span style='color:#7f0055; font-weight:bold; '>if</span> numBytes > numBytesInt:<br />
<span style='color:#7f0055; font-weight:bold; '>return</span> numBytesInt + 1<br />
<span style='color:#7f0055; font-weight:bold; '>else</span>:<br />
<span style='color:#7f0055; font-weight:bold; '>return</span> numBytesInt<br />
<br />
<span style='color:#3f7f59; '>'''This function gets the first byte, removes it from the string and</span><br />
<span style='color:#3f7f59; '>returns a new value'''</span><br />
<span style='color:#7f0055; font-weight:bold; '>def</span> shiftLeft(binary):<br />
sBinary = str(binary)<br />
firstByte = int(sBinary,2) & int(<span style='color:#2a00ff; '>'11111111'</span>,2)<br />
newBinary = int(sBinary,2) >> 8<br />
nBinary = motor.d2b(newBinary)<br />
<span style='color:#7f0055; font-weight:bold; '>print</span> <span style='color:#2a00ff; '>"I took away"</span>, firstByte<br />
<span style='color:#7f0055; font-weight:bold; '>print</span> <span style='color:#2a00ff; '>"And now I'm left with"</span>, nBinary<br />
<span style='color:#7f0055; font-weight:bold; '>return</span> nBinary<br />
<br />
<span style='color:#3f7f59; '># Wraps several functions to split</span><br />
<span style='color:#3f7f59; '># the "steps" integer into bytes ready for sending</span><br />
<span style='color:#3f7f59; '># Then it write packet header (255) and then</span><br />
<span style='color:#3f7f59; '># all the other bytes</span><br />
<br />
<span style='color:#3f7f59; '>'''The final move command. I combines all the other functions in this</span><br />
<span style='color:#3f7f59; '>module to move the motor to the specified position'''</span><br />
<span style='color:#7f0055; font-weight:bold; '>def</span> position(num,degsPerStepFloat,stepsFloat):<br />
steps = int(stepsFloat / degsPerStepFloat)<br />
<span style='color:#7f0055; font-weight:bold; '>if</span>(steps < 65535 <span style='color:#7f0055; font-weight:bold; '>and</span> steps > -1):<br />
binary = motor.d2b(steps)<br />
numBytes = motor.binaryCount(binary)<br />
<span style='color:#3f7f59; '># from the shiftLef def</span><br />
ser.write(chr(255))<br />
<span style='color:#3f7f59; '># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span><br />
<span style='color:#7f0055; font-weight:bold; '>for</span> i <span style='color:#7f0055; font-weight:bold; '>in</span> range(0,2,1):<br />
sBinary = str(binary)<br />
firstByte = int(sBinary,2) & int(<span style='color:#2a00ff; '>'11111111'</span>,2)<br />
newBinary = int(sBinary,2) >> 8<br />
binary = motor.d2b(newBinary)<br />
ser.write(chr(firstByte))<br />
<span style='color:#7f0055; font-weight:bold; '>if</span>(steps > -65535 <span style='color:#7f0055; font-weight:bold; '>and</span> steps < 0):<br />
stepsNeg = steps * -1<br />
binary = motor.d2b(stepsNeg)<br />
numBytes = motor.binaryCount(binary)<br />
<span style='color:#3f7f59; '># from the shiftLef def</span><br />
ser.write(chr(220))<br />
<span style='color:#3f7f59; '># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span><br />
<span style='color:#7f0055; font-weight:bold; '>for</span> i <span style='color:#7f0055; font-weight:bold; '>in</span> range(0,2,1):<br />
sBinary = str(binary)<br />
firstByte = int(sBinary,2) & int(<span style='color:#2a00ff; '>'11111111'</span>,2)<br />
newBinary = int(sBinary,2) >> 8<br />
binary = motor.d2b(newBinary)<br />
ser.write(chr(firstByte))<br />
<span style='color:#7f0055; font-weight:bold; '>return</span> stepsFloat<br />
</code>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-84560867861665537692010-04-06T22:07:00.000+09:302010-04-06T22:07:26.788+09:30<code class="syntax">
<span class="c">################################################</span>
<span class="c"># Module: motor.py</span>
<span class="c"># Created: 21 April 2009</span>
<span class="c"># Author: Daniel Thompson</span>
<span class="c"># http://danthompsonsblog.blogspot.com/</span>
<span class="c"># Version: 0.2</span>
<span class="c"># License: GPLv3</span>
<span class="c"># http://www.fsf.org/licensing/</span>
<span class="sd">'''Provides a serial connection abstraction layer</span>
<span class="sd">for use with Arduino "MultipleSteppers" sketch.</span>
<span class="sd">'''</span>
<span class="c">################################################</span>
<span class="kn">import</span> <span class="nn">motor</span>
<span class="kn">import</span> <span class="nn">serial</span>
<span class="c">#setup the serial port</span>
<span class="n">usbport</span> <span class="o">=</span> <span class="s">'COM4'</span>
<span class="n">ser</span> <span class="o">=</span> <span class="n">serial</span><span class="o">.</span><span class="n">Serial</span><span class="p">(</span><span class="n">usbport</span><span class="p">,</span> <span class="mi">115200</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="c"># convert a decimal (denary, base 10) integer to a binary string (base 2)</span>
<span class="k">def</span> <span class="nf">d2b</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="sd">'''convert denary integer n to binary string bStr'''</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="s">''</span>
<span class="k">if</span> <span class="n">n</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span> <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="s">"must be a positive integer"</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="s">'0'</span>
<span class="k">while</span> <span class="n">n</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="n">bStr</span>
<span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">>></span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">bStr</span>
<span class="sd">'''Returns the number of bit bytes (eighths) in binary string.</span>
<span class="sd">Always rounds up, never rounds down.'''</span>
<span class="k">def</span> <span class="nf">binaryCount</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
<span class="n">sNumber</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">number</span><span class="p">)</span>
<span class="n">length</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">sNumber</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mf">8.0</span>
<span class="n">numBytesInt</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mi">8</span>
<span class="k">if</span> <span class="n">numBytes</span> <span class="o">></span> <span class="n">numBytesInt</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span>
<span class="sd">'''This function gets the first byte, removes it from the string and</span>
<span class="sd">returns a new value'''</span>
<span class="k">def</span> <span class="nf">shiftLeft</span><span class="p">(</span><span class="n">binary</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">nBinary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="k">print</span> <span class="s">"I took away"</span><span class="p">,</span> <span class="n">firstByte</span>
<span class="k">print</span> <span class="s">"And now I'm left with"</span><span class="p">,</span> <span class="n">nBinary</span>
<span class="k">return</span> <span class="n">nBinary</span>
<span class="c"># Wraps several functions to split</span>
<span class="c"># the "steps" integer into bytes ready for sending</span>
<span class="c"># Then it write packet header (255) and then</span>
<span class="c"># all the other bytes</span>
<span class="sd">'''The final move command. I combines all the other functions in this</span>
<span class="sd">module to move the motor to the specified position'''</span>
<span class="k">def</span> <span class="nf">position</span><span class="p">(</span><span class="n">num</span><span class="p">,</span><span class="n">degsPerStepFloat</span><span class="p">,</span><span class="n">stepsFloat</span><span class="p">):</span>
<span class="n">steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">stepsFloat</span> <span class="o">/</span> <span class="n">degsPerStepFloat</span><span class="p">)</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o"><</span> <span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">></span> <span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">steps</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">255</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">></span> <span class="o">-</span><span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o"><</span> <span class="mi">0</span><span class="p">):</span>
<span class="n">stepsNeg</span> <span class="o">=</span> <span class="n">steps</span> <span class="o">*</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">stepsNeg</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">220</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">return</span> <span class="n">stepsFloat</span>
</code>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-72663702116792548532010-04-06T21:40:00.010+09:302010-04-06T22:04:51.693+09:30hooray!<code class="syntax"><br />
<div class="highlight"><pre><span class="c">################################################</span>
<span class="c"># Module: motor.py</span>
<span class="c"># Created: 21 April 2009</span>
<span class="c"># Author: Daniel Thompson</span>
<span class="c"># http://danthompsonsblog.blogspot.com/</span>
<span class="c"># Version: 0.2</span>
<span class="c"># License: GPLv3</span>
<span class="c"># http://www.fsf.org/licensing/</span>
<span class="sd">'''Provides a serial connection abstraction layer</span>
<span class="sd">for use with Arduino "MultipleSteppers" sketch.</span>
<span class="sd">'''</span>
<span class="c">################################################</span>
<span class="kn">import</span> <span class="nn">motor</span>
<span class="kn">import</span> <span class="nn">serial</span>
<span class="c">#setup the serial port</span>
<span class="n">usbport</span> <span class="o">=</span> <span class="s">'COM4'</span>
<span class="n">ser</span> <span class="o">=</span> <span class="n">serial</span><span class="o">.</span><span class="n">Serial</span><span class="p">(</span><span class="n">usbport</span><span class="p">,</span> <span class="mi">115200</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="c"># convert a decimal (denary, base 10) integer to a binary string (base 2)</span>
<span class="k">def</span> <span class="nf">d2b</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="sd">'''convert denary integer n to binary string bStr'''</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="s">''</span>
<span class="k">if</span> <span class="n">n</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span> <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="s">"must be a positive integer"</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="s">'0'</span>
<span class="k">while</span> <span class="n">n</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="n">bStr</span>
<span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">>></span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">bStr</span>
<span class="sd">'''Returns the number of bit bytes (eighths) in binary string.</span>
<span class="sd">Always rounds up, never rounds down.'''</span>
<span class="k">def</span> <span class="nf">binaryCount</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
<span class="n">sNumber</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">number</span><span class="p">)</span>
<span class="n">length</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">sNumber</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mf">8.0</span>
<span class="n">numBytesInt</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mi">8</span>
<span class="k">if</span> <span class="n">numBytes</span> <span class="o">></span> <span class="n">numBytesInt</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span>
<span class="sd">'''This function gets the first byte, removes it from the string and</span>
<span class="sd">returns a new value'''</span>
<span class="k">def</span> <span class="nf">shiftLeft</span><span class="p">(</span><span class="n">binary</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">nBinary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="k">print</span> <span class="s">"I took away"</span><span class="p">,</span> <span class="n">firstByte</span>
<span class="k">print</span> <span class="s">"And now I'm left with"</span><span class="p">,</span> <span class="n">nBinary</span>
<span class="k">return</span> <span class="n">nBinary</span>
<span class="c"># Wraps several functions to split</span>
<span class="c"># the "steps" integer into bytes ready for sending</span>
<span class="c"># Then it write packet header (255) and then</span>
<span class="c"># all the other bytes</span>
<span class="sd">'''The final move command. I combines all the other functions in this</span>
<span class="sd">module to move the motor to the specified position'''</span>
<span class="k">def</span> <span class="nf">position</span><span class="p">(</span><span class="n">num</span><span class="p">,</span><span class="n">degsPerStepFloat</span><span class="p">,</span><span class="n">stepsFloat</span><span class="p">):</span>
<span class="n">steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">stepsFloat</span> <span class="o">/</span> <span class="n">degsPerStepFloat</span><span class="p">)</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o"><</span> <span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">></span> <span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">steps</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">255</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">></span> <span class="o">-</span><span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o"><</span> <span class="mi">0</span><span class="p">):</span>
<span class="n">stepsNeg</span> <span class="o">=</span> <span class="n">steps</span> <span class="o">*</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">stepsNeg</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">220</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">return</span> <span class="n">stepsFloat</span>
</pre></div></code>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-67312608625575257572010-04-06T21:36:00.048+09:302010-04-06T23:10:56.898+09:30Arduino<code class="syntax">
<span class="c">################################################</span>
<span class="c"># Module: motor.py</span>
<span class="c"># Created: 21 April 2009</span>
<span class="c"># Author: Daniel Thompson</span>
<span class="c"># http://danthompsonsblog.blogspot.com/</span>
<span class="c"># Version: 0.2</span>
<span class="c"># License: GPLv3</span>
<span class="c"># http://www.fsf.org/licensing/</span>
<span class="sd">'''Provides a serial connection abstraction layer</span>
<span class="sd">for use with Arduino "MultipleSteppers" sketch.</span>
<span class="sd">'''</span>
<span class="c">################################################</span>
<span class="kn">import</span> <span class="nn">motor</span>
<span class="kn">import</span> <span class="nn">serial</span>
<span class="c">#setup the serial port</span>
<span class="n">usbport</span> <span class="o">=</span> <span class="s">'COM4'</span>
<span class="n">ser</span> <span class="o">=</span> <span class="n">serial</span><span class="o">.</span><span class="n">Serial</span><span class="p">(</span><span class="n">usbport</span><span class="p">,</span> <span class="mi">115200</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="c"># convert a decimal (denary, base 10) integer to a binary string (base 2)</span>
<span class="k">def</span> <span class="nf">d2b</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="sd">'''convert denary integer n to binary string bStr'''</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="s">''</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="s">"must be a positive integer"</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="s">'0'</span>
<span class="k">while</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="n">bStr</span>
<span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">&gt;&gt;</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">bStr</span>
<span class="sd">'''Returns the number of bit bytes (eighths) in binary string.</span>
<span class="sd">Always rounds up, never rounds down.'''</span>
<span class="k">def</span> <span class="nf">binaryCount</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
<span class="n">sNumber</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">number</span><span class="p">)</span>
<span class="n">length</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">sNumber</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mf">8.0</span>
<span class="n">numBytesInt</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mi">8</span>
<span class="k">if</span> <span class="n">numBytes</span> <span class="o">&gt;</span> <span class="n">numBytesInt</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span>
<span class="sd">'''This function gets the first byte, removes it from the string and</span>
<span class="sd">returns a new value'''</span>
<span class="k">def</span> <span class="nf">shiftLeft</span><span class="p">(</span><span class="n">binary</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="mi">8</span>
<span class="n">nBinary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="k">print</span> <span class="s">"I took away"</span><span class="p">,</span> <span class="n">firstByte</span>
<span class="k">print</span> <span class="s">"And now I'm left with"</span><span class="p">,</span> <span class="n">nBinary</span>
<span class="k">return</span> <span class="n">nBinary</span>
<span class="c"># Wraps several functions to split</span>
<span class="c"># the "steps" integer into bytes ready for sending</span>
<span class="c"># Then it write packet header (255) and then</span>
<span class="c"># all the other bytes</span>
<span class="sd">'''The final move command. I combines all the other functions in this</span>
<span class="sd">module to move the motor to the specified position'''</span>
<span class="k">def</span> <span class="nf">position</span><span class="p">(</span><span class="n">num</span><span class="p">,</span><span class="n">degsPerStepFloat</span><span class="p">,</span><span class="n">stepsFloat</span><span class="p">):</span>
<span class="n">steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">stepsFloat</span> <span class="o">/</span> <span class="n">degsPerStepFloat</span><span class="p">)</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">&lt;</span> <span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">steps</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">255</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">):</span>
<span class="n">stepsNeg</span> <span class="o">=</span> <span class="n">steps</span> <span class="o">*</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">stepsNeg</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">220</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">return</span> <span class="n">stepsFloat</span>
</code>
Arduino Code
<code class="syntax"><span class="c">################################################</span>
<span class="c"># Module: motor.py</span>
<span class="c"># Created: 21 April 2009</span>
<span class="c"># Author: Daniel Thompson</span>
<span class="c"># http://danthompsonsblog.blogspot.com/</span>
<span class="c"># Version: 0.2</span>
<span class="c"># License: GPLv3</span>
<span class="c"># http://www.fsf.org/licensing/</span>
<span class="sd">'''Provides a serial connection abstraction layer</span>
<span class="sd">for use with Arduino "MultipleSteppers" sketch.</span>
<span class="sd">'''</span>
<span class="c">################################################</span>
<span class="kn">import</span> <span class="nn">motor</span>
<span class="kn">import</span> <span class="nn">serial</span>
<span class="c">#setup the serial port</span>
<span class="n">usbport</span> <span class="o">=</span> <span class="s">'COM4'</span>
<span class="n">ser</span> <span class="o">=</span> <span class="n">serial</span><span class="o">.</span><span class="n">Serial</span><span class="p">(</span><span class="n">usbport</span><span class="p">,</span> <span class="mi">115200</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="c"># convert a decimal (denary, base 10) integer to a binary string (base 2)</span>
<span class="k">def</span> <span class="nf">d2b</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="sd">'''convert denary integer n to binary string bStr'''</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="s">''</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">:</span> <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="s">"must be a positive integer"</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="s">'0'</span>
<span class="k">while</span> <span class="n">n</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">:</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="n">bStr</span>
<span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">&gt;&gt;</span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">bStr</span>
<span class="sd">'''Returns the number of bit bytes (eighths) in binary string.</span>
<span class="sd">Always rounds up, never rounds down.'''</span>
<span class="k">def</span> <span class="nf">binaryCount</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
<span class="n">sNumber</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">number</span><span class="p">)</span>
<span class="n">length</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">sNumber</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mf">8.0</span>
<span class="n">numBytesInt</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mi">8</span>
<span class="k">if</span> <span class="n">numBytes</span> <span class="o">&gt;</span> <span class="n">numBytesInt</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span>
<span class="sd">'''This function gets the first byte, removes it from the string and</span>
<span class="sd">returns a new value'''</span>
<span class="k">def</span> <span class="nf">shiftLeft</span><span class="p">(</span><span class="n">binary</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="mi">8</span>
<span class="n">nBinary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="k">print</span> <span class="s">"I took away"</span><span class="p">,</span> <span class="n">firstByte</span>
<span class="k">print</span> <span class="s">"And now I'm left with"</span><span class="p">,</span> <span class="n">nBinary</span>
<span class="k">return</span> <span class="n">nBinary</span>
<span class="c"># Wraps several functions to split</span>
<span class="c"># the "steps" integer into bytes ready for sending</span>
<span class="c"># Then it write packet header (255) and then</span>
<span class="c"># all the other bytes</span>
<span class="sd">'''The final move command. I combines all the other functions in this</span>
<span class="sd">module to move the motor to the specified position'''</span>
<span class="k">def</span> <span class="nf">position</span><span class="p">(</span><span class="n">num</span><span class="p">,</span><span class="n">degsPerStepFloat</span><span class="p">,</span><span class="n">stepsFloat</span><span class="p">):</span>
<span class="n">steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">stepsFloat</span> <span class="o">/</span> <span class="n">degsPerStepFloat</span><span class="p">)</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">&lt;</span> <span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">steps</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">255</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">&gt;</span> <span class="o">-</span><span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">):</span>
<span class="n">stepsNeg</span> <span class="o">=</span> <span class="n">steps</span> <span class="o">*</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">stepsNeg</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">220</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&amp;</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&gt;&gt;</span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">return</span> <span class="n">stepsFloat</span>
</code>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-3569852950907907462010-04-06T20:08:00.030+09:302010-04-06T21:52:41.215+09:30fixed??<code class="arduino">
<table class="highlighttable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89</pre></div></td><td class="code"><div class="highlight"><pre><span class="c">################################################</span>
<span class="c"># Module: motor.py</span>
<span class="c"># Created: 21 April 2009</span>
<span class="c"># Author: Daniel Thompson</span>
<span class="c"># http://danthompsonsblog.blogspot.com/</span>
<span class="c"># Version: 0.2</span>
<span class="c"># License: GPLv3</span>
<span class="c"># http://www.fsf.org/licensing/</span>
<span class="sd">'''Provides a serial connection abstraction layer</span>
<span class="sd">for use with Arduino "MultipleSteppers" sketch.</span>
<span class="sd">'''</span>
<span class="c">################################################</span>
<span class="kn">import</span> <span class="nn">motor</span>
<span class="kn">import</span> <span class="nn">serial</span>
<span class="c">#setup the serial port</span>
<span class="n">usbport</span> <span class="o">=</span> <span class="s">'COM4'</span>
<span class="n">ser</span> <span class="o">=</span> <span class="n">serial</span><span class="o">.</span><span class="n">Serial</span><span class="p">(</span><span class="n">usbport</span><span class="p">,</span> <span class="mi">115200</span><span class="p">,</span> <span class="n">timeout</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
<span class="c"># convert a decimal (denary, base 10) integer to a binary string (base 2)</span>
<span class="k">def</span> <span class="nf">d2b</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="sd">'''convert denary integer n to binary string bStr'''</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="s">''</span>
<span class="k">if</span> <span class="n">n</span> <span class="o"><</span> <span class="mi">0</span><span class="p">:</span> <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">,</span> <span class="s">"must be a positive integer"</span>
<span class="k">if</span> <span class="n">n</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
<span class="k">return</span> <span class="s">'0'</span>
<span class="k">while</span> <span class="n">n</span> <span class="o">></span> <span class="mi">0</span><span class="p">:</span>
<span class="n">bStr</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">n</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="n">bStr</span>
<span class="n">n</span> <span class="o">=</span> <span class="n">n</span> <span class="o">>></span> <span class="mi">1</span>
<span class="k">return</span> <span class="n">bStr</span>
<span class="sd">'''Returns the number of bit bytes (eighths) in binary string.</span>
<span class="sd">Always rounds up, never rounds down.'''</span>
<span class="k">def</span> <span class="nf">binaryCount</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
<span class="n">sNumber</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">number</span><span class="p">)</span>
<span class="n">length</span> <span class="o">=</span> <span class="nb">len</span><span class="p">(</span><span class="n">sNumber</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mf">8.0</span>
<span class="n">numBytesInt</span> <span class="o">=</span> <span class="n">length</span> <span class="o">/</span> <span class="mi">8</span>
<span class="k">if</span> <span class="n">numBytes</span> <span class="o">></span> <span class="n">numBytesInt</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span> <span class="o">+</span> <span class="mi">1</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">return</span> <span class="n">numBytesInt</span>
<span class="sd">'''This function gets the first byte, removes it from the string and</span>
<span class="sd">returns a new value'''</span>
<span class="k">def</span> <span class="nf">shiftLeft</span><span class="p">(</span><span class="n">binary</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">nBinary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="k">print</span> <span class="s">"I took away"</span><span class="p">,</span> <span class="n">firstByte</span>
<span class="k">print</span> <span class="s">"And now I'm left with"</span><span class="p">,</span> <span class="n">nBinary</span>
<span class="k">return</span> <span class="n">nBinary</span>
<span class="c"># Wraps several functions to split</span>
<span class="c"># the "steps" integer into bytes ready for sending</span>
<span class="c"># Then it write packet header (255) and then</span>
<span class="c"># all the other bytes</span>
<span class="sd">'''The final move command. I combines all the other functions in this</span>
<span class="sd">module to move the motor to the specified position'''</span>
<span class="k">def</span> <span class="nf">position</span><span class="p">(</span><span class="n">num</span><span class="p">,</span><span class="n">degsPerStepFloat</span><span class="p">,</span><span class="n">stepsFloat</span><span class="p">):</span>
<span class="n">steps</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">stepsFloat</span> <span class="o">/</span> <span class="n">degsPerStepFloat</span><span class="p">)</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o"><</span> <span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o">></span> <span class="o">-</span><span class="mi">1</span><span class="p">):</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">steps</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">255</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span
class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">if</span><span class="p">(</span><span class="n">steps</span> <span class="o">></span> <span class="o">-</span><span class="mi">65535</span> <span class="ow">and</span> <span class="n">steps</span> <span class="o"><</span> <span class="mi">0</span><span class="p">):</span>
<span class="n">stepsNeg</span> <span class="o">=</span> <span class="n">steps</span> <span class="o">*</span> <span class="o">-</span><span class="mi">1</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">stepsNeg</span><span class="p">)</span>
<span class="n">numBytes</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">binaryCount</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="c"># from the shiftLef def</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="mi">220</span><span class="p">))</span>
<span class="c"># note: the 2 in (0,2,1) is critical for alowing two bytes through every time.</span>
<span class="k">for</span> <span class="n">i</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">):</span>
<span class="n">sBinary</span> <span class="o">=</span> <span class="nb">str</span><span class="p">(</span><span class="n">binary</span><span class="p">)</span>
<span class="n">firstByte</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">&</span> <span class="nb">int</span><span class="p">(</span><span class="s">'11111111'</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span>
<span class="n">newBinary</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">sBinary</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span> <span class="o">>></span> <span class="mi">8</span>
<span class="n">binary</span> <span class="o">=</span> <span class="n">motor</span><span class="o">.</span><span class="n">d2b</span><span class="p">(</span><span class="n">newBinary</span><span class="p">)</span>
<span class="n">ser</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="nb">chr</span><span class="p">(</span><span class="n">firstByte</span><span class="p">))</span>
<span class="k">return</span> <span class="n">stepsFloat</span>
</pre></div>
</td></tr></table>
</code>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-9864613655843089852010-04-05T21:25:00.031+09:302010-04-06T19:58:01.023+09:30tester<code class="syntax"><span class="c">#!/usr/bin/env python</span><br />
<br />
<span class="k">import</span> <span class="nn">sys</span><br />
<span class="k">import</span> <span class="nn">traceback</span><br />
<span class="k">import</span> <span class="nn">utils</span><br />
<span class="k">from</span> <span class="nn">bin.server</span> <span class="k">import</span> <span class="n">LearndServer</span><br />
<br />
<span class="k">if</span> <span class="n">__name__</span> <span class="o">==</span> <span class="s">'__main__'</span><span class="p">:</span><br />
<span class="n">learnd</span> <span class="o">=</span> <span class="n">LearndServer</span><span class="p">(</span> <span class="p">)</span><br />
<br />
<span class="k">try</span><span class="p">:</span><br />
<span class="n">learnd</span><span class="o">.</span><span class="n">run</span><span class="p">()</span><br />
<span class="k">except</span> <span class="ne">KeyboardInterrupt</span><span class="p">:</span><br />
<span class="n">utils</span><span class="o">.</span><span class="kp">log</span><span class="p">(</span><span class="s">"KeyboardInterrupt - Exiting."</span><span class="p">)</span><br />
<br />
<span class="n">learnd</span><span class="o">.</span><span class="n">close</span><span class="p">()</span><br />
<span class="k">except</span><span class="p">:</span><br />
<span class="n">traceback</span><span class="o">.</span><span class="n">print_exc</span><span class="p">()</span><br />
<span class="n">utils</span><span class="o">.</span><span class="kp">log</span><span class="p">(</span><span class="s">"Exiting."</span><span class="p">)</span><br />
<br />
<span class="n">learnd</span><span class="o">.</span><span class="n">close</span><span class="p">()</span></code>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com1tag:blogger.com,1999:blog-2179756264375199748.post-13151517371874161222009-08-15T21:02:00.000+09:302009-08-15T23:11:00.188+09:30Simple Viewer!Testing the Simple Viewer with Blogger. It works a treat thanks to this great <a href="http://iphotowalker.blogspot.com/2008/06/tutorial-simpleviewer-in-blogger-post.html?showComment=1250339499833#c3806588011140833165">tutorial</a>!
<object height="600" width="600"><param name="Movie" value="http://dl.getdropbox.com/u/1750722/viewer.swf"><param name="Flashvars" value="xmlDataPath=http://dl.getdropbox.com/u/1750722/gallery.xml"><param name="bgcolor" value="#181818"><embed src="http://dl.getdropbox.com/u/1750722/viewer.swf" flashvars="xmlDataPath=http://dl.getdropbox.com/u/1750722/gallery.xml" type="application/x-shockwave-flash" bgcolor="#0a0a0a" height="600" width="600"></embed></object>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-68122793582912729042009-08-13T21:49:00.000+09:302009-08-13T22:06:50.817+09:30Slide ShowTest (another one!)<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" codebase="http://download.macromedia.com/pub/shockwave/cabs/flash/swflash.cab#version=9,0,45,0" width="150" height="150">
<param name="movie" value="http://sites.google.com/site/danthompsonsite/home/Pic1.swf?attredirects=0">
<param name="quality" value="high">
<param name="menu" value="false">
<embed src="http://sites.google.com/site/danthompsonsite/home/Pic1.swf?attredirects=0" quality="high" pluginspage="http://www.macromedia.com/go/getflashplayer" type="application/x-shockwave-flash" width="600" height="450"></embed>
</object>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-21664822791971883312009-08-08T15:32:00.000+09:302009-08-08T15:34:20.368+09:30FEGGER<div style="margin: 0px auto 10px; text-align: center;"><a href="http://2.bp.blogspot.com/_POxG6aoXG3o/Sn0U4CUO4LI/AAAAAAAAAYU/jdp7ZPZSgOw/s1600-h/frankenegger_v001.jpg"><img alt="" src="http://2.bp.blogspot.com/_POxG6aoXG3o/Sn0U4CUO4LI/AAAAAAAAAYU/jdp7ZPZSgOw/s320/frankenegger_v001.jpg" border="0" /></a> </div><div style="clear: both; text-align: center;"><a href="http://picasa.google.com/blogger/" target="ext">
</a></div>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-85124900560836888542009-08-08T11:38:00.001+09:302009-08-08T15:13:14.879+09:30new slide show!<embed type="application/x-shockwave-flash" src="http://picasaweb.google.com/s/c/bin/slideshow.swf" flashvars="host=picasaweb.google.com&hl=en_US&feat=flashalbum&RGB=0x000000&feed=http%3A%2F%2Fpicasaweb.google.com%2Fdata%2Ffeed%2Fapi%2Fuser%2Ffrankenegger%2Falbumid%2F5367404050760148657%3Falt%3Drss%26kind%3Dphoto%26authkey%3DGv1sRgCJ_qocmVjtKKWQ%26hl%3Den_US" pluginspage="http://www.macromedia.com/go/getflashplayer" width="600" height="400"></embed>
<a href="http://picasaweb.google.com/frankenegger/Dorkbot_Talk?authkey=Gv1sRgCJ_qocmVjtKKWQ#slideshow/5367405601153097506">see the real deal!</a>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-66710298714192095362009-08-08T11:36:00.000+09:302009-08-08T15:29:20.092+09:30Adelaide CBD sunsetuploaded using picasa!Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-92180170819329739042009-07-18T22:22:00.000+09:302009-07-18T22:26:11.090+09:30In case you are wondering....This site is a test site for my real blog, <a href="http://danthompsonsblog.blogspot.com/">THE LONG WAY HOME</a> . I'm mainly using this blog to test templates before I roll them out in the my real blog.
Check <a href="http://bloggerstop.net/2009/01/multi-level-drop-down-menu-in.html">this link</a> to see how I did the menus on this page.
Enjoy!Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-39852843444764964102009-07-18T11:23:00.001+09:302009-07-18T11:23:56.005+09:30My Second Post Yeah!Hope this works!Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0tag:blogger.com,1999:blog-2179756264375199748.post-2833733211373236272009-07-18T10:38:00.001+09:302009-08-08T10:53:52.196+09:30First PostBlah!
<embed type="application/x-shockwave-flash" src="http://picasaweb.google.com/s/c/bin/slideshow.swf" width="400" height="267" flashvars="host=picasaweb.google.com&hl=en_US&feat=flashalbum&RGB=0x000000&feed=http%3A%2F%2Fpicasaweb.google.com%2Fdata%2Ffeed%2Fapi%2Fuser%2Ffrankenegger%2Falbumid%2F5184864994194630929%3Falt%3Drss%26kind%3Dphoto%26authkey%3DGv1sRgCM-Ml8Xv89eZnQE%26hl%3Den_US" pluginspage="http://www.macromedia.com/go/getflashplayer"></embed>
<table style="width:auto;"><tr><td><a href="http://picasaweb.google.com/lh/photo/hJWTN4owwB9ze4hNOpkFCQ?authkey=Gv1sRgCM-Ml8Xv89eZnQE&feat=embedwebsite"><img src="http://lh3.ggpht.com/_POxG6aoXG3o/R_TSTttUKfI/AAAAAAAAACM/qu_hG3BxETg/s144/OHNO.jpg" /></a></td></tr><tr><td style="font-family:arial,sans-serif; font-size:11px; text-align:right">From <a href="http://picasaweb.google.com/frankenegger/DanThompson?authkey=Gv1sRgCM-Ml8Xv89eZnQE&feat=embedwebsite">Dan Thompson</a></td></tr></table>Dan Thompsonhttp://www.blogger.com/profile/09932336949749833460noreply@blogger.com0