Blowing Through Lines

/**
 * Code is a mix of ps2mouse from the Arduino playground
 * and mousewheel code from "a world in dk" modified to
 * work with Arduino Decimilia and 0017, and run a PS2
 * Microsoft Intellimouse.
 * 
 * Collin Reidorf collin@paperclipped.com 
 * Repaired http://blowingthroughlines.com
 
 */
 
/*
 * an arduino sketch to interface with a ps/2 mouse.
 * Also uses serial protocol to talk back to the host
 * and report what it finds.
 */
 
/*
 * Pin 5 is the mouse data pin, pin 6 is the clock pin
 * Feel free to use whatever pins are convenient.
 */
#define MDATA 5
#define MCLK 6
 
/*
 * according to some code I saw, these functions will
 * correctly set the mouse clock and data pins for
 * various conditions.
 */
void gohi(int pin)
{
	pinMode(pin, INPUT);
	digitalWrite(pin, HIGH);
}
 
void golo(int pin)
{
	pinMode(pin, OUTPUT);
	digitalWrite(pin, LOW);
}
 
/* PRECONDITION : clock is HIGH */
/* sends a single bit and returns with clock high */
void sendBit(char bit)
{
	if (bit) {
		gohi(MDATA);
	} 
	else {
		golo(MDATA);
	}
	/* wait for clock cycle */
	while (digitalRead(MCLK) == LOW)
		;
	while (digitalRead(MCLK) == HIGH)
		;
}
 
/* reads a single bit and returns with clock low */
char readBit()
{
	char tmp = 0x00;
	while (digitalRead(MCLK) == HIGH)
		;
	if (digitalRead(MDATA) == HIGH) 
		tmp = 0x01;
 
	while (digitalRead(MCLK) == LOW)
		;
 
	return tmp;
}
 
void mouse_write(char data)
{
	char i;
	char parity = 1;
 
	/* put pins in output mode */
	gohi(MDATA);
	gohi(MCLK);
	delayMicroseconds(300);
	golo(MCLK);
	delayMicroseconds(300);
	golo(MDATA);
	delayMicroseconds(10);
	/* start bit */
	gohi(MCLK);
	/* wait for mouse to take control of clock); */
	sendBit(0);
 
	/* clock is low, and we are clear to send data */
	for (i=0; i < 8; i++) {
 
		sendBit(data & 0x01);
 
		parity = parity ^ (data & 0x01); // might not need this anymore but too lazy to test...
 
		data = data >> 1;
	}  
	/* parity */
	sendBit(parity);
 
	/* stop bit */
	sendBit(1);
 
	/* wait for mouse to switch modes */
	while ((digitalRead(MCLK) == LOW) || (digitalRead(MDATA) == LOW))
		;
	/* put a hold on the incoming data. */
	golo(MCLK);
}
 
/*
 * Get a byte of data from the mouse
 */
char mouse_read(void)
{
	char data = 0x00;
	int i;
	char bit = 0x01;
 
	//	Serial.print("reading byte from mouse\n");
	/* start the clock */
	gohi(MCLK);
	gohi(MDATA);
	delayMicroseconds(50);
	readBit();
 
	// delayMicroseconds(5);  /* not sure why */ // and not evidently needed
 
	for (i=0; i < 8; i++) { // read the bits
		data = data | (readBit()<<i);
	}
 
	/* eat parity bit, which we ignore */
	readBit();
 
	/* eat stop bit */
	readBit(); 
 
	/* put a hold on the incoming data. */
	golo(MCLK);
 
	return data;
}
 
// for the mousewheel
// #define verbose // for verbose output
unsigned char msInitSequence[7]; // should go up on top when ready
 
char writeAndGetResponse(char data) {
	// #ifdef verbose
		// Serial.print("sending :	 ");
		// Serial.print((unsigned char)data, HEX);
		// Serial.print("\t");
	// #endif	
 
	mouse_write( data );
	return response();
}
 
char response() {
	char data = mouse_read();
	// #ifdef verbose
		// Serial.print("echo ");
		// Serial.print((unsigned char)data, HEX);
		// Serial.print(" from mouse\n");
	// #endif
	return data;
}
// 
void msMode() {
	// sequence for ms mode (3 button + scroll)
	// this is a entering procedure and i guess it will
	// work with other mice/ICs as its problably stadard ps2
	// And using an array were just a quick way to handle them
	msInitSequence[0] =0xF3;
	msInitSequence[1] =0xC8;
	msInitSequence[2] =0xF3;
	msInitSequence[3] =0x64;
	msInitSequence[4] =0xF3;
	msInitSequence[5] =0x50;
	msInitSequence[6] =0xF2;
 
 
	int i;
	for(i=0;i<7;i++) 
		writeAndGetResponse(msInitSequence[i]);
}
 
// end of mousewheel stuff
 
 
void showMStat(char mstat)
{
	int i;
	char bit = 0x01;
	for(i = 0; i<8; i++)
	{
		if(mstat&bit)
		{
			Serial.print("\t");
			switch(i)
			{
				case 0:
					Serial.print("L");
					break;
				case 1:
					Serial.print("R");
					break;
				case 2:
					Serial.print("M");
					break;
				case 3:
					// Serial.print(" Reserve ...\t");
					break;
				case 4:
					// Serial.print(" X data negative \t");
					break;
				case 5:
					// Serial.print("Y data negative \t");
					break;
				case 6:
					Serial.print("X data overflow");
					break;
				case 7:
					Serial.print("Y data overflow");
					break;
			}
		}
		bit = bit<<1;
	} 
}
 
void mouse_init()
{
	gohi(MCLK);
	gohi(MDATA);
	//	Serial.print("Sending reset to mouse\n");
	mouse_write(0xff);
	mouse_read();  /* ack byte */
	//	Serial.print("Read ack byte1\n");
	mouse_read();  /* blank */
	mouse_read();  /* blank */
 
	msMode(); // mousewheel code
 
	//	Serial.print("Sending remote mode code\n");
	mouse_write(0xf0);	/* remote mode */
	mouse_read();  /* ack */
	//	Serial.print("Read ack byte2\n");
 
	delayMicroseconds(100);
}
 
void setup()
{
	Serial.begin(9600);
	mouse_init();
}
 
/*
 * get a reading from the mouse and report it back to the
 * host via the serial line.
 */
void loop()
{
	char mstat;
	char mx;
	char my;
	char mz;
 
	/* get a reading from the mouse */
	writeAndGetResponse(0xEB); /* give me data! */ 
 
	mstat = mouse_read();
	mx = mouse_read();
	my = mouse_read();
	mz = mouse_read();
 
	/* send the data back up */
 
	Serial.print("\tmouse status=");
	Serial.print(mstat, BIN);
	Serial.print("\tX=");
	Serial.print(mx, DEC);
	Serial.print("\tY=");
	Serial.print(my, DEC);
	Serial.print("\tZ=");
	Serial.print(mz, DEC);
	showMStat(mstat); // print buttons that are down
	Serial.println();
	delay(20);	/* twiddle */
}

// some code
function test() {
	flashID.ner("hello"); // BAAAAAAD!
}

// some code
function test() {
	var flashMovie = $('#flashID');
	flashMovie.ner("hello"); // ALSO BAAAAAAD!
}

function test() {
	var flashMovie = document.getElementByID("flashID");
	flashMovie.ner("hello"); // FINALLY! It worked.
}

package com.paperclipped.physics
{
	import Box2D.Collision.b2AABB;
	import Box2D.Common.Math.b2Vec2;
	import Box2D.Dynamics.b2DebugDraw;
	import Box2D.Dynamics.b2World;
 
	import flash.display.Sprite;
 
	/**
	 * This is a container class to make the creation of Box2D World simpler.
	 * Box2D r47 or greater required.
	 * (c) 2009 Collin Reisdorf MIT License
	 * 
	 * @author Collin Reisodrf
	 */	
	public class World
	{
//-----------------------------------------Variables-----------------------------------------//
		private var _scale:Number;
		private var _world:b2World;
//-------------------------------------------------------------------------------------------//
 
//------------------------------------------Getters------------------------------------------//
		/**
		 * @return Scale set by the user when the world is constructed.
		 */				
		public function get scale():Number		{ return _scale;	}
		/**
		 * @return The world object made by the constructor.
		 */		
		public function get world():b2World		{ return _world;	}
//-------------------------------------------------------------------------------------------//
 
//----------------------------------------Constructor----------------------------------------//		
		public function World(width:uint, height:uint, debugSprite:Sprite=null, showCenterOfMass:Boolean=false, gravity:b2Vec2=null, scale:Number=30, padding:uint=1000, doSleep:Boolean=true)
		{
			var worldAABB:b2AABB = new b2AABB();
				worldAABB.lowerBound.Set(-padding, -padding);
				worldAABB.upperBound.Set(width+padding, width+padding);
 
			gravity = (gravity)? gravity:new b2Vec2(0, 10.0);
			_world = new b2World(worldAABB, gravity, doSleep);
 
			if(debugSprite)
			{
				var	debugDraw:b2DebugDraw = new b2DebugDraw();
					debugDraw.SetSprite(debugSprite);
					debugDraw.SetDrawScale(scale);
					debugDraw.SetFillAlpha(0.3);
					debugDraw.SetLineThickness(1.0);
					debugDraw.SetFlags(b2DebugDraw.e_shapeBit | b2DebugDraw.e_jointBit | uint((showCenterOfMass)? b2DebugDraw.e_centerOfMassBit:0));
				_world.SetDebugDraw(debugDraw);
			}
		}
//-------------------------------------------------------------------------------------------//
 
//--------------------------------------Private Methods--------------------------------------//
//-------------------------------------------------------------------------------------------//
 
//--------------------------------------Public  Methods--------------------------------------//
//-------------------------------------------------------------------------------------------//
	}
}

package com.paperclipped.physics
{
	import Box2D.Collision.Shapes.b2PolygonDef;
	import Box2D.Common.Math.b2Vec2;
	import Box2D.Dynamics.Joints.b2Joint;
	import Box2D.Dynamics.Joints.b2RevoluteJointDef;
	import Box2D.Dynamics.b2Body;
	import Box2D.Dynamics.b2BodyDef;
	import Box2D.Dynamics.b2World;
 
	/**
	 * This is a container class to make the creation of a chain simpler
	 * Box2D r47 or greater required.
	 * (c) 2009 Collin Reisdorf MIT License
	 * 
	 * @author Collin Reisodrf
	 */	
	public class Chain
	{
//-----------------------------------------Variables-----------------------------------------//
		public static const HORIZONTAL:String = 'h';
		public static const VERTICAL:String = 'v'; // not supported yet
 
		private var _bodies:Array;
		private var _joints:Array;
//		private var _parent:
		private var _world:b2World;
//-------------------------------------------------------------------------------------------//
 
//------------------------------------------Getters------------------------------------------//
		public function get bodies():Array 	{ return _bodies;								}
		public function get end():b2Body 	{ return _bodies[_bodies.length-1] as b2Body;	}
		public function get joints():Array	{ return _joints;								}
		public function get start():b2Body	{ return _bodies[0] as b2Body;					}
//-------------------------------------------------------------------------------------------//
 
//------------------------------------------Setters------------------------------------------//
//-------------------------------------------------------------------------------------------//
 
//----------------------------------------Constructor----------------------------------------//
		public function Chain(world:b2World, numLinks:uint=3, anchorX:int=0, anchorY:int=0, direction:String="h", swingLimit:uint=0, /*parent=null,*/ scale:uint=30)
		{
			_world = world;
			_bodies = new Array();
			_joints = new Array();
//			_parent = parent; // not sure what/how to attach this to yet...
 
			var ground:b2Body = world.GetGroundBody();
			var i:int;
			var anchor:b2Vec2 = new b2Vec2();
			var body:b2Body;
			var joint:b2Joint;
 
			var sd:b2PolygonDef = new b2PolygonDef();
			sd.SetAsBox(24 / scale, 5 / scale);
			sd.density = 100.0;
			sd.friction = 0.8;
 
			var bd:b2BodyDef = new b2BodyDef();
 
			var jd:b2RevoluteJointDef = new b2RevoluteJointDef();
			if(swingLimit > 0)
			{
				jd.lowerAngle = -swingLimit / (180/Math.PI);
				jd.upperAngle = swingLimit / (180/Math.PI);
				jd.enableLimit = true;
			}else
			{
				jd.enableLimit = false;
			}
 
			var prevBody:b2Body = ground;
			for (i = 0; i < 3; ++i)
			{
//				if(i == 0)
//				{
//				trace("enabled motor damnit");
//					jd.enableMotor = true;
//					jd.motorSpeed = 1;
//					jd.maxMotorTorque = 100;
//				}else
//				{
//					jd.enableMotor = false;
//
//				}
 
				bd.position.Set((anchorX + 22 + 44 * i) / scale, anchorY / scale);
				body = world.CreateBody(bd);
				body.CreateShape(sd);
				body.SetMassFromShapes();
 
				anchor.Set((anchorX + 44 * i) / scale, anchorY / scale);
				jd.Initialize(prevBody, body, anchor);
				joint = world.CreateJoint(jd);
 
				prevBody = body;
				_bodies.push(body);
				_joints.push(joint);
			}
		}
//-------------------------------------------------------------------------------------------//
 
//--------------------------------------Private Methods--------------------------------------//
//-------------------------------------------------------------------------------------------//
 
//--------------------------------------Public  Methods--------------------------------------//
//-------------------------------------------------------------------------------------------//
	}
}

<!--[if gte IE 8]>-->
<script type="text/javascript" src="js/swfaddress.2.3.js"></script>
<!--<![endif>-->