http://www.droidforums.net/forum/droid-general-discussions/86800-custom-roms-cricket-network.html#post886957

which is a post-flash version of this:

http://www.howardforums.com/showthread.php/1643218-Motorola-Droid-Full-Solution-Updated

I modified the process a bit, though.  So, here’s what I did:

1. Get http://www.whiterabbit.org/android/u2nl.zip
2. Push u2nl.zip onto the sdcard either with ADB or USB mount.
3. Shell into the D2G with ADB or use the Term.app and mount the /system “rw”:

   mount -o rw,remount -t ext3 /dev/block/mmcblk1p21 /system

4. Unzip the contents of u2nl.zip onto the sdcard:

   cd /sdcard; unzip u2nl.zip

5. Copy the u2nl executable to /system/bin:

   cp /sdcard/u2nl/u2nl /system/bin/
   chmod 755 /system/bin/u2nl

6. Create a startup script to execute the commands in autostart.sh:

   cp /sdcard/u2nl/autostart/motodroid/cricket/autostart.sh /etc/init.d/99cricket
   chmod 750 /etc/init.d/99cricket
   chgrp shell /etc/init.d/99cricket

7. Delete the exit 0 on the last line of the 99cricket script.
8. Exit the Term.app or the ADB shell.
9. Menu->Settings->Wireless & Networks->Mobile Networks->Access Point Names
10. Add the following APN:
    • Name – Cricket
    • APN – internet
    • Proxy – wap.mycricket.com
    • Port – 8080
    • Username – yourphonenumber@mycricket.com
    • Password – cricket
    • Server – wap.mycricket.com
    • MMSC – http://mms.mycricket.com/servlets/mms
    • MMS Proxy – wap.mycricket.com
    • MMS Port – 8080
    • MCC – 310
    • MNC – 004
    • Authentication Type – PAP or CHAP
    • APN type – <Not set>

    And don’t forget to hit Menu->Save.

11. Reboot

And just for reference, the commands in the autostart.sh/99cricket file are:

#!/system/bin/sh

## set up the iptables for cricket

export PATH="$PATH:/system/bin"
iptables -P INPUT ACCEPT
iptables -P OUTPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -F
iptables -t nat -F
iptables -X
iptables -t nat -A OUTPUT -o ppp0 -p 6 ! -d 10.132.25.254 -j REDIRECT --to-port 1025
u2nl 10.132.25.254 8080 127.0.0.1 1025 >/dev/null 2>&1 &
sh -c "sleep 5;kill `ps|grep nk.bla.android.autostart|grep -v grep|awk '{print $2}'`" &

Thanks to http://www.whiterabbit.org/android/.

In any case, the group has a large contingent of technical types and the discussion of representation eventually raised the question of the difference between processes and things, verbs and nouns, [en|de]coders and an encoding, or code and data. The underlying itch seems to be the concept of self-modifying processes or, in computer science terms, code as data and data as code. It seemed to me the holistic thinkers see an aspect to living things, organisms, that is not present in machines. (This inarticulate distinction isn’t new, of course. Great minds have been trying to tease them apart for millenia. And my puny mind won’t add anything to what they’ve already done. But this blog has gotten a bit stale; so I must post something.)

The group seemed to have stalled at the ontological status of a representation. Such a thing seems to have an autonomy all on its own. For example, if you scratch an image of your grandmother into a piece of granite, then humanity goes extinct, do those scratches on the granite still represent your grandmother? Or are they then just meaningless scratches on a rock? To what extent is the decoding process required for an encoded artifact to still be meaningful?

Anyway, this obviously raises all sorts of questions for anyone who likes to think deeply or completely. But the (shallow and incomplete) question it raises to me is fairly common to all the philosophical problems I think about: circular reference. In logic, an impredicative definition is one that defines an object using a quantification over all the other objects like the object being defined. In other words, it’s a self-referencing definition. It’s im-predicative simply because it’s not predicative. In the foundations of math, it boils down to von Neumann’s Axiom of Regularity, which states that sets cannot have elements that, when cracked open, contain elements present anywhere in the cumulative hierarchy of sets above them. In other words, the set hierarchy cannot contain loops.

It seems to me that an organism, and in particular those of us who are capable of using symbols to communicate with one another, is impredicatively defined in terms of its environment. The symbols used are in constant redefinition as the organism and its environment evolve. Hence, any representation, e.g. of the environment by the organism or of the organism by the environment, will be self-referential and inseparable from its context.

So, this leads me to ask why we ascribe ontological status to representations? Why do we think the image of a grandmother scratched into a rock will persist as a representation? I think the answer lies in how we count, which is (probably) based on the fact that we have fingers, digits. We count ordinally: 1, 2, 3 …. And because we do so, our intuitive concept of numbers and sets of things is constructive. Abstractly, math is about grammar, sentences, consistency, and completeness. But concretely, math is about how we relate large bunches of things to small bunches of things, 100 cows to 10 bails of hay, 10 fingers to a billion stars, etc.

When considering these relationships, abstract or concrete, various problems arise like how to represent nothing, the result of taking away 6 cows from a total of 6 cows to give you no cows. How does one represent no cows? Infinity and density are other such problems. What lies after the largest number to which you can count? What lies between two very close numbers? Etc.

In the course of handling some of these issues, von Neumann formulated a constraint (regularity) to avoid unconstructable, cyclic set hierarchies. Later, Turing came up with the “halting problem”: given a step-by-step procedure, decide whether the procedure halts or continues forever. These sorts of problem obviously depend critically on construction. Whether you can tell if a procedure will halt depends on whether and how it can be constructed.

It is this sense of constructability and automatic deduction (no consciousness required), that I think leads to ascribing more ontological status to representations/encodings than is objectively warranted. Another interesting twist arises because so many people use the computer as a metaphor for organisms, the hardware is likened to the body and the software is likened to the mind. But again, this metaphor raises the hackles of those who think organisms are categorically different from machines.

We can seamlessly use the term “representation” to mean a thought in the mind of an organism and an encoding in the software of a machine. But the character of the term changes between the two usages. Saying “the computer uses a representation of your grandmother” is very different to an ordinary layperson than saying “you have a representation of your grandmother in your mind”.

Perhaps this goes back to the axiom of regularity in that the most common modern computer architecture is the von Neumann architecture, where the CPU (process) is categorically distinct from the memory (objects) upon which it operates. These modern computers function by counting, constructing one state from previous states. That separation between the CPU and the memory disallows cyclic sets. At any given time, the objects in the memory can be enumerated, which would not be true without the axiom of regularity. No register can be a member of itself.

Of course, we can simulate circularity by first enumerating some of the set, then moving the CPU pointer back to a register it already finished reading and letting it read again from that same register. But this is not a circular or impredicative definition because at any particular time, the memory is completely, acyclically, enumerable. I take this to imply that a von Neumann architecture is incapable of realizing a non-well-founded set.

Of course, I’m not really a mathematician and I’m certainly not a meta-mathematician. So, my intuition and/or reasoning could be completely off. One discussant pointed out that an alternative set of axioms, called AFA (Anti-Foundation Axiom, which refers to the ZFC without the axiom of regularity plus the anti-foundation axiom) is just as consistent as ZFC (Zermelo-Fraenkel plus the Axiom of Choice). And others[1] point out that AFA and ZFC are shown to be “mutually interpretable”. So, perhaps this means that a sentence in AFA, involving a cyclic set (not possible in ZFC), can be “constructed” by first transforming the sentence into some equivalent in ZFC, constructing that in the normal way, then transforming it back. This would mean that a von Neumann architecture machine, although based in the intuitive counting-based construction with which we’re familiar, would still be able to compute AFA sentences … kinda like transforming a problem from the time domain into the frequency domain, solving it there, and transforming it back. I don’t know. But it sure seems suspicious to me.

In any case, perhaps my suspicion is evidence that I’ve bought into the false dichotomy von Neumann so insidiously implanted in our modern, digitally myopic minds? Perhaps representations (or symbols, in general) really do become entirely meaningless when violently torn from their context?

[1] http://research.microsoft.com/pubs/70350/tr-2006-138.pdf

/home/[username]/.mozilla-thunderbird/[profile].default/chrome/userContent.css

In that file, place the following CSS clause:

span[_moz_quote=true] {
color: pink ! important;
}

But shut Thunderbird down before you edit that file. Thanks to this forum thread for the answer.

1. change /boot/grub/menu.lst root=LABEL=uec-rootfs to root=/dev/sda1, and
2. copying some kernel modules so that nfs-kernel-server will work. link

1. Get the SysRescCD ISO image. (Any live linux CD should work, including Knoppix.)
2. Create a new (larger) VirtualBox disk image (*.vdi) from within VirtualBox.
3. In the VirtualBox Details tab for your Windows instance, set your original VDI as the IDE Primary Master.
4. Set the new (empty) VDI as the IDE Primary Slave.
5. And set the linux ISO as the CD/DVD IDE Secondary Master.
6. Ensure that the instance is set to boot from the CD/DVD first in System->Boot Order.
7. Boot the instance.
8. At the command line, run
   fdisk -l /dev/sda
   You should see a partition there of type 7, NTFS.
9. Then run
   fdisk -l /dev/sdb
   You should see an error message that says there is no partition on that device.
10. Then run the command:
    dd if=/dev/sda of=/dev/sdb
    This will take a long time. It means copy from the input file /dev/sda to the output file /dev/sdb.
11. Shutdown the system with:
    shutdown -h now
12. Change the Storage->IDE Secondary Master (CD/DVD) from the ISO image to your regular optical drive, or remove it completely so that it will boot into the original (small) Windows image.
13. In Windows, select Start->Run… and type:
    diskpart.exe
14. Type:
    select disk 1
    to select the (large) disk.
15. Type:
    list disk
    to see that you’ve selected the right one with the right size.
16. Type:
    select partition 1
    to select the 1st partition on that disk.
17. Type:
    list partition
    to see that you’ve selected the right partition.
18. Type:
    extend
    to extend the volume all the way to the end of the device.
19. Turn off the virtual instance and select the new (larger) VDI as the Storage->IDE Primary Master.
20. Boot the instance again and you should have a larger system (C:) disk.

Recently I started using my linux laptop as my primary avr-usb development environment. When I upgraded the laptop to the current Ubuntu-LTS release (10.4 aka Lucid lynx) a bunch of stuff was broken including all of the wonderful udev rules provided by my linux savvy friends at dorkbotpdx.

I mean jeesh even lsusb was broken.

$ lsusb -vd "03eb:"|grep iM
cannot read device status, Operation not permitted (1)
iManufacturer           1

When I started looking at what changed and how to adjust, the web dead ended to a lot of threads like the one at http://ubuntuforums.org/showthread.php?t=1360412 ; where two people declared that having to escalate privileges to root in order to talk to a user device was “normal”. Even when the developer said it wasn’t normal the ubuntu folk redeclared it normal (apparently after Bush you just have to repeat something blatantly stupid for it to be true). As an administrator the last thing you want is everything and its dog requiring root privileges.

Hanging around the #ubuntu channel was a lot like having people repeat the searches on the web that provided me with the same dead ends that I joined the channel trying to resolve.

Cherchez la femme (look at the squeeze)

This was getting stupid. All I wanted to do was to have devices that I could plug in and program and then communicate with them using ruby or perl or some other haphazzardly thrown together scripts without having to be root. Then I realized once again that ubuntu is really focused on making the users life easier and that this leads to a lot of non technical help. So I asked my friends what the nick name was for the Debian release that was the basis for the Ubuntu release nick named “Lucid” and then re did all of my dead ended web queries replacing “Ubuntu Lucid” with “Debian Squeeze”.

The results were heavy on the technical detail and light on social skills.

More importantly I quickly found the solution that I needed in the middle of this link (http://git.zerfleddert.de/cgi-bin/gitweb.cgi/usb-driver?a=blob_plain&f=README&hb=HEAD) what I was missing was the difference between the new and the old udev rules.

“If you are running a newer version of udev (as in Debian Squeeze and
Ubuntu 9.10), you need to adapt the rules-file to the new udev-version:
sed -i -e ‘s/TEMPNODE/tempnode/’ -e ‘s/SYSFS/ATTRS/g’ -e ‘s/BUS/SUBSYSTEMS/’ \
/etc/udev/rules.d/xusbdfwu.rules”

One line of sed was all I needed and it had taken me a week of asking about lucid when i should have been asking about squeeze. With this I also was able to find the changes to the lay out of the /dev and /proc trees and the new tools to monitor udev and diagnose issues.

All-Your-Atmel-Belong to Us

I really just wanted to change the permissions so I could use my devices. Adding the following udev rule to your system will do just that.  You will also need to restart the udev service. Both of these will require you to be root.

# cat >/etc/udev/rules.d/98-all-your-atmel-belong-to-us.rules<<EOF
#------------------------/etc/udev/rules.d/98-all-your-atmel-belong-to-us.rules
#
# Make atmel devices (dfu, LUFA, obdev) accessible in userland
# 
ACTION=="add", SUBSYSTEMS=="usb", ATTRS{idVendor}=="03eb", MODE="0666"
EOF
# service udev restart

To actually own all my atmel I could have also added ‘ ,USER=”don” ‘ after the mode part but I just wanted to talk my Atmel usb-avr devices and the open source firmware I was developing. And the above rule made things “just work”.

$ lsusb -vd "03eb:"|grep iM
iManufacturer           1 mycompany.com
$

This rule fixed all of my LUFA based devices including the my open source arduino programmer as well as the dfu programmer.used to code them. Hopefully it will be a while before I have to go through this again.

So after upgrading two systems to Lucid, I can tell you that most of the details have been well paid attention to, and a few problems we were having with 9.10 and hardy actually got solved. But there is still stuff that wasn’t broken that the kids just had to fix. So without further adeau I will tell you how to get gdm (and X) to go away after you have installed sysv-rc configured it to runlevel 3 (multiuser – no x) and its still there.

Setting the runtime.

If you have a working inittab the existing scripts will reference it so you can skip to how to get rid of gdm.

if you don’t you will find that the default runlevel is set to 2 (linux’s ‘user defined’ graphical runlevel since rc5 wasnt good enough for some reason) in /etc/init/rc-sysinit.conf. This should be changed to look like this.

# Default runlevel, this may be overriden on the kernel command-line
# or by faking an old /etc/inittab entry
env DEFAULT_RUNLEVEL=3

rebooting and typing “runlevel” should verify the change.

Why is gdm/X still running?

Beats the begebes out of me. But if you want it to stop you need to edit the /etc/init/gdm.conf and comment out the “start on” conditions and change them so that they correspond to the appropriate runlevel.

#start on (filesystem
#          and started dbus
#          and (graphics-device-added fb0 PRIMARY_DEVICE_FOR_DISPLAY=1
#               or drm-device-added card0 PRIMARY_DEVICE_FOR_DISPLAY=1
#               or stopped udevtrigger))
start on runlevel [24]
stop on runlevel [0136]

Grubby.

If you don’t want gdm/x you probably don’t want the splash junk either. While /boot/grub/menu.lst allows you to set default options like nosplash every kernel upgrade i have done in the past year explicitly asks for quiet and splash way out at the end of each “kernel” line so just plan on hand editing the darned thing after each kernel update. I am sure you can uninstall splash but I prefer configuring things to keeping track of what needs to be uninstalled for a system to run correctly.

Damned Kids.

Hope this saves you some of your precious hair. All and all lucid (server and desktop) seems pretty sane and stable but they are still fixing things whether or not they were broken.

Dont even get me started on last weeks apparmor configuration update busting our dns.

I’ll repeat the brief blurb on my agent based modeling website.

This paper talks in relative detail about how hypothesis formulation and falsification (failed validation) can be done at a fine grain when only coarse grained validation data is available. Because our in silico liver (ISL) is an analog built in software, we can trace its internals. And because the internals of the analog were designed to map to the internal structure and dynamics of its referent (wet-lab liver perfusion experiments), traces of the ISL become detailed hypotheses about the internals of the liver. However, those detailed hypotheses are not falsifiable, except to the extent that they fail to reproduce the coarse validation data. Nothing can be done about that until we design wet-lab experiments to perform on real livers. In the meantime, though, we can alter the ISL mechanisms so that the coarse grained data matches that taken from wet-lab experiments under different conditions. In this case, we build 3 ISLs that generate the outflow profiles for drug and a sucrose marker for: 1) normal healthy livers, 2) alcohol damaged livers, and 3) carbon tetrachloride damaged livers. With the traces for each of the 3 ISLs, based upon the validated (i.e. not proven true, of course, but proven true enough) mechanisms of the ISL, we can formulate ‘proto-theories’ for the translation of an experimental liver from a healthy to a diseased (cirrhotic) state.

Note that the particulars of the ‘proto-theories’ suggested by these traces are not as sophisticated as those that might be generated by an expert hepatologist. In fact, these ‘proto-theories’ may even seem bizarre or patently false to such an expert (though I believe they don’t seem so to the experts). Indeed, as Box’s aphorism says,

… all models are wrong; the practical question is how wrong do they have to be to not be useful.

The point is not to build computer programs that attempt to compete with the hypothesis formulation of experts. This is not an AI project. The point is to build devices, with whatever tools are available including computers, that make the experts more efficient and effective. By formulating these ‘proto-theories’ about the translation of healthy livers to diseased livers (and vice versa), models like the ISLs provide a foil or sounding board to help sharpen the theories developed by the experts.

Midi Monster Button Locations.	Benito 7g Switch Lcations
Benito 2010 Switch Locations	Benito Without Buttons

All of the code on the Benito and MidiMonster devices is open source and references an open source library called the Lightweight Usb For Avr (lufa). Getting the code compiled and onto the device requires a few other open source tools.

AVR-GCC

The most current and stable release of the toochain for the AVR has untill recently been maintained by Eric Wedddington and released as WinAvr (http://sourceforge.net/projects/winavr/) Winaver integrates nicely into atmels avr studio http://www.atmel.com/dyn/Products/tools_card.asp?tool_id=2725 and I reccomend that you get both if you are running windows. Each Winavr Release is closely followed by objective developments CrossPack for avr http://www.obdev.at/products/crosspack/index.html and a script for building the current toolchain on linux which is hosted by AvrFreaks at present there is also a debian package that was put out last month http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=90172

HWB? DFU?

Most Atmel “atmega” devices have a pin dedicated to determining whether or not the device goes into the bootloader depending on the devices flag settings. This pin is labled HWB (for hardware boot) on most of the datasheets. The usb avr family has this mode set up by default. When you hold the hwb pin low and reset the device it goes into the bootloader. On these devices the built in bootloader uses a usb device class called the Device Firmware Uploader (DFU). Atmel provides a tool called flip for programming DFU devices on windows and linux. There is an open source programmer called dfu-programmer http://dfu-programmer.sourceforge.net/

That other guys stuff.

Those of you who have worked with the teensy boards from paul stoffregon will notice some subtle differences. Paul wrote his own (closed source) bootloader rather than use the bootloader tha comes installed on the chips. Then he uses a hardware trick similar to the auto reset hack to make a single button manipulate both the reset and the hwb pins to put his boards into the bootloader. I didnt feel that either the two button arrangement or the builtin bootloaders were broken so I like most people working with these chips dont fix them.

Using the dfu-programmer

All of the programs in Dean Cameras Lightweight Usb for Avr have a “dfu” target. Once you have the target into the DFU mode you can simply

$make dfu

This will cause the dfu-programmer to erase the flash reprogramm it with a new hex file and restart the chip. You can also do this manually with the following commands

$dfu-programmer atmega32u2 erase
$dfu-programmer atmega32u2 flash mycode.hex
$dfu-programmer atmega32u2 start

This will cause the dfu-programmer to erase the flash reprogramm it with a new hex file and restart the chip.