zmxu / cellbots Goto Github PK

The demo com.cellbots.logger DataLogger

needs to be reviewed and updated, the camera api crashes and the write/zip is 
prevented by the 2.3 and 4 android security updates.

This is a good example and possibly the only functional sensor logger.

The initial setup needs to poll all available cameras (more than 2 possible) 
and option select their maximal resolution or framerate.

Logging needs an option to segment into directories or time stamped files with 
variable duration (10 second sensor data each directory or filename, images 
timestamped)

It is possible to record and snap both front and rear simultaneously on many 
devices, and fast throttle between front and rear cameras is possible (sans 
system delay) and alternation should be included in the settings.

Cameras must be set for INFINITE focus or the demo will be useless for use.

It is possible to use HEVC 265 to encode 8k sequential images from the cameras 
allowing maximal resolution regardless of frame rate. 

There are methods to force maximal frame rate recording, both in video stream 
and photo burst.

There are options to more accurately set the SAMPLE RATE which currently is too 
slow.

There is significantly more information available, a snapshot of all system 
status can be collected at certain interval or upon each fragment.

The host system's status should also be logged, cpu, temp, memory so that 
failures can be tracked.

A number of sensors are not included, namely the signals (phone, wifi, etc) and 
Audio/input when not using system mp4 video

Please contact [email protected] gao.bensen so we can go over the best 
options for the demo.

The Python code currently send commands out to the robot using serial 
commands over /dev/ttyMSM2 on rooted phones. We want to support BlueTooth 
serial so that non-rooted phones can be used to connect to electronics.

This also means phones won't need to be physically connected to the device to 
commands them. Holding the phone and moving it like a Wiimote is an example 
use for remote control.

Let a cellbot detect bar-codes in brain mode using front-camera. Let a cellbot 
save bar-codes' content or send it to web-interface. The feature may be used 
for object/location recognition.

The robot currently generations a lot of instructional messages and there 
is a mess of what is done with them.

Currently:

- Sometimes there are spoken, which can be muted, and repeated messages are 
suppressed.

- Some information goes out to the screen via 'print'. Handy when starting 
up the code or debugging but not practical in live operation where you 
can't see the screen.

- We use makeToast() sometimes to make more obvious on screen messages. 
They are easier to see but go away and any info is lost.

- Reply back via XMPP with the same info as above but only if in XMPP mode.

Somewhere in here is a need for some sanity around which method the user 
wants for communications and what is most helpful.

Let a cellbot log the path it make, using data from its' sensors. It will allow 
more complicated scenarios of usage: mapping of surroundins, local positioning, 
etc. 

What steps will reproduce the problem?
1. Run CellbotRemote connected to any bot
2. Moving the phone does not drive the robots


What is the expected output? What do you see instead?
The code here starting on line 170 uses degrees and all values need to be 
adjusted for radians instead due to API changes in SL4A and Android.
http://code.google.com/p/cellbots/source/browse/trunk/android/python/cellbotRemo
te.py

What steps will reproduce the problem?
1.I connect my droid to my mindstorm brick via wifi and set it in brain mode 
2.I connect my other droid to it via shared profile and they will connect. 
3.

What is the expected output? What do you see instead?
I can control it just fine but there is no video and i cant take pictures.
What version of the product are you using? On what operating system?
android(2.2) mindstorm(1.29)

Please provide any additional information below.

We have commandParse() to deal with incoming commands from the user. Now that 
we're starting to have two-way serial working, we need to have a new routing 
to deal with the responses from the robot. Something like responseParse().

Currently the software only sends serial output by echo to /dev/ttyMSM2, 
which goes from the phone to the Arduino RX pin. We'd like to get commands 
sent from the Arduino TX pin accepted by the phone.

The hardware should support this but pySerial isn't included in the Android 
Scripting Environment so we need a hack.

Feature-Request:

I want to control the Roomba in Safe-Mode, so that it stops and returns into 
normal state, e.g. when I lift it.

I would have done it by myself (at the End it ist just a Byte in the settings). 
But I am not able to compile the project in eclipse.
At the moment, when I include the "httpmime-4.1-alpha2.jar", eclipse hangs up 
and aborts with a "out of memory" error (see attached image)

Apps like Bambuser can't rotate the image and expect the phone to be in 
landscape mode when streaming. We need a bot body design that allows the 
phone to more easily be mounted this way and have a clear line if sigh from 
the camera.

We recently removed the text responses from the Arduino code when two-way 
serial communication was added. This was done so that the phone could take 
action on clear data coming from the robot. We lost the ability to plug the 
Arduino directly into a PC via USB and get debugging though.

We should add a command "debug=on" or something similar to turn the verbose 
output back on but leave it off by default.

Create a mini website with some basic AJAX buttons that accepts commands to 
control the bot in addition to the telnet method. Some sample code here to 
get started:
http://python.about.com/od/networkingwithpython/ss/beg_web_client_9.htm

Use Android's voice recognition to let users speak commands to the robot.

Unable to install from market. would love to be able to use this on my Galaxy 
tab 2 7.0

Hi, 

I think that we could generarate a elemental communication API for Serial
and Bluetooth Connection.

The first layer, allow to stablish the connection. For the moment if you
use Serial Port with Python, a good idea could be define a standard to
connect with an Arduino board. With Bluetooth, we could create the same API
to reach that goal.

In a second layer, we could stablish a protocol to manage actuators, for
example RC Servos.

What steps will reproduce the problem?
1. Run the cellbot.py file on the phone
2. Send the 'x' command to get the location
3. Robot says it can not find the location

Under the hood we wrap error checking around the location getting and I think 
we aren't parsing the response right. This probably happened when we 
introduced the robot.py file class. So we're asking for something like 
.result when maybe we need ['result']. Probably an easy fix somewhere.

The new safety check code works for a forward facing or downward facing rage 
sensor. It stops the bot if it will run into something or off the table when 
moving forward. It doesn't deal with moving backwards though and still does 
these same front facing safety checks.

We should assume a robot with forward and back sensors and then understand 
which direction it is moving to know what sensors to read.

What steps will reproduce the problem?
1. Run the cellbots program
2. Back out of it without a proper exit to close the terminal socket
3. Try running the cellbots program again
4. You typically get an error that the socket is already in use

We should either kill and restart the socket in that case, or just skip 
opening it again and use the existing socket.

The servos being used have been modified for continuous rotation. They don't 
however work exactly equal due to slight differences in the resistors used 
for the hack.

We want to add a trim pot and software to let a user slightly adjust the 
signal sent to the left and right servo so the robot drives straight.

The audio text-to-speech is annoying when it repeats the same instruction 
over and over. Best to skip repeats of the same command in sequence such as 
telling it to continue moving forward or turning.

Find a low latency app for transmitting locally and over internet from phone 
to PC. Write code to initiate the software and start streaming.

Need to add a command to close the XMPP connection after taking the quite 
command.

Steps:
1. Start cellbot.py with XMPP commands
2. Send 'q'
3. Get message that it is quitting.

It won't take any further commands but the robot user still shows online. 
Need to close the XMPP conection before closing the Python program.

Note: hitting the back button in ASE will kill it.

What steps will reproduce the problem?
1. Run cellbot on a robot
2. Send a command such as 'point north'
3. Robots will keep moving but never really find North properly

What is the expected output? What do you see instead?
The code handling this is on line 213 here:
http://code.google.com/p/cellbots/source/browse/trunk/android/python/cellbot.py

We may have an issue with API changes where we aren't reading the compass 
heading properly? This happened for angles that recently moved to radians for 
example.

It may also be that we're getting interference from motors and really need for 
them to disconnect and chill out between readings. I suspect the API issue is 
more likely though.

What steps will reproduce the problem?
1. Cellbots on samsung galaxy S3 do not transfer video.
2. "Start Preview" make the picture and buttons to flutter.
3.

What is the expected output? What do you see instead?
 When using "Start Preview" I expect to see video from phone.
 The picture flutters and even the buttons flutters and is hard to use to 
 stop the flutter 

What version of the product are you using? On what operating system?
cellbots v1.0  /  windows 7 , 64

Please provide any additional information below.

Use XMPP chat in addition to the telnet option. Here is some sample code to 
build from.
http://code.google.com/p/android-
scripting/source/browse/python/ase/scripts/saychat.py

The config file allows for setting the listening method that the robot should 
accept commands on (xmpp, telnet, voice). We should prompt the user if this 
is not set to make it easier to try multiple option without editing the file.

The newly introduced safety check code looks to the range sensors on the 
robot to see if there i anything in front of it or the edge of the table it 
is on. We check this AFTER our first command to the servos. Not good.

We should check to see that it is safe to move BEFORE doing so. Although we 
also need to give the human a way to override this since the current check i 
a cheat that allows the human operator to nudge it a little bit.

What steps will reproduce the problem?
1. Run the app on Samsung Galaxy Camera
2. Tap "use back camera"
3. Tap record button

What is the expected output? What do you see instead?
Expected: Record video and data. 
Instead: App crashes, sends message: "camera hardware error"

What version of the product are you using? On what operating system?
Model: Samsung-EK-GC100, Android version 4.1.1

Please provide any additional information below.

Continuous rotation servos often don't have an exact center until calibrated. 
some servos have a pot on them to adjust but others will need it to be done 
in software.

Currently the commandparse() function processes incoming commands, but also 
has too much sub-logic in it. While it calls other functions for some things, 
action like speaking the GPS location are all done within.

We should have a clear function that is dedicated to parsing commands and 
deciding what action to take. Any action should then live within another 
function.

Added this in the 3/27/2010 version of cellbot.py and it requires the use of 
netip.py, which was added to the trunk.

When you launch cellbots.py, it will sometimes throw an error about the 
callback event not existing. Just launching the app again generally fixes it.

Would love to find why and fix it.

The Arduino code should have support for reflectance sensors on the robot for 
edge detection.

We currently use Python to write the robot code, which runs on the phone 
using the Android Scripting Environment. Some users have suggested we also 
have an Android app that can be loaded in the Market.

The ideal use-case is casual users who come across someone with these robots 
and want to quickly download an app and connect to it (best with BlueTooth)

Configurable arduino settings can be saved to the devices EEEPROM so they
dont need to be configured in source code or be sent from the phone after
each reboot.

Add to the Arduino command interpreter to read into a buffer until it
receives a \n char. 

This will allow for more advanced commands like 'leftWheel=100' and a
configuration command. 

We currently have two different code branches, one for the Nokia platform, 
and one for Android. Much of the logic can be shared if we break out the 
functions that talk to hardware.

Ideally the cellbot.py file would be capable of running on either platform. 
It could detect which ones it is on or the developer could set a simple flag.