Most of you reading this probably have some of your own methods of evading the tracking and sharing of your browsing habits online. But in case you don't or are interested in checking out an alternative, here's a neat browser tool I found called Do Not Track Plus (DNT+):
http://www.abine.com/dntdetail.php

Basically, it blocks your dumb browsers (Chrome, FF, Safari and IE) from sending your info to third parties. It also tells you how many attempts there were (total and per-site), and breaks them down for you if you're interested. FAQ is here:
http://www.donottrackplus.com/faqs.php

I found some great IPv6 YouTube tutorials that could help people get a handle on this newfandangled way of doing things. I've been running through them and they are pretty easy to follow if you have some background on basic IPv4 networking concepts.

Part one:
http://www.youtube.com/watch?v=rljkNMySmuM

If you are looking for a specific part (there are 7 as far as I know), you can search "ipv6-0x" on YouTube where x is 1-7.
Pretty interesting protocol if you ask me.

http://www.cnn.com/2010/TECH/mobile/10/13/apple.sexting.patent/index.html

"Grammarians may cheer this innovation. The texting interface also could prod kids toward better grammar, requiring them to identify and fix spelling, punctuation and grammar mistakes before sending a message."

We need.

I'm a part of a scholarship group run by the dean of enrollment services for my university. At our last meeting the dean gave us a piece of paper entitled "One Word Project". We had until August 1st to complete it. Here it is August 2nd (technically) and I am about to dive in.

I thought bringing this to Teh Geekery could result in some hilarity, so here it is:

"
Reflect on your life, what you love, what you do, what you want the world to know about you. The key is to find one word and one word only that best captivates YOU. Find the deeper meaning behind your hobbies, interests, and studies. Vince likes to eat: his word is "YUMYUMYUMYUM." Shanice tries daily to speak out and get her voice heard: her word is "Activism." Ailsa constantly dreams of what is to come: her word is "Dreamer." Andrew has grown up with computers all his life and continues to work with them today: his word is "4E65726479."

"

Feel free to post your one word here. You can also post a small explanation of why you chose that word. As far as taking it seriously, it's your choice. Personally, I am going to use this opportunity to make it clear that I hate doing this kind of crap.

Try and pick one word without changing it later.

Oh, and I'll post my word later. I'm not sure what it is yet. Also, fuck Andrew. We all know a word is only 16 bits.

Exactly 1500 lines of pure, 8086 microprocessor based assembly code.

-4 Floors, (0=basement, 1=ground)
-7 segment display showing floor and direction of travel
-Queue system that takes in new input at ANY time during the program and queues the destination for later travel
-Uses system time to calculate time between floors (5sec), time for door opening and closing (3sec), and a wait time for the doors. (For instance if they open at your destination and need to close to go to another destination) (3sec).
-Alarm bypass
-1st floor bypass

If you really want to build and run this, it's 16-bit masm. I'll send you my include file if you want it, but you'll need some extra stuff. Don't ask me what.

If you're REALLY interested, maybe I'll host the .exe.

FIFTEEN HUNDRED

[aeva][aeva]TITLE Elevator              (16-bit.asm)

;Elevator Final Project Assembly
;Joey Huggins | v959s342

;Floors setup:
;0 : Basement floor
;1 : Ground floor : Main floor : Starting location
;2 : Floor 2
;3 : Floor 3

;The program uses the system time to calculate the time it takes between floors, time to open / close doors.

INCLUDE Irvine16.inc

.data
ArrayU BYTE 15 DUP (99)
ArrayD BYTE 15 DUP (99)
BypassV BYTE 0
AlarmV BYTE 0
Counter BYTE 0
TravelCounter BYTE 0
InsideB BYTE 0
OutsideB BYTE 0
Up BYTE 0
Down BYTE 0
Closed BYTE 1
Open BYTE 0
Opening BYTE 0
Closing BYTE 0
Floor BYTE 1
Moving BYTE 0
InvalidV BYTE 0
NextFloor BYTE 0
Difference BYTE 0
ArraySizeU BYTE 0
ArraySizeD BYTE 0
firstChar BYTE ?,0
secondChar BYTE ?,0
msgFloor BYTE 0ah,0dh,"Floor: ",0
msgChanging BYTE 0ah,0dh, "Elevator moving . . .",0
msgOpening BYTE 0ah,0dh,"Doors opening . . .",0
msgClosing BYTE 0ah,0dh,"Doors closing . . .",0
msgOpen BYTE 0ah,0dh, "Doors Open",0
msgClosed BYTE 0ah,0dh, "Doors Closed",0
msgControls BYTE "Controls:",0ah,0dh,0ah,0dh, "Type 0-3 For your current floor (Outside controls) or 'i' for Inside controls",0ah,0dh
 BYTE "If outside: Type Up(u), Down(d), or Bypass(b) on ground floor",0ah,0dh
 BYTE "If inside: Type destination floor 0-3, Close doors(c), Open doors(o) or Alarm(a)",0ah,0dh,0
msgExamples BYTE 0ah,0dh, "Example:", 0ah,0dh, "Typing '1u' means you are on ground floor and want to go up",0ah,0dh
 BYTE "Typing 'i2' means you are in the elevator and want to go to floor 2",0ah,0dh
 BYTE "Typing 'io' means you are on the inside and want the doors open.",0ah,0dh,0
msgTest BYTE 0ah,0dh, "To continue, type the sequence for outside controls on floor 3 going down : ",0
msgInvalid BYTE 0ah,0dh, "Invalid key pressed, please start your control sequence over again",0
msgBypass BYTE 0ah,0dh, "All destinations cleared. Returning to first floor.",0
msgAlarm BYTE 0ah,0dh, "Alarm activated. Returning to first floor and shutting down operation.",0
msgMoving BYTE 0ah,0dh, "Elevator moving. Doors remaining closed.",0
msgClean BYTE 0ah,0dh,0ah,0dh,0
msgSegment1 BYTE "   _",0ah,0dh,0
msgSegment2 BYTE "  |",0
msgSegment3 BYTE "_",0
msgSegment4 BYTE "|",0ah,0dh,0
msgSegment5 BYTE "  |",0
msgSegment6 BYTE "_",0
msgSegment7 BYTE "|",0,0ah,0dh,0
msgSegmentF BYTE " ",0
msgSegmentFR BYTE " ",0ah,0dh,0
msgSegmentFS BYTE "    ",0
msgSegmentFSR BYTE "    ",0ah,0dh,0
msgSegmentFSS BYTE "   ",0


.code
main PROC
mov ax,@data
mov ds,ax

call ClrScr

;;;;;;;;;;;;
;;;;INITIAL : START
;;;;;;;;;;;;


mov edx, OFFSET msgControls
call WriteString
mov edx, OFFSET msgExamples
call WriteString

Initial: ;Ask Cu to try a sequence. This part makes sure the user knows how to
;control the evelator program by asking for a specific action

mov edx, OFFSET msgTest
call WriteString

call ReadChar
mov firstChar, al

cmp al,33h

jz Next
jmp Initial

Next: ;First Character is OK

call ReadChar
mov secondChar, al

cmp al,64h
jz Correct

Correct::
CALL Displayp

DisplayDoneCorrect:

;;;;;;;;;;;;
;;;;INITIAL : END
;;;;;;;;;;;;

mov edi, OFFSET ArrayD ;Check if the queue's are empty
mov esi, OFFSET ArrayU
cmp BYTE PTR [esi], 99 ;99 is the empty value. Because 0 is a valid floor (basement)
jz NextQueue
jmp NotEmpty
NextQueue:
cmp BYTE PTR [edi], 99
jz QueueEmpty
jmp NotEmpty

QueueEmpty:
mov Moving, 0
mov Up, 0
mov Down, 0
CALL DisplayP

DisplayDoneQueueEmpty:

mov ah, 10h
int 16h

inc Counter ;Are we on the first or second entry

cmp OutsideB, 1 ;If OutsideB is 1, the previous key was from the outside controls and we are getting a 'u' or 'd'
jz Outside21 ;Signal (though, it doesn't really matter).
jmp FirstCase1

Outside21:
mov OutsideB, 0
cmp al, 62h
jz Bypass1
jmp BufferDone1 ;It shouldn't make a difference if the person is going up or down. They will actually
;Make the decision based on what they press inside. So we just skip the u or d.
Bypass1:
CALL BypassP
jmp Correct

FirstCase1:

cmp InsideB, 1 ;If InsideB is 1, that means the previous key was 'i' for inside
jz Inside21

cmp al, 69h ;if the key is i
jz Inside1

cmp al, 30h
jz Number1
cmp al, 31h
jz Number1
cmp al, 32h
jz Number1
cmp al, 33h
jz Number1

Invalid1: ;Key doesn't match anything acceptable. So we let the user know and end the buffercheck.
mov InsideB, 0 ;Go ahead and clear buffer
mov ah, 11h
int 16h
mov InvalidV, 1
CALL DisplayP
mov InvalidV, 0
jmp BufferDone1

Number1:
;If outside, grab number and make sure we grab the u or d afterwards
cmp InsideB, 1 ;If i was the last key then the number is coming from the inside.
jnz SetOutsideB1
jz DontSetOutside1

SetOutsideB1: ;If i was not the last key, then the number is on the outside
mov OutsideB, 1 ;And we need to set the outside boolean so we can catch the u or d the next time around when we check the buffer
mov bl, Floor
add bl, 30h
cmp bl, al ;Is the destination above or below current floor. See below for if they are the same
js GoingUp1 ;Destination is above the current floor
jmp GoingDown1 ;Destination is below current floor

DontSetOutside1:
mov InsideB, 0 ;The inside sequence is done, so we can reset the boolean
mov bl, Floor ;Put the current floor in a register to check
add bl, 30h ;Make the floor it's ASCII value
cmp bl, al ;Is the destination higher or lower than the current floor
jz DoCallOpen1 ;You're on the destination floor. Open the doors if they are closed.

js GoingUp1 ;Destination is above the current floor
jmp GoingDown1 ;Destination is below current floor

GoingDown1:
mov NextFloor, al
jmp BufferDone1

GoingUp1:
mov NextFloor, al
jmp BufferDone1

Inside1:
mov InsideB, 1 ;If the user entered i, then we need to know the next entry will be an inside option
jmp BufferDone1

Inside21: ;If the previous key was an i
cmp al, 61h
jz Alarm1
cmp al, 6fh
jz DoCallOpen1
cmp al, 63h
jz DoCallClosed1
cmp al, 30h
jz Number1
cmp al, 31h
jz Number1
cmp al, 32h
jz Number1
cmp al, 33h
jz Number1

jmp Invalid1

DoCallOpen1:
CALL OpenDoors
mov InsideB, 0
mov Counter, 0
jmp Correct

DoCallClosed1:
CALL CloseDoors
mov InsideB, 0
mov Counter, 0
jmp Correct

Alarm1:
CALL AlarmP

BufferDone1:

cmp Counter, 2
jz Move
jmp QueueEmpty

NotEmpty:

mov esi, OFFSET ArrayU
mov edi, OFFSET ArrayD

cmp ArraySizeU, 0
jz EndBubbleSortU
cmp ArraySizeU, 1
jz EndBubbleSortU

;;;;;;;;;;BubbleSort Up

movzx ecx, ArraySizeU
dec ecx

B1:
push ecx

B2:
mov al, BYTE PTR [esi]
cmp BYTE PTR [esi+1],al
jge B3
xchg al, BYTE PTR [esi+1]
mov BYTE PTR [esi],al

B3:
add esi, 1
loop B2

pop ecx
loop B1

EndBubbleSortU:

cmp ArraySizeD, 0
jz EndBubbleSort
cmp ArraySizeD, 1
jz EndBubbleSort

;;;;;;;;;BubbleSort Down

movzx ecx, ArraySizeD
dec ecx

F1:
push ecx

F2:
mov al, BYTE PTR [edi]
cmp BYTE PTR [edi+1],al
jge F3
xchg al,BYTE PTR [edi+1]
mov BYTE PTR [edi],al

F3:
add edi, 1
loop F2

pop ecx
loop F1

EndBubbleSort:;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

mov bl, Up
cmp bl, 1
jz IsThereAnUp
jmp IsThereADown

IsThereAnUp:
mov esi, OFFSET ArrayU
cmp BYTE PTR [esi], 99
jnz MoveUp

IsThereADown:
mov edi, OFFSET ArrayD
cmp BYTE PTR [edi], 99
jnz MoveDown

MoveUp:
mov Up, 1
mov Down, 0
mov esi, OFFSET ArrayU
mov bl, BYTE PTR [esi]
mov NextFloor, bl
mov BYTE PTR [esi], 99 ;Replace element with a 99
mov bl, ArraySizeU
sub bl, 1
mov ArraySizeU, bl
jmp Move

MoveDown:
mov Up, 0
mov Down, 1
mov edi, OFFSET ArrayD

GrabTop:
add edi, 1
cmp BYTE PTR [edi], 99 ;At this point, there should be at least one element in the array so
;We shouldn't have to check for an empty array again
jnz GrabTop
sub edi, 1
mov bl, BYTE PTR [edi] ;If the element we are at is a 99, we need to go back one.
mov NextFloor, bl
mov BYTE PTR [edi], 99 ;Replace element with a 99
mov bl, ArraySizeD
sub bl, 1
mov ArraySizeD, bl
jmp Move

Move::
cmp AlarmV, 1
jz AlarmCalled
CALL DoorWait

mov OutsideB, 0
mov InsideB, 0
mov Counter, 0
cmp Open, 1
jz DoCloseTheDoors
jmp TheyAlreadyDoneDid

DoCloseTheDoors:
CALL CloseDoors
CALL DisplayP


TheyAlreadyDoneDid:
AlarmCalled:

mov bl, BypassV
cmp bl, 1
jz Bypassing
mov bl, AlarmV
cmp bl, 1
jz Alarming
jmp NothingSpecial

Alarming:
CALL CloseDoors
CALL DisplayP

mov NextFloor, 31h
jmp NothingSpecial

Bypassing:
CALL DisplayP

mov NextFloor, 1
jmp NothingSpecial

NothingSpecial:

mov bl, Floor
add bl, 30h
cmp bl, NextFloor
jz CallOpenDoors
js SetUp
jmp SetDown

CallOpenDoors:
CALL OpenDoors
jmp Correct

SetUp:
mov Up, 1
mov Down, 0
mov bl, Floor
add bl, 30h
jmp FindDifferenceU

SetDown:
mov Up, 0
mov Down, 1
mov bl, Floor
add bl, 30h
jmp FindDifferenceD

FindDifferenceU:
mov Up, 1
mov Down, 0
inc Difference
inc bl
cmp bl, NextFloor
jz DirectionFound
jmp FindDifferenceU

FindDifferenceD:
mov Down, 1
mov Up, 0
inc Difference
sub bl, 1
cmp bl, NextFloor
jz DirectionFound
jmp FindDifferenceD

DirectionFound:
mov TravelCounter, 0

TimeBetweenFloors:
mov Moving, 1
Call DisplayP

;;;;;;;;;;;;
;;;;TIME BETWEEN FLOORS : START
;;;;;;;;;;;;

mov ah, 2Ch ;Get time. Seconds are in DH, minutes in CL
int 21h

mov ah, dh ;ah = dh = seconds
mov bl, cl ;bl = cl = minutes

CheckTime: ;Start the checktime 'loop'
push ax ;Push the seconds we initially grabbed

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : START
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 11h ;This is the code for checking the keyboard buffer.
int 16h   ;If the zero flag is set, there is nothing in the buffer
jz BufferDone
;If the zero flag is not set, we can remove the key from the buffer
mov ah, 10h
int 16h

cmp OutsideB, 1 ;If OutsideB is 1, the previous key was from the outside controls and we are getting a 'u' or 'd'
jz Outside2 ;Signal (though, it doesn't really matter).
jmp FirstCase

Outside2:
mov OutsideB, 0
cmp al, 62h
jz Bypass
jmp BufferDone ;It shouldn't make a difference if the person is going up or down. They will actually
;Make the decision based on what they press inside. So we just skip the u or d.
Bypass:
CALL BypassP
jmp Correct

FirstCase:

cmp InsideB, 1 ;If InsideB is 1, that means the previous key was 'i' for inside
jz Inside2

cmp al, 69h ;if the key is i
jz Inside

cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

Invalid: ;Key doesn't match anything acceptable. So we let the user know and end the buffercheck.
mov InsideB, 0 ;Go ahead and clear buffer
mov ah, 11h
int 16h
mov InvalidV, 1
CALL DisplayP
mov InvalidV, 0
jmp BufferDone

Number:
;If outside, grab number and make sure we grab the u or d afterwards
cmp InsideB, 1 ;If i was the last key then the number is coming from the inside.
jnz SetOutsideB
jz DontSetOutside

SetOutsideB: ;If i was not the last key, then the number is on the outside
mov OutsideB, 1 ;And we need to set the outside boolean so we can catch the u or d the next time around when we check the buffer
mov bl, Floor
add bl, 30h
cmp bl, al ;Is the destination above or below current floor. See below for if they are the same
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

DontSetOutside:
mov InsideB, 0 ;The inside sequence is done, so we can reset the boolean
mov bl, Floor ;Put the current floor in a register to check
add bl, 30h ;Make the floor it's ASCII value
cmp bl, al ;Is the destination higher or lower than the current floor (though we're moving)
jz BufferDone ;For now at least, if we just came from the destination floor, then I'm not going
;to add it to the queue. You can add it again when you reach the next floor.
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

GoingDown:
mov edi, OFFSET ArrayD
cmp BYTE PTR [edi], 99
jz LCA
LC: ;esi and edi aren't always going to point to the next open space so we have to find it
add edi, 1
cmp BYTE PTR [edi], 99
jz LCA
jnz LC
LCA:
mov BYTE PTR [edi], al ;edi points to ArrayD
inc ArraySizeD
jmp BufferDone

GoingUp:
mov esi, OFFSET ArrayU
cmp BYTE PTR [esi], 99
jz LC2A
LC2:
add esi, 1
cmp BYTE PTR [esi], 99
jz LC2A
jnz LC2
LC2A:
mov BYTE PTR [esi], al ;esi points to ArrayU
inc ArraySizeU
jmp BufferDone

Inside:
mov InsideB, 1 ;If the user entered i, then we need to know the next entry will be an inside option
jmp BufferDone

Inside2: ;If the previous key was an i
cmp al, 61h
jz Alarm
cmp al, 6fh
jmp BufferDone
cmp al, 63h
jz BufferDone
cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

jmp Invalid

Alarm:
CALL AlarmP

BufferDone:

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : END
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 2Ch ;Get current time (new time)
int 21h

pop ax ;Get back old seconds

sub dh,ah ;New seconds - Old Seconds = difference

js YAdd ;If the subtraction changed the sign flag (rollover), we need to add 60 to the result
jmp NAdd ;Otherwise, go ahead and subtract 5 from the difference to check.

YAdd: ;If there was a rollover, add 60 to the difference
add dh,60

NAdd: ;There was no rollover just continue
sub dh,5 ;Difference - 5

jz Over ;If the difference between the seconds is 5 (5 - 5 = 0), we're done counting
jnz CheckTime ;Otherwise, repeat loop and continue to check the time.

Over:

inc TravelCounter

cmp Up,1
jz IncreaseFloor
jmp DecreaseFloor

IncreaseFloor:
inc Floor
jmp ChangeFloorsDone
DecreaseFloor:
mov bl, Floor
sub bl, 1
mov Floor, bl

ChangeFloorsDone:

mov bl, Difference

cmp bl, TravelCounter
jnz TimeBetweenFloors

;;;;;;;;;;;;
;;;;TIME BETWEEN FLOORS : END
;;;;;;;;;;;;

cmp AlarmV, 1
jz EndItAll

mov bl, NextFloor
sub bl, 30h
mov Floor, bl
mov TravelCounter, 0
mov Difference, 0
mov Moving, 0
CALL OpenDoors
jmp Correct

EndItAll::

CALL DisplayP

exit
main ENDP

OpenDoors PROC
cmp Open, 1
jz DoorsAreOpen
jmp NoTheyAint
DoorsAreOpen:
ret
NoTheyAint:
mov Opening, 1
mov Closing, 0
mov Open, 0
mov Closed, 0
CALL DisplayP

mov ah, 2Ch ;Get time. Seconds are in DH, minutes in CL
int 21h

mov ah, dh ;ah = dh = seconds
mov bl, cl ;bl = cl = minutes

CheckTime: ;Start the checktime 'loop'
push ax ;Push the seconds we initially grabbed

mov bl, AlarmV
cmp bl, 1
jz BufferDone

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : START
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 11h ;This is the code for checking the keyboard buffer.
int 16h   ;If the zero flag is set, there is nothing in the buffer
jz BufferDone
;If the zero flag is not set, we can remove the key from the buffer
mov ah, 10h
int 16h

cmp OutsideB, 1 ;If OutsideB is 1, the previous key was from the outside controls and we are getting a 'u' or 'd'
jz Outside2 ;Signal (though, it doesn't really matter).
jmp FirstCase

Outside2:
mov OutsideB, 0
cmp al, 62h
jz Bypass
jmp BufferDone ;It shouldn't make a difference if the person is going up or down. They will actually
;Make the decision based on what they press inside. So we just skip the u or d.
Bypass:
CALL BypassP
jmp Correct

FirstCase:

cmp InsideB, 1 ;If InsideB is 1, that means the previous key was 'i' for inside
jz Inside2

cmp al, 69h ;if the key is i
jz Inside

cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

Invalid: ;Key doesn't match anything acceptable. So we let the user know and end the buffercheck.
mov InsideB, 0 ;Go ahead and clear buffer
mov ah, 11h
int 16h
mov InvalidV, 1
CALL DisplayP
mov InvalidV, 0
jmp BufferDone

Number:
;If outside, grab number and make sure we grab the u or d afterwards
cmp InsideB, 1 ;If i was the last key then the number is coming from the inside.
jnz SetOutsideB
jz DontSetOutside

SetOutsideB: ;If i was not the last key, then the number is on the outside
mov OutsideB, 1 ;And we need to set the outside boolean so we can catch the u or d the next time around when we check the buffer
mov bl, Floor
add bl, 30h
cmp bl, al ;Is the destination above or below current floor. See below for if they are the same
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

DontSetOutside:
mov InsideB, 0 ;The inside sequence is done, so we can reset the boolean
mov bl, Floor ;Put the current floor in a register to check
add bl, 30h ;Make the floor it's ASCII value
cmp bl, al ;Is the destination higher or lower than the current floor (though we're moving)
jz BufferDone ;For now at least, if we just came from the destination floor, then I'm not going
;to add it to the queue. You can add it again when you reach the next floor.
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

GoingDown:
mov edi, OFFSET ArrayD
cmp BYTE PTR [edi], 99
jz LCA
LC: ;esi and edi aren't always going to point to the next open space so we have to find it
add edi, 1
cmp BYTE PTR [edi], 99
jz LCA
jnz LC
LCA:
mov BYTE PTR [edi], al ;edi points to ArrayD
inc ArraySizeD
jmp BufferDone

GoingUp:
mov esi, OFFSET ArrayU
cmp BYTE PTR [esi], 99
jz LC2A
LC2:
add esi, 1
cmp BYTE PTR [esi], 99
jz LC2A
jnz LC2
LC2A:
mov BYTE PTR [esi], al ;esi points to ArrayU
inc ArraySizeU
jmp BufferDone

Inside:
mov InsideB, 1 ;If the user entered i, then we need to know the next entry will be an inside option
jmp BufferDone

Inside2: ;If the previous key was an i
cmp al, 61h
jz Alarm
cmp al, 6fh
jmp BufferDone
cmp al, 63h
jz DoCallCloseDoors
cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

jmp Invalid

DoCallCloseDoors:
CALL CloseDoors
jmp Correct

Alarm:
CALL AlarmP

BufferDone:

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : END
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 2Ch ;Get current time (new time)
int 21h

pop ax ;Get back old seconds

sub dh,ah ;New seconds - Old Seconds = difference

js YAdd ;If the subtraction changed the sign flag (rollover), we need to add 60 to the result
jmp NAdd ;Otherwise, go ahead and subtract 3 from the difference to check.

YAdd: ;If there was a rollover, add 60 to the difference
add dh,60

NAdd: ;There was no rollover just continue
sub dh,3 ;Difference - 3

jz Over ;If the difference between the seconds is 3 (3 - 3 = 0), we're done counting
jnz CheckTime ;Otherwise, repeat loop and continue to check the time.

Over:

mov Open, 1
mov Closed, 0
mov Closing, 0
mov Opening, 0

mov bl, AlarmV
cmp bl, 1
jz EndItAll

mov BypassV, 0

ret
OpenDoors ENDP

CloseDoors PROC
cmp Closed, 1
jz DoorsAreClosed
jmp NoTheyAint
DoorsAreClosed:
ret
NoTheyAint:
mov Closing, 1
mov Closed, 0
mov Open, 0
mov Moving, 0
CALL DisplayP

mov ah, 2Ch ;Get time. Seconds are in DH, minutes in CL
int 21h

mov ah, dh ;ah = dh = seconds
mov bl, cl ;bl = cl = minutes

CheckTime: ;Start the checktime 'loop'
push ax ;Push the seconds we initially grabbed

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : START
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 11h ;This is the code for checking the keyboard buffer.
int 16h   ;If the zero flag is set, there is nothing in the buffer
jz BufferDone
;If the zero flag is not set, we can remove the key from the buffer
mov ah, 10h
int 16h

cmp OutsideB, 1 ;If OutsideB is 1, the previous key was from the outside controls and we are getting a 'u' or 'd'
jz Outside2 ;Signal (though, it doesn't really matter).
jmp FirstCase

Outside2:
mov OutsideB, 0
cmp al, 62h
jz Bypass
jmp BufferDone ;It shouldn't make a difference if the person is going up or down. They will actually
;Make the decision based on what they press inside. So we just skip the u or d.
Bypass:
CALL BypassP
jmp Correct

FirstCase:

cmp InsideB, 1 ;If InsideB is 1, that means the previous key was 'i' for inside
jz Inside2

cmp al, 69h ;if the key is i
jz Inside

cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

Invalid: ;Key doesn't match anything acceptable. So we let the user know and end the buffercheck.
mov InsideB, 0 ;Go ahead and clear buffer
mov ah, 11h
int 16h
mov InvalidV, 1
CALL DisplayP
mov InvalidV, 0
jmp BufferDone

Number:
;If outside, grab number and make sure we grab the u or d afterwards
cmp InsideB, 1 ;If i was the last key then the number is coming from the inside.
jnz SetOutsideB
jz DontSetOutside

SetOutsideB: ;If i was not the last key, then the number is on the outside
mov OutsideB, 1 ;And we need to set the outside boolean so we can catch the u or d the next time around when we check the buffer
mov bl, Floor
add bl, 30h
cmp bl, al ;Is the destination above or below current floor. See below for if they are the same
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

DontSetOutside:
mov InsideB, 0 ;The inside sequence is done, so we can reset the boolean
mov bl, Floor ;Put the current floor in a register to check
add bl, 30h ;Make the floor it's ASCII value
cmp bl, al ;Is the destination higher or lower than the current floor (though we're moving)
jz BufferDone ;For now at least, if we just came from the destination floor, then I'm not going
;to add it to the queue. You can add it again when you reach the next floor.
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

GoingDown:
mov edi, OFFSET ArrayD
cmp BYTE PTR [edi], 99
jz LCA
LC: ;esi and edi aren't always going to point to the next open space so we have to find it
add edi, 1
cmp BYTE PTR [edi], 99
jz LCA
jnz LC
LCA:
mov BYTE PTR [edi], al ;edi points to ArrayD
inc ArraySizeD
jmp BufferDone

GoingUp:
mov esi, OFFSET ArrayU
cmp BYTE PTR [esi], 99
jz LC2A
LC2:
add esi, 1
cmp BYTE PTR [esi], 99
jz LC2A
jnz LC2
LC2A:
mov BYTE PTR [esi], al ;esi points to ArrayU
inc ArraySizeU
jmp BufferDone

Inside:
mov InsideB, 1 ;If the user entered i, then we need to know the next entry will be an inside option
jmp BufferDone

Inside2: ;If the previous key was an i
cmp al, 61h
jz Alarm
cmp al, 6fh
jz DoCallOpenDoors
cmp al, 63h
jmp BufferDone
cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

jmp Invalid

DoCallOpenDoors:
CALL OpenDoors
jmp Correct

Alarm:
CALL AlarmP

BufferDone:

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : END
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 2Ch ;Get current time (new time)
int 21h

pop ax ;Get back old seconds

sub dh,ah ;New seconds - Old Seconds = difference

js YAdd ;If the subtraction changed the sign flag (rollover), we need to add 60 to the result
jmp NAdd ;Otherwise, go ahead and subtract 5 from the difference to check.

YAdd: ;If there was a rollover, add 60 to the difference
add dh,60

NAdd: ;There was no rollover just continue
sub dh,3 ;Difference - 3

jz Over ;If the difference between the seconds is 3 (3 - 3 = 0), we're done counting
jnz CheckTime ;Otherwise, repeat loop and continue to check the time.

Over:

mov Open, 0
mov Closed, 1
mov Closing, 0
mov Opening, 0

ret
CloseDoors ENDP

DoorWait PROC
mov ah, 2Ch ;Get time. Seconds are in DH, minutes in CL
int 21h

mov ah, dh ;ah = dh = seconds
mov bl, cl ;bl = cl = minutes

CheckTime: ;Start the checktime 'loop'
push ax ;Push the seconds we initially grabbed

mov bl, AlarmV
cmp bl, 1
jz BufferDone

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : START
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 11h ;This is the code for checking the keyboard buffer.
int 16h   ;If the zero flag is set, there is nothing in the buffer
jz BufferDone
;If the zero flag is not set, we can remove the key from the buffer
mov ah, 10h
int 16h

cmp OutsideB, 1 ;If OutsideB is 1, the previous key was from the outside controls and we are getting a 'u' or 'd'
jz Outside2 ;Signal (though, it doesn't really matter).
jmp FirstCase

Outside2:
mov OutsideB, 0
cmp al, 62h
jz Bypass
jmp BufferDone ;It shouldn't make a difference if the person is going up or down. They will actually
;Make the decision based on what they press inside. So we just skip the u or d.
Bypass:
CALL BypassP
jmp Correct

FirstCase:

cmp InsideB, 1 ;If InsideB is 1, that means the previous key was 'i' for inside
jz Inside2

cmp al, 69h ;if the key is i
jz Inside

cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

Invalid: ;Key doesn't match anything acceptable. So we let the user know and end the buffercheck.
mov InsideB, 0 ;Go ahead and clear buffer
mov ah, 11h
int 16h
mov InvalidV, 1
CALL DisplayP
mov InvalidV, 0
jmp BufferDone

Number:
;If outside, grab number and make sure we grab the u or d afterwards
cmp InsideB, 1 ;If i was the last key then the number is coming from the inside.
jnz SetOutsideB
jz DontSetOutside

SetOutsideB: ;If i was not the last key, then the number is on the outside
mov OutsideB, 1 ;And we need to set the outside boolean so we can catch the u or d the next time around when we check the buffer
mov bl, Floor
add bl, 30h
cmp bl, al ;Is the destination above or below current floor. See below for if they are the same
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

DontSetOutside:
mov InsideB, 0 ;The inside sequence is done, so we can reset the boolean
mov bl, Floor ;Put the current floor in a register to check
add bl, 30h ;Make the floor it's ASCII value
cmp bl, al ;Is the destination higher or lower than the current floor (though we're moving)
jz BufferDone ;For now at least, if we just came from the destination floor, then I'm not going
;to add it to the queue. You can add it again when you reach the next floor.
js GoingUp ;Destination is above the current floor
jmp GoingDown ;Destination is below current floor

GoingDown:
mov edi, OFFSET ArrayD
cmp BYTE PTR [edi], 99
jz LCA
LC: ;esi and edi aren't always going to point to the next open space so we have to find it
add edi, 1
cmp BYTE PTR [edi], 99
jz LCA
jnz LC
LCA:
mov BYTE PTR [edi], al ;edi points to ArrayD
inc ArraySizeD
jmp BufferDone

GoingUp:
mov esi, OFFSET ArrayU
cmp BYTE PTR [esi], 99
jz LC2A
LC2:
add esi, 1
cmp BYTE PTR [esi], 99
jz LC2A
jnz LC2
LC2A:
mov BYTE PTR [esi], al ;esi points to ArrayU
inc ArraySizeU
jmp BufferDone

Inside:
mov InsideB, 1 ;If the user entered i, then we need to know the next entry will be an inside option
jmp BufferDone

Inside2: ;If the previous key was an i
cmp al, 61h
jz Alarm
cmp al, 6fh
jz MaybeOpenDoors
cmp al, 63h
jz MaybeCloseDoors
cmp al, 30h
jz Number
cmp al, 31h
jz Number
cmp al, 32h
jz Number
cmp al, 33h
jz Number

jmp Invalid

MaybeOpenDoors:
CALL OpenDoors
jmp BufferDone

MaybeCloseDoors:
cmp Closed, 1
jz BufferDone
CALL CloseDoors
jmp BufferDone

Alarm:
CALL AlarmP

BufferDone:

;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;KEYBOARD BUFFER JUNK : END
;;;;;;;;;;;;;;;;;;;;;;;

mov ah, 2Ch ;Get current time (new time)
int 21h

pop ax ;Get back old seconds

sub dh,ah ;New seconds - Old Seconds = difference

js YAdd ;If the subtraction changed the sign flag (rollover), we need to add 60 to the result
jmp NAdd ;Otherwise, go ahead and subtract 3 from the difference to check.

YAdd: ;If there was a rollover, add 60 to the difference
add dh,60

NAdd: ;There was no rollover just continue
sub dh,3 ;Difference - 3

jz Over ;If the difference between the seconds is 3 (3 - 3 = 0), we're done counting
jnz CheckTime ;Otherwise, repeat loop and continue to check the time.

Over:

ret
DoorWait ENDP

BypassP PROC
mov BypassV, 1
mov esi, OFFSET ArrayU
mov edi, OFFSET ArrayD
L1:
mov BYTE PTR [esi], 99
mov BYTE PTR [edi], 99
add esi, 1
add edi, 1
cmp esi, 15
jz Done
jmp L1
Done:
mov BypassV, 0
mov AlarmV, 0
mov Counter, 0
mov TravelCounter, 0
mov InsideB, 0
mov OutsideB, 0
mov Up, 0
mov Down, 0
mov Closed, 1
mov Open, 0
mov Floor, 0
mov NextFloor, 0
mov Difference, 0
mov ArraySizeU, 0
mov ArraySizeD, 0
ret
BypassP ENDP

AlarmP PROC
mov AlarmV, 1
mov esi, OFFSET ArrayU
mov edi, OFFSET ArrayD
L1:
mov BYTE PTR [esi], 99
mov BYTE PTR [edi], 99
add esi, 1
add edi, 1
cmp esi, 15
mov Counter, 0
mov Closed, 1
mov Open, 0
jz Done
jmp L1
Done:
jmp Move
AlarmP ENDP

DisplayP PROC USES eax edx
call ClrScr

cmp Floor, 0
jz Floor0
cmp Floor, 1
jz Floor1
cmp Floor, 2
jz Floor2
cmp Floor, 3
jz Floor3

Floor0:
mov edx, OFFSET msgSegment1
call WriteString
mov edx, OFFSET msgSegment2
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegment4
call WriteString
mov edx, OFFSET msgSegment5
call WriteString
mov edx, OFFSET msgSegment6
call WriteString
mov edx, OFFSET msgSegment7
call WriteString
jmp D1Done

Floor1:
mov edx, OFFSET msgSegmentFSR
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegment4
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegment7
call WriteString
jmp D1Done

Floor2:
mov edx, OFFSET msgSegment1
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegment3
call WriteString
mov edx, OFFSET msgSegment4
call WriteString
mov edx, OFFSET msgSegment5
call WriteString
mov edx, OFFSET msgSegment6
call WriteString
mov edx, OFFSET msgSegmentFR
call WriteString
jmp D1Done

Floor3:
mov edx, OFFSET msgSegment1
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegment3
call WriteString
mov edx, OFFSET msgSegment4
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegment6
call WriteString
mov edx, OFFSET msgSegment7
call WriteString

D1Done:

mov edx, OFFSET msgClean
call WriteString

D2:
cmp Up, 1
jz GoingUp
cmp Down, 1
jz GoingDown
jmp D3

GoingUp:
mov edx, OFFSET msgSegmentFSR
call WriteString
mov edx, OFFSET msgSegment2
call WriteString
mov edx, OFFSET msgSegment3
call WriteString
mov edx, OFFSET msgSegment4
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegmentFR
call WriteString
jmp D4

GoingDown:
mov edx, OFFSET msgSegmentFSR
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegment3
call WriteString
mov edx, OFFSET msgSegmentFR
call WriteString
mov edx, OFFSET msgSegment5
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegment7
call WriteString
jmp D4

D3:
mov edx, OFFSET msgSegmentFSR
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegmentFR
call WriteString
mov edx, OFFSET msgSegmentFSS
call WriteString
mov edx, OFFSET msgSegmentF
call WriteString
mov edx, OFFSET msgSegmentFR
call WriteString

D4:
mov bl, InvalidV
cmp bl, 1
jz Invalid
mov bl, AlarmV
cmp bl, 1
jz Alarm

jmp NotSpecial

Alarm:
mov edx, OFFSET msgAlarm
call WriteString
ret

Invalid:
mov edx, OFFSET msgInvalid
call WriteString
ret

NotSpecial:

mov bl, Opening
cmp bl, 1
jz DisplayOpening

mov bl, Closing
cmp bl, 1
jz DisplayClosing
jmp OCDone

DisplayOpening:
mov edx, OFFSET msgOpening
call WriteString
jmp DisplayDone

DisplayClosing:
mov edx, OFFSET msgClosing
call WriteString
jmp DisplayDone

OCDone:

mov bl, Open
cmp bl, 1
jz DisplayOpen
jmp DisplayClosed
DisplayOpen:
mov edx, OFFSET msgOpen
call WriteString
jmp DisplayDone
DisplayClosed:
mov edx, OFFSET msgClosed
call WriteString

DisplayDone:
cmp Moving, 1
jz DisplayMoving
jmp NoMoving
DisplayMoving:
mov edx, OFFSET msgChanging
call WriteString
NoMoving:

ret
DisplayP ENDP

END main[/aeva][/aeva]

There was a whole summer in between my Circuits I class and my current Circuits II class that made me forget how to do some simple frequency to frequency, time to frequency, and frequency to time conversions.

Ex.
V = 120√50° --converts to->  V = x + jy (where j is basically i or √-1)

Z = 50 + j50 --converts back to-> x√y°

(Edit: These are actually frequency to frequency, I believe)

The textbook is different and assumes we already know how to do such transformations. Prematurely, I sold my old book and can't find my old notes. I've been introweb searching this but can't find any practical formulas that will work for these cases above. The only one I remember is the following time to frequency transformation:

V = 120sin(4t + 50) --converts to-> 120√50°

I'm still looking for my notes but thought I'd put the homework forum to good use at the same time. Leave it to me to understand all the concepts but be unable to do my homework because I can't convert numbers.

I'm on a search for a good internet radio.

Ever since my dad subscribed for SBC DSL I have been using LaunchCast internet radio on Yahoo.com. I was able to listen to my own 'customized' station free of ads because I had a 'plus' account due to the DSL subscription. Also, I could skip as many songs as I wanted until I got to one I wanted to hear.

However, they have recently been taken over by CBS Radio and are discontinuing the 'customized' station which really has me heated. They have their regular stations but are now putting a limit on the number of songs you can skip per hour.

I have also been using Pandora which I liked because you can search a radio station by genre or just by artist and hear related music. However, they also have a skip limit on each individual station.

Can anyone suggest a good internet radio site? I hate the skip limits, but I can live with it if I have to (I get why they have to have it). I really just want something that has a good idea of what goes together and will recommend new artists. This is my primary way of finding new music.

We lost one of the greats today.

click

I'm going to see Marky's latest movie tonight which also happens to be Shyamalan's latest. I would have to say from what I've seen it should be interesting and of course M. Night always brings his A-game with endings.

Until I come back from The Happening tonight to convey my feelings about it (because I know you want to know), perhaps we should use this thread to discuss good / bad movie endings or why Marky Mark will never live down The Funky Bunch and "Good Vibrations" no matter how hard he tries.

EDIT: Oh yeah, http://youtube.com/watch?v=UnzgNAzquCw

About a week ago I had to take my car ('93 Ford Mustang GT) in for a bit of work as the brakes were bad. I can fix a variety of things myself but not brakes. Long story short, the quoted by $200 but it cost $455. This came at a bad time as I just got back from spending lourdes of money in L.A. for spring break.

I told you that story so I could tell you this one . . .

Back when I was a young lad of about 14 I received what young men usually receive at the age of 18: The draft regislation. Now, I pretty much just forgot about that until now. Apparently, TurboTax says my birthday is not in sync with what Social Security says it is.

Once again, long story short, I had to go to the S.S. office to change my birthday.

So, I'm on my way to the S.S. office today when I look up (can't remember what I was doing) and there lies a Honda CRV about 15-20 feet ahead of me. Needless to say, I slam on the brakes and slammed into the back of her.

She's fine, I'm fine. Her car is eerily unscathed, but the Mustang . . .

Tow truck guy comes and asked me if I want it towed to the 'lot'. I say no, take it to my house. He proceeds to tell me that It wil cost me $85 to take it to my house, but it will cost the Insurance company $85 to take it to the 'lot'. I proceed to tell him to take it to the lot.

Now what I didn't realize, and I blame myself for this, was that he assumed I had full coverage. Now, I have to pay for the wrecker service which would have been $85 dollars but now include: $85 tow, gas and mileage fees, one day storage fee, and a $55 dollar tow back to my house.

So if you've stayed with me so far in this story, I guess the moral is it can always get worse and I should feel grateful for having a car I can spend 455 dollars on. And goodbye piggy bank.

http://www.apple.com/macbookair/

Sure it's tiny and gorgeous, but only one USB? Maybe they should take that headphone jack out and give us another one of those expensive USB ports.

I understand the Air is probably for people who just need a cool looking paperweight (although it isn't too heavy) so they can put it on their knee and pretend to get work done. I am probably not one of the people they market this thing for. However, considering you'll be shelling out $1,700 (for the 1.6 GHZ, the 1.8 is $3,098), why not get another $200 out and get a MacBookPro? Or, better yet, save a bunch of money and get a regular MacBook.

Maybe this is for the people who need to be able to slide their notebooks under a door, or use them as a frisbee, or snap them in two.

My new roomate is from Brunei. Where oh where is Brunei you might ask. Well, as he put it, do you know where Singapore is? Above that on the map. Anyone know anything interesting about this place? Has anyone even heard of it before? I know I hadn't until today.

Like most of the international students here at Wichita State, he's here on scholarship for engineering. Hopefully he likes more interesting music than my last roomate.

Here's to a new semester trying to decypher what he just said.