public String talkToSelf(String input) {
try {
ChatterBot bot1 = factory.create(ChatterBotType.CLEVERBOT);
ChatterBotSession bot1session = bot1.createSession();
ChatterBot bot2 = factory.create(ChatterBotType.PANDORABOTS, "b0dafd24ee35a477");
ChatterBotSession bot2session = bot2.createSession();
while (continueToTalkToSelf) {
System.out.println("bot1> " + input);
input = bot2session.think(input);
log.info(input);
System.out.println("bot2> " + input);
log.info(input);
input = bot1session.think(input);
}
} catch (Exception e) {
Logging.logException(e);
}
return input;
}
public void write(byte[] command) {
// iterate through the byte array sending each one to the serial port.
for (int i = 0; i < command.length; i++) {
try {
serial.write(command[i]);
} catch (IOException e) {
Logging.logException(e);
}
}
}
public String chat(String toSay) {
try {
return session.think(toSay);
} catch (Exception e) {
Logging.logException(e);
}
return null;
}
public void displayClear() {
try {
device.write(0x00, new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 16);
device.write(0x00, new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 16);
device.write(0x00, new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 16);
device.write(0x00, new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 16);
} catch (Exception e) {
Logging.logException(e);
}
}
public boolean init() {
try {
factory = new ChatterBotFactory();
// chatterbot = factory.create(type);
chatterbot = factory.create(ChatterBotType.PANDORABOTS, "b0dafd24ee35a477");
session = chatterbot.createSession();
} catch (Exception e) {
Logging.logException(e);
}
return true;
}
public byte[] writeDisplay(byte[] data) {
if (device == null) {
log.error("device is null");
return data;
}
try {
device.write(0x00, data, 0, 16);
} catch (Exception e) {
Logging.logException(e);
}
return data;
}
public boolean init7SegmentDisplay() {
try {
if (device == null) {
log.error("device is null");
return false;
}
device.write(0x21, (byte) 0x00);
device.write(0x81, (byte) 0x00);
device.write(0xEF, (byte) 0x00);
device.write(0x00, new byte[] {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 16);
} catch (Exception e) {
Logging.logException(e);
}
return true;
}
public static void main(String[] args) {
LoggingFactory.getInstance().configure();
LoggingFactory.getInstance().setLevel(Level.WARN);
try {
LIDAR template = new LIDAR("Lidar");
template.startService();
// LIDAR lidar01 = (LIDAR) Runtime.createAndStart("lidar01", "LIDAR");
// creates and runs a serial service
// lidar01.connect("dev/lidar01");
// send a command
// this sets the mode to a spread of 180 degrees with readings every
// 0.5
// degrees
// lidar01.setMode(180, 0.5f);
// this setMode command catches the reply from the LMS in the
// listener
// within the
// LIDAR service and returns a bool stating if it was successful or
// not.
// an array of floats holding ranges (after the LDIAR service strips
// and
// parses the data.
// lidar01.singleScan();
Python python = new Python("python");
python.startService();
Runtime.createAndStart("gui", "GUIService");
/*
* GUIService gui = new GUIService("gui"); gui.startService();
*
*/
} catch (Exception e) {
Logging.logException(e);
}
}
@Override
public void run() {
try {
// Keep a socket open to listen to all the UDP trafic that is
// destined for this port
socket = new DatagramSocket(8888, InetAddress.getByName("0.0.0.0"));
socket.setBroadcast(true);
while (true) {
log.info("server >>>Ready to receive broadcast packets! on 0.0.0.0:8888");
// Receive a packet
byte[] recvBuf = new byte[15000];
DatagramPacket packet = new DatagramPacket(recvBuf, recvBuf.length);
socket.receive(packet);
// Packet received
log.info(
"server >>>Discovery packet received from: " + packet.getAddress().getHostAddress());
log.info("server >>>Packet received; data: " + new String(packet.getData()));
// See if the packet holds the right command (message)
String message = new String(packet.getData()).trim();
if (message.equals("DISCOVER_FUIFSERVER_REQUEST")) {
byte[] sendData = "DISCOVER_FUIFSERVER_RESPONSE".getBytes();
// Send a response
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, packet.getAddress(), packet.getPort());
socket.send(sendPacket);
log.info("server >>>Sent packet to: " + sendPacket.getAddress().getHostAddress());
}
}
} catch (Exception e) {
Logging.logException(e);
}
}
public ArrayList<InetAddress> ping() {
ArrayList<InetAddress> ret = new ArrayList<InetAddress>();
// Find the server using UDP broadcast
try {
// Open a random port to send the package
DatagramSocket c = new DatagramSocket();
c.setBroadcast(true);
byte[] sendData = "DISCOVER_FUIFSERVER_REQUEST".getBytes();
// Try the 255.255.255.255 first
try {
log.info("client >>> sending request packet to: 255.255.255.255:8888 (DEFAULT)");
DatagramPacket sendPacket =
new DatagramPacket(
sendData, sendData.length, InetAddress.getByName("255.255.255.255"), 8888);
c.send(sendPacket);
byte[] recvBuf = new byte[15000];
DatagramPacket pong = new DatagramPacket(recvBuf, recvBuf.length);
c.receive(pong);
log.info("client >>> recieved PONG");
} catch (Exception e) {
}
// Broadcast the message over all the network interfaces
Enumeration interfaces = NetworkInterface.getNetworkInterfaces();
while (interfaces.hasMoreElements()) {
NetworkInterface networkInterface = (NetworkInterface) interfaces.nextElement();
if (networkInterface.isLoopback() || !networkInterface.isUp()) {
continue; // Don't want to broadcast to the loopback
// interface
}
for (InterfaceAddress interfaceAddress : networkInterface.getInterfaceAddresses()) {
InetAddress broadcast = interfaceAddress.getBroadcast();
if (broadcast == null) {
continue;
}
// Send the broadcast package!
try {
log.info("client >>> sending request packet to: 255.255.255.255:8888 (DEFAULT)");
DatagramPacket sendPacket =
new DatagramPacket(sendData, sendData.length, broadcast, 8888);
c.send(sendPacket);
} catch (Exception e) {
}
log.info(
"client >>> Request packet sent to: "
+ broadcast.getHostAddress()
+ "; Interface: "
+ networkInterface.getDisplayName());
}
}
log.info(">>> Done looping over all network interfaces. Now waiting for a reply!");
// Wait for a response
byte[] recvBuf = new byte[15000];
DatagramPacket receivePacket = new DatagramPacket(recvBuf, recvBuf.length);
c.receive(receivePacket);
// We have a response
log.info(
">>> Broadcast response from server: " + receivePacket.getAddress().getHostAddress());
// Check if the message is correct
String message = new String(receivePacket.getData()).trim();
if (message.equals("DISCOVER_FUIFSERVER_RESPONSE")) {
// DO SOMETHING WITH THE SERVER'S IP (for example, store it in
// your controller)
// Controller_Base.setServerIp(receivePacket.getAddress());
ret.add(receivePacket.getAddress());
}
// Close the port!
c.close();
} catch (IOException e) {
Logging.logException(e);
}
return ret;
}
// FIXME - normalize further
public Response serveFile(
String uri,
Map<String, String> header,
File homeDir,
boolean allowDirectoryListing,
boolean isCustomFile) {
String username;
String password;
//
if (webgui.requiresSecurity()) { // && !authorized) {
try {
if (header.containsKey("authorization")) {
String up = header.get("authorization");
int pos = up.indexOf("Basic ");
if (pos != -1) {
up = up.substring(pos + 6);
}
// FIXME - depends on commons !!!!
String usernameAndPassword = new String(Base64.decode(up)); // SHWEET
// CURRENTLY
// USING
// WEBSOCKETS
// VERSION
// !!!
// :P
username = usernameAndPassword.substring(0, usernameAndPassword.lastIndexOf(":"));
password = usernameAndPassword.substring(usernameAndPassword.lastIndexOf(":") + 1);
String token = BasicSecurity.authenticate(username, password);
if (token != null) {
// authorized = true;
} else {
throw new Exception(String.format("no token for user %s", username));
}
log.info(usernameAndPassword);
} else {
throw new Exception("no authorization in header");
}
} catch (Exception e) {
Logging.logException(e);
Response r = new Response(e.getMessage());
r.setStatus(Response.Status.FORBIDDEN);
r.addHeader("WWW-Authenticate", "Basic realm=\"MyRobotLab\"");
return r;
}
}
// Remove URL arguments
uri = uri.trim().replace(File.separatorChar, '/');
if (uri.indexOf('?') >= 0) {
uri = uri.substring(0, uri.indexOf('?'));
}
// Prohibit getting out of current directory
if (uri.startsWith("..") || uri.endsWith("..") || uri.indexOf("../") >= 0) {
return new Response(
Response.Status.FORBIDDEN,
WSServer.MIME_PLAINTEXT,
"FORBIDDEN: Won't serve ../ for security reasons.");
}
File f;
if (!isCustomFile) {
// ---- begin resource ----------------
// TODO ? hard coded /resource - are they going to pull up
// WebGUI.class how useful is that ??
String resoucePath = String.format("/resource%s", uri);
InputStream fis = null;
if (resoucePath.endsWith("/")) {
// ends with a slash .. might be a directory - try index.html
String documentIndex = String.format("%sindex.html", resoucePath);
fis = FileIO.class.getResourceAsStream(documentIndex);
if (fis == null) { // couldn't find document index try directory
// listing, if allowed
fis = FileIO.class.getResourceAsStream(resoucePath);
} else {
uri = documentIndex;
}
} else {
fis = FileIO.class.getResourceAsStream(resoucePath);
}
if (fis == null)
return new Response(
Response.Status.NOT_FOUND, WSServer.MIME_PLAINTEXT, "Error 404, file not found.");
try {
// Get MIME type from file name extension, if possible
String mime = null;
int dot = uri.lastIndexOf('.');
if (dot >= 0) {
mime = (String) NanoHTTPD.theMimeTypes.get(uri.substring(dot + 1).toLowerCase());
}
if (mime == null) {
// mime = NanoHTTPD.MIME_DEFAULT_BINARY;
mime = WSServer.MIME_PLAINTEXT;
}
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[16384];
while ((nRead = fis.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
fis.close();
buffer.flush();
byte[] content = null;
// if ("/resource/WebGUI/myrobotlab.html".equals(uri)) {
if (uri.endsWith(".mrl")) {
content = filter(new String(buffer.toByteArray()), header);
mime = NanoHTTPD.MIME_HTML;
} else {
content = buffer.toByteArray();
}
Response r = new Response(Response.Status.OK, mime, new ByteArrayInputStream(content));
r.addHeader("Content-length", "" + content.length);
return r;
} catch (IOException ioe) {
return new Response(
Response.Status.FORBIDDEN, WSServer.MIME_PLAINTEXT, "FORBIDDEN: Reading file failed.");
}
// ---- end resource -------------------
} else {
// ---- begin file -----------------------
f = new File(homeDir, uri);
if (!f.exists())
return new Response(
Response.Status.NOT_FOUND, WSServer.MIME_PLAINTEXT, "Error 404, file not found.");
// List the directory, if necessary
if (f.isDirectory()) {
// Browsers get confused without '/' after the
// directory, send a redirect.
if (!uri.endsWith("/")) {
uri += "/";
Response r =
new Response(
Response.Status.REDIRECT,
NanoHTTPD.MIME_HTML,
"<html><body>Redirected: <a href=\"" + uri + "\">" + uri + "</a></body></html>");
r.addHeader("Location", uri);
return r;
}
// First try index.html and index.htm
if (new File(f, "index.html").exists()) f = new File(homeDir, uri + "/index.html");
else if (new File(f, "index.htm").exists()) f = new File(homeDir, uri + "/index.htm");
// No index file, list the directory
else if (allowDirectoryListing) {
String[] files = f.list();
String msg = "<html><body><h1>Directory " + uri + "</h1><br/>";
if (uri.length() > 1) {
String u = uri.substring(0, uri.length() - 1);
int slash = u.lastIndexOf('/');
if (slash >= 0 && slash < u.length())
msg += "<b><a href=\"" + uri.substring(0, slash + 1) + "\">..</a></b><br/>";
}
for (int i = 0; i < files.length; ++i) {
File curFile = new File(f, files[i]);
boolean dir = curFile.isDirectory();
if (dir) {
msg += "<b>";
files[i] += "/";
}
msg += "<a href=\"" + NanoHTTPD.encodeUri(uri + files[i]) + "\">" + files[i] + "</a>";
// Show file size
if (curFile.isFile()) {
long len = curFile.length();
msg += " <font size=2>(";
if (len < 1024) msg += curFile.length() + " bytes";
else if (len < 1024 * 1024)
msg += curFile.length() / 1024 + "." + (curFile.length() % 1024 / 10 % 100) + " KB";
else
msg +=
curFile.length() / (1024 * 1024)
+ "."
+ curFile.length() % (1024 * 1024) / 10 % 100
+ " MB";
msg += ")</font>";
}
msg += "<br/>";
if (dir) msg += "</b>";
}
return new Response(Response.Status.OK, NanoHTTPD.MIME_HTML, msg);
} else {
return new Response(
Response.Status.FORBIDDEN,
WSServer.MIME_PLAINTEXT,
"FORBIDDEN: No directory listing.");
}
}
// ----- end file ------------------------
}
// }
try {
// Get MIME type from file name extension, if possible
String mime = null;
// int dot = f.getCanonicalPath().lastIndexOf('.');
int dot = uri.lastIndexOf('.');
if (dot >= 0) {
mime = (String) NanoHTTPD.theMimeTypes.get(uri.substring(dot + 1).toLowerCase());
}
if (mime == null) {
mime = WSServer.MIME_PLAINTEXT;
}
// Support (simple) skipping:
long startFrom = 0;
String range = header.get("Range");
if (range != null) {
if (range.startsWith("bytes=")) {
range = range.substring("bytes=".length());
int minus = range.indexOf('-');
if (minus > 0) range = range.substring(0, minus);
try {
startFrom = Long.parseLong(range);
} catch (NumberFormatException nfe) {
}
}
}
InputStream fis;
if (!isCustomFile) {
fis = FileIO.class.getResourceAsStream(uri);
if (fis == null) {
return new Response(
Response.Status.NOT_FOUND, WSServer.MIME_PLAINTEXT, "Error 404, file not found.");
}
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[16384];
while ((nRead = fis.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
fis.close();
buffer.flush();
byte[] content = null;
// FIXME - this is not normalized - because the code around it
// is
// not normalized
if (uri.endsWith(".mrl")) {
content = filter(new String(buffer.toByteArray()), header);
mime = NanoHTTPD.MIME_HTML;
} else {
content = buffer.toByteArray();
}
Response r = new Response(Response.Status.OK, mime, new ByteArrayInputStream(content));
r.addHeader("Content-length", "" + content.length);
return r;
} else {
fis = new FileInputStream(f);
// fis.skip(startFrom); // TODO support skip in the future
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
byte[] data = new byte[16384];
while ((nRead = fis.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
fis.close();
buffer.flush();
byte[] content = null;
// FIXME - this is not normalized - because the code around it
// is
// not normalized
if (uri.endsWith(".mrl")) {
content = filter(new String(buffer.toByteArray()), header);
mime = NanoHTTPD.MIME_HTML;
} else {
content = buffer.toByteArray();
}
Response r = new Response(Response.Status.OK, mime, new ByteArrayInputStream(content));
r.addHeader("Content-length", "" + content.length);
// r.addHeader("Content-length", "" + (f.length() - startFrom));
// r.addHeader("Content-range", "" + startFrom + "-" +
// (f.length() - 1) + "/" + f.length());
return r;
}
} catch (IOException ioe) {
return new Response(
Response.Status.FORBIDDEN, WSServer.MIME_PLAINTEXT, "FORBIDDEN: Reading file failed.");
}
}