Archive for Uncategorized

| June 5, 2013
No comments

nlp.pl

% Natural Language Parser for Scribbler II Robot
% by Justin Mangue, 2013
%
% Uses DCG grammar parsing to parse natural language input into Python code, to be executed on a Scribbler II robot.
%
% References used:
% * "The Art of Prolog", Sterling & Shapiro, 1986.

% ParseToCode is the main routine.  Takes a sentence and converts it to a list of executable python code.
% Call with parseToCode([sentence,as,a,list],Status,Code).
parseToCode(Sentence, Status, CodeListOut) :-
	compound_sentence(ParseList, Sentence, []),
	Status = valid,
	generate_code_list(ParseList, [], CodeListOut), 
	!.	
	
parseToCode(Sentence, Status, CodeOut) :-
	+ compound_sentence(_, Sentence, []),
	Status = invalid_sentence,
	CodeOut = 'null',
	!.
	
%%% GRAMMAR DEFINITIONS %%%
	
% Compound Sentence is the top level.  Consists of an optional address statement followed by one or more simple sentences joined by a connective.
compound_sentence(Compound) -->
	optionally_address(robot),
	simple_sentence(Command),
	connective(and),
	compound_sentence(Sentence),
	{ append([Command], [Sentence], Compound_NotFlat) },
	{ flatten2(Compound_NotFlat, Compound) }.

compound_sentence(Command) -->
	optionally_address(robot),
	simple_sentence(Command).
	
% A simple sentence is a command phrase, possibly followed by an optional repetition clause.
simple_sentence([loop(C,T)]) --> 
	command_phrase(C), 
	(to_number(T), [times] ; to_number_eng(T)).
	
simple_sentence([Simple]) --> 
	command_phrase(Simple).
  
% Command phrases are the basic command-level structure.  Most consist of an action and some sort of argument.
command_phrase(move(D,S)) --> 
  action(go), 
  direction(D),
  optional(for),
  unit_to_seconds(S).
  
command_phrase(move(D,S)) --> 
  action(go), 
  unit_to_seconds(S),
  direction(D).
  
command_phrase(move(forward,S)) --> 
  action(go), 
  unit_to_seconds(S).
  
command_phrase(move(D,3)) --> 
  action(go), 
  direction(D).
  
command_phrase(turn(D,S)) --> 
  action(turn), 
  optional(to),
  (optional(the) ; optional(your)),
  direction(D), 
  unit_to_seconds(S).

command_phrase(turn(D,S)) --> 
  action(turn), 
  optional(to),
  (optional(the) ; optional(your)),
  direction(D),
  { S is 90*(3.25 / 360) }.  % 90 degrees by default
  
command_phrase(turn(right,D)) -->
  action(turn),
  direction(around),
  { D is 180 * (3.25 / 360) }.  % 180 degree turn
  
command_phrase(turn(Dir,D)) -->
  action(spin),
  direction(around),
  optional(to),
  (optional(the) ; optional(your)),
  direction(Dir),
  { D is 3.25 }.  % 360 degree turn
  
command_phrase(turn(right,D)) -->
  action(spin),
  direction(around),
  { D is 3.25 }.  % 360 degree turn
	
command_phrase(pic(Mode)) -->
	action(take),
	adposition(a),
	photomode(Mode),
	object(picture).
	
command_phrase(pic(0)) -->  % b&w pic by default, for speed reasons
	action(take),
	adposition(a),
	object(picture).
	
command_phrase(wait(S)) -->
	action(wait),
	optional(for),
	unit_to_seconds(S).
	
command_phrase(wait(3.0)) -->
	action(wait).	
	
command_phrase(beep) -->
	action(beep).
	
command_phrase(moonwalk(S)) -->
	action(moonwalk),
	optional(for),
	unit_to_seconds(S).
	
command_phrase(moonwalk(4.0)) -->
	action(moonwalk).
	
command_phrase(move_until_wall(D)) -->
	command_phrase(move(D,_)),
	condition(until),
	[you],
	condition(encounter),
	object(wall).
	
% Vocabulary/synonym definitions
	
action(go) --> [go] ; [move] ; [drive] ; [roll] ; [scoot].
action(turn) --> [turn] ; [rotate] ; [swivel].
action(spin) --> [spin].
action(take) --> [take] ; [obtain] ; [get] ; [snap].
action(wait) --> [wait] ; [pause] ; [stop].
action(beep) --> [beep].
action(moonwalk) --> [moonwalk].

direction(forward) --> [forward] ; [forwards] ; [ahead] ; [up].
direction(backward) --> [backward] ; [backwards] ; [back].
direction(left) --> [left] ; [counter-clockwise] ; [counter],[clockwise].
direction(right) --> [right] ; [clockwise].
direction(around) --> [around] ; [in],adposition(a),[circle].

adposition(a) --> [a] ; [one].

condition(until) --> [until].
condition(encounter) --> [encounter] ; [reach] ; [sense] ; [hit].

photomode(0) --> [grayscale] ; [greyscale] ; [gray] ; [grey] ; [black],[and],[white] ; [black],[&],[white].
photomode(1) --> [color].

object(picture) --> [photo] ; [picture] ; [pic] ; [snapshot].
object(wall) --> [a],[wall] ; [the],[wall] ; [an],[obstacle] ; [something].

pronoun(robot) --> [robot] ; [scribbler].

connective(and) --> [and] ; [then] ; [comma] ; [and], [then] ; [comma], [then] ; [comma], [and], [then].

% Optional form of address
optionally_address(robot) -->
	(optional(robot) ; optional(scribbler)),
	optional(comma),
	optional(please).
	
% Allow a DCG word to be optional
optional(X) --> [X] ; [].

% Number parsing predicates
% English number recognition from 0.0 - 9999.9

to_number(N) --> num(N1), [point], digit(N2), { N is N1 + (0.1 * N2) }.
to_number(N) --> num(N).

to_number_eng(1) --> [once].
to_number_eng(2) --> [twice].
to_number_eng(3) --> [thrice].

num(0) --> [zero].
num(N) --> xxxx(N).
num(N) --> xxx(N).
num(N) --> xx(N).
num(N) --> digit(N).

num(N) --> [N], { number(N) }.

xxxx(N) --> digit(D), [thousand], xxx(N1), { N is D*1000+N1 }.
xxx(N) --> digit(D), [hundred], rest_xxx(N1), { N is D*100+N1 }.

rest_xxx(0) --> [].
rest_xxx(N) --> [and], xx(N).
rest_xxx(N) --> xx(N).

xx(N) --> digit(N).
xx(N) --> teen(N).
xx(N) --> tens(T), rest_xx(N1), { N is T+N1 }.

rest_xx(0) --> [].
rest_xx(N) --> digit(N).

digit(1) --> [one].
digit(2) --> [two].
digit(3) --> [three].
digit(4) --> [four].
digit(5) --> [five].
digit(6) --> [six].
digit(7) --> [seven].
digit(8) --> [eight].
digit(9) --> [nine].

teen(10) --> [ten].
teen(11) --> [eleven].
teen(12) --> [twelve].
teen(13) --> [thirteen].
teen(14) --> [fourteen].
teen(15) --> [fifteen].
teen(16) --> [sixteen].
teen(17) --> [seventeen].
teen(18) --> [eighteen].
teen(19) --> [nineteen].

tens(20) --> [twenty].
tens(30) --> [thirty].
tens(40) --> [forty].
tens(50) --> [fifty].
tens(60) --> [sixty].
tens(70) --> [seventy].
tens(80) --> [eighty].
tens(90) --> [ninety].

% Scribbler Unit conversions
% All of the Myro commands for Scribbler are expressed in seconds, so conversions of other unit types to seconds are required.

% Seconds -> Seconds
unit_to_seconds(S) -->
	to_number(S), { + S = 1 }, [seconds] ;
	to_number(S), { S = 1 }, [second].
	
% Milliseconds -> Seconds
unit_to_seconds(MS) -->
	to_number(S), { + S = 1 }, { MS is (S / 1000) }, [milliseconds] ;
	to_number(S), { S = 1 }, { MS is (S / 1000) },[millisecond].

% Feet -> Seconds
unit_to_seconds(S) -->
	to_number(Feet), { + Feet = 1 }, { S is Feet * 2.05 }, [feet] ; 
	to_number(Feet), { Feet = 1 }, { S is 2.05 }, [foot].

% Inches -> Seconds
unit_to_seconds(S) -->
	to_number(Inches), { + Inches = 1 }, { S is Inches * (2.05 / 12) }, [inches] ; 
	to_number(Inches), { Inches = 1 }, { S is (2.05 / 12) }, [inch].
	
% Degrees -> Seconds
unit_to_seconds(S) -->
	to_number(Degrees), { + Degrees = 1 }, { S is Degrees * (3.25 / 360) }, ([degrees] ; [º]) ;
	to_number(Degrees), { Degrees = 1 }, { S is (3.25 / 360) }, ([degree] ; [º]).
	
%%% CODE GENERATION %%%
% The top level structure is a code list, which is a list of one or more code fragments to be executed.
% This part is pretty messy, but is needed to handle passing instructions back to Python from Prolog.

generate_code_list([], CodeList, CodeList).
generate_code_list([H|T], CodeList, CodeListOut) :-
	generate_code(H, CodeLineOut),
	append(CodeList, CodeLineOut, NewCodeList),
	generate_code_list(T, NewCodeList, CodeListOut).

generate_code(move(forward,S), CodeOut) :-
	string_to_atom(Keyword, forward),
	CodeOut = [[Keyword,1.0,S]], !.

generate_code(move(backward,S), CodeOut) :-
	string_to_atom(Keyword, backward),
	CodeOut = [[Keyword,1.0,S]], !.

generate_code(move(left,S), CodeOut) :-
	string_to_atom(Keyword1, turnLeft),
	string_to_atom(Keyword2, forward),
	Ninety is 90*(3.25 / 360),
	CodeOut = [[Keyword1,1.0,Ninety],[Keyword2,1.0,S]], !.
	
generate_code(move(right,S), CodeOut) :-
	string_to_atom(Keyword1, turnRight),
	string_to_atom(Keyword2, forward),
	Ninety is 90*(3.25 / 360),
	CodeOut = [[Keyword1,1.0,Ninety],[Keyword2,1.0,S]], !.
	
generate_code(turn(left,S), CodeOut) :-
	string_to_atom(Keyword, turnLeft),
	CodeOut = [[Keyword,1.0,S]], !.
	
generate_code(turn(right,S), CodeOut) :-
	string_to_atom(Keyword, turnRight),
	CodeOut = [[Keyword,1.0,S]], !.
	
generate_code(wait(S), CodeOut) :-
	string_to_atom(Keyword, wait),
	CodeOut = [[Keyword,S]], !.
	
generate_code(pic(Mode), CodeOut) :-
	string_to_atom(Keyword, takePhoto),
	CodeOut = [[Keyword,Mode]], !.

generate_code(beep, CodeOut) :-
	string_to_atom(Keyword, beep),
	CodeOut = [[Keyword,0.4, 640]], !.
	
generate_code(loop(C,T), CodeOut) :-
	generate_code(C,Code),
	append_n_times(Code,[],T,CodeOut), !.
	
generate_code(move_until_wall(forward), CodeOut) :-
	string_to_atom(Keyword, move_until_wall),
	CodeOut = [[Keyword]], !.
	
generate_code(move_until_wall(left), CodeOut) :-
	string_to_atom(Keyword1, turnLeft),
	string_to_atom(Keyword2, move_until_wall),
	Ninety is 90*(3.25 / 360),
	CodeOut = [[Keyword1,1.0,Ninety],[Keyword2]], !.
	
generate_code(move_until_wall(right), CodeOut) :-
	string_to_atom(Keyword1, turnRight),
	string_to_atom(Keyword2, move_until_wall),
	Ninety is 90*(3.25 / 360),
	CodeOut = [[Keyword1,1.0,Ninety],[Keyword2]], !.

generate_code(move_until_wall(backward), CodeOut) :-
	string_to_atom(Keyword1, turnRight),
	string_to_atom(Keyword2, move_until_wall),
	string_to_atom(Keyword3, turnLeft),
	OneEighty is 180*(3.25 / 360),
	CodeOut = [[Keyword1,1.0,OneEighty],[Keyword2],[Keyword3,1.0,OneEighty]], !.

generate_code(moonwalk(S), CodeOut) :-
	string_to_atom(Keyword, moonwalk),
	CodeOut = [[Keyword,S]], !.
	
%%%  MISC SUPPORT PREDICATES %%%

% Check if S is a sublist of L
sublist(S, L) :-
  append(_, L2, L),
  append(S, _, L2).
  
% Builds a list of N instances of item C, then returns the result in L
append_n_times(_,L,0,L):- !.
append_n_times(C,L,N,Result):-
	append(L,C,NewL),
	NewN is N-1,
	append_n_times(C,NewL,NewN,Result).
 
% Flatten a list of lists
flatten2([], []) :- !.
flatten2([L|Ls], FlatL) :-
    !,
    flatten2(L, NewL),
    flatten2(Ls, NewLs),
    append(NewL, NewLs, FlatL).
flatten2(L, [L]).
Category: Uncategorized | Tags: ,
| June 5, 2013
No comments

scribpro.py

# coding=latin-1
#
# File: scribpro.py
# by Justin Mangue
#
# Description:
# This is a script that enables use of a Prolog natural language parsing component to control a Scribbler II robot
# over bluetooth.  Use in sync with nlp.pl.
#
# Dependencies:
# Python 2.7.4         http://www.python.org/getit/      
# PySwip 0.2.3         https://code.google.com/p/pyswip/
# PySpeech             https://code.google.com/p/pyspeech/
# Myro 2.9.5           http://myro.roboteducation.org/download/
# Swi-Prolog 6.2.6     http://www.swi-prolog.org/Download.html

# IMPORTS
from sys import exit
from myro import *
from pyswip import Prolog
import speech as pyspeech

# GLOBAL SETTINGS
verNum = '0.6'              # ScribPro Version Number
scribblerPort = 'COM5'      # Scribbler Bluetooth Port
prologFile = 'nlp.pl'       # Prolog file to consult
debug = 'on'                # Debug mode, if enabled, shows detailed prolog parse information
inputMode = "text"          # Input in text mode by default
outputMode = "text"         # Output to text by default

# CLASSES
class PrologResult(object):
  def __init__(self, prologcall, status, pythoncode):
     self.prologcall = prologcall
     self.status = status
     self.pythoncode = pythoncode

# FUNCTIONS

def strClean(string):
    """ strClean(str) -- converts "A string like This" into a list of lowercase atoms
        i.e. [a,string,like,this] for use in Prolog. also converts commas to "and"s """
    finalstring = "["
    loweredstring = string.lower()
    exclude = '!"#$%&'()*+-./:;<=>?@[\]^_`{|}~'
    for c in exclude:
        loweredstring = loweredstring.replace(c,"")    
    for ch in loweredstring:
        if ch == ' ':
            finalstring = finalstring + ","
        elif ch == ',':
            finalstring = finalstring + ",comma"
        #elif ch == u'xb0' or ch == '°':
        #    finalstring = finalstring + ",degrees"
        else:
            finalstring = finalstring + ch
    return finalstring + "]"
       
def parse(inStr):
    """parse(str) -- cleans the user input and then throws it at Prolog for analysis"""
    codeOut = "null"
    sentence = strClean(inStr)
    prologCall = 'parseToCode(' + sentence + ', Status, CodeOut).'
    for soln in prolog.query(prologCall, maxresult=1):
        statusOut = ''.join(soln["Status"])
        if statusOut == 'valid':
            codeOut = buildMultiCode(soln["CodeOut"])
    return PrologResult(prologCall,statusOut,codeOut)

def buildCode(prologterms):
    """converts a [instruction, param1, param2, ...] list into Python-exec-friendly "instruction(param1,param2,...)" functor format"""
    parameters = [str(item) for item in prologterms]
    if len(parameters) > 2:
        codeOut = parameters[0] + '('
        for x in range(len(parameters)-2):
            codeOut = codeOut + parameters[x+1] + ', '
        codeOut = codeOut + parameters[len(parameters)-1] + ')'
    elif len(parameters) == 2:
        codeOut = parameters[0] + '(' + parameters[1] + ')'
    else:
        codeOut = parameters[0] + '()'
    return codeOut

def buildMultiCode(instructions):
    """converts a list of [instruction, param1, param2] codes into a list of Python-exec-friendly "instruction(param1,param2,...)" strings
       i.e. buildMultiCode([('forward',['1.0','3.0']),('stop',[])]) -> ['forward(1.0, 3.0)', 'stop()']"""
    multiCodeOut = []
    for x in instructions:
        line = buildCode(x)
        multiCodeOut.append(line)
    return multiCodeOut


def execute(code):       # potential security concerns here!
    """executes multiple lines of python script in sequence"""
    for line in code:
        if type(line) is list:
            execute(line)
        else:
            exec line

def toggle_inputMode(mode):
    """toggles between text and voice mode"""
    if mode == "text":
        print "Now activating voice input."
        return "voice"
    else:
        print "Switching back to text-input mode."
        return "text"

def toggle_outputMode(mode):
    """toggles between text and voice mode"""
    if mode == "text":
        print "Now activating voice output."
        return "voice"
    else:
        print "Switching back to text-only output mode."
        return "text"

def toggle_debugMode():
    """toggles between debug mode being on/off"""
    if debug == "on":
        print "Disabling debug mode."
        return "off"
    else:
        print "Enabling debug mode."
        return "on"

# addon robot commands
def takePhoto(mode):
    """Take and display a photo in the specified color mode. 2=color(fast), 1=color, 0=gray"""
    if mode == 2:
        pic = takePicture("jpeg-fast")
    elif mode == 1:
        pic = takePicture("color")
    else:
        pic = takePicture("gray")
    show(pic,"Scribby Cam")
    return

def move_until_wall():
    """Repeatedly moves forward in small increments until wall is sensed"""
    while not wall():
        forward(1.0, 0.7)
    return

def moonwalk(time):
    """Moonwalk backwards for time"""
    while timeRemaining(time):
        forward(.25,.1)                         
        backward(1,.3)                          

# MAIN 
def main():
    # global variable references
    global debug
    global prolog
    global inputMode
    global outputMode
    
    # initialize the robot
    print "***************** ScribPro v" + verNum + " *****************"
    init(scribblerPort)                           
    print "Scribbler II found on bluetooth (" + scribblerPort + ")."
    
    # instantiation of Prolog interface
    prolog = Prolog()
    prolog.consult(prologFile)
    print "Prolog has been initialized."
    print "Loaded " + prologFile + " into SWI-Prolog!"

    print "Starting in " + inputMode + " input mode. ['voice' to toggle]"
    print "Starting in " + outputMode + " output mode. ['sound' to toggle]"
    print "*************************************************"
    
    # main routine
    while(1):
        # grab a line of input, either text or voice
        if inputMode == "voice":
            try:
                inStr = pyspeech.input("nAwaiting voice command. (Ctrl-C to enter text)")
                print "Voice command: " + inStr + "n"
            except KeyboardInterrupt:
                inStr = raw_input("Type in a command: ")
        else:
            inStr = raw_input("nEnter a command: ")

        # parse the input and behave appropriately
        if (inStr == 'quit' or inStr == 'exit'):
            print "Exiting..."
            exit(0)
        elif inStr == 'reload':
            newprolog = Prolog()
            newprolog.consult(prologFile)
            prolog = newprolog
            print "Reloaded " + prologFile + " into Prolog!"
        elif inStr == 'voice':
            inputMode = toggle_inputMode(inputMode)
        elif inStr == 'sound':
            outputMode = toggle_outputMode(outputMode)
        elif inStr == 'debug':
            debug = toggle_debugMode()
        else:
            Result = parse(inStr)
            if Result.status == 'valid':
                if outputMode == "voice":
                    pyspeech.say("Okay")
                print "Okay."
                execute(Result.pythoncode)
            else:
                if outputMode == "voice":
                    errorMsg = "I don't understand " + inStr
                    pyspeech.say(errorMsg)
                print "I don't understand "" + inStr + ""."
                    
            # Print detailed debug information
            if debug == "on":   
                print "nProlog query executed:", Result.prologcall
                print "Status:", Result.status
                print "CodeOut:", Result.pythoncode

if __name__ == "__main__":
    main()
Category: Uncategorized | Tags: ,