Archives For July 2013

I’m done with T-Mobile DE (Germany).

I got a new HTC One last week for renewing my contract with the “Telekom”. I put up with the fact they didn’t have the black version, anyways the silver one is not that bad. As soon as I got it, I started to read on the traditional android blogs that 4.2.2 was being pushed. First in Asia, then east Europe… and early this week, to the rest of Europe. Non-branded Ones, even Vodafone or O2 branded phones got the update in Germany. All of them… except T-Mobile of course. I had a similar experience with an HTC Sensation I had some time ago, and then I had to install a ROM for updating.

This time I really wanted to stay off rooting/unlocking the phone for some time. But the lack of timely updates has made me flash a De-branded stock Rom to my HTC One. Finally I have 4.2.2!

The process was actually easier than expected. So, in case you want to “de-brand” your HTC One, here are the steps I followed and the links where you will find the complete procedure for each step:

Usual disclaimer: Blah blah, root your phone at your own risk, blah blah you may void your warranty, etc.

  1. Unlock the bootlader. You can do it directly in the htcdev.com website. They explain you the procedure to unlock your phone. A video following the instructions here.
  2. Root your phone. This is needed to later gain S-OFF of the device. Follow the video instructions posted here.
  3. Gain S-OFF via revone. This small utility will get you S-OFF and you can get if from here. Also, a detailed video of the procedure is here.
  4. Change CID so that you receive the updates and can install a stock HTC system version. Follow the steps mentioned in this post, except instead of wrting the CID to 11111111, write HTC__001. Another useful post on this topic is this one.
  5. Flash a RUU stock rom. You can find most of them here. I used RUU_M7_UL_JB_50_HTC_Europe_1.28.401.7_Radio_4A.13. 3231.27_10.31.1131.05_release_310878_signed.exe.
  6. That’s it! Keep getting the updates from Settings -> Check for updates until you get Android 4.2.2

Hope this help you getting rid of T-Mobile bloatware and delayed updates.

UPDATE:

After reinstalling all my apps, I noticed in the settings that the phone is marked as a “Test device” in some places. Also when you try to enter recovery mode you can briefly see a red warning mentioning this. This is because the phone is in S-OFF. To remove this notification and possible other “side effects”, you just need to put S-ON again via the revone tool. Because you lost root flashing the RUU, you will need to root again the phone installing the recovery again. Probably you could avoid all this if before flashing the RUU, you put the phone in S-ON again. In my case, I don’t want to flash the system again as I already installed and set up the phone for a second time.

UPDATE 2:

I got Android 4.3 already on day 1 as well. So the method keeps working.

Continuing with the description of the wireless mailbox sensor, I was missing the information on the coordinator: an arduino mega with an ethernet shield and an Xbee attached.

Originally I had two Regular Xbee Series 1. I chose series 1 because of the simplicity for non complex projects. I read in many sources they are easier to handle when starting out with Xbee and also they support multi-point communication. Weather to use a physical antenna or on-chip antenna I think doesn’t matter much. The problem I had was that the signal from the regular Xbees didn’t reach from my mailbox (which is downstairs outside my apartment) to the location of the coordinator inside my apartment. I finally had to buy a Xbee Series 1 Pro with a wire antenna. Pro and Regular Xbees are compatible with only few minor changes, more importantly the Pro version consumes more power given the larger reception range. The coordinator runs on a connected power source so I didn’t really mind this increase in power consumption.

The coordinator is always listening for upcoming Xbee transmissions, in case it receives something, it will check the source sensor the transmission is coming from and the message (mailbox opened, new letter received, etc). After “decoding” the message it will connect via the Ethernet Shield to a php script I have in my hosting that will handle the push notification using Google Cloud Messaging (GCM) for Android. I will write about the use of GCM and the android app in a separate post.

Here is the full code for the arduino handling the reception of messages:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
#include <SPI.h>
#include <Ethernet.h>
#include <EthernetClient.h>
#include <Xbee.h>
#include <Ilos.h>
 
// Xbee related stuff
XBee         xbee       = XBee();
XBeeResponse response   = XBeeResponse();
Rx16Response rx16       = Rx16Response();
Rx64Response rx64       = Rx64Response();
 
// Ethernet related stuff
boolean     lastConnected   = false;
byte        mac[]           = { 0x00, 0xAA, 0xBB, 0xCC, 0xDA, 0x02 };
IPAddress   ip(192,168,1,234);
char        server[]        = "www.adrova.com";
EthernetClient client;
 
// Input and outputs
int statusLED = 13;
 
void setup(){
 
    // Setup pin modes
    pinMode(statusLED, OUTPUT);
 
    // Setup serial interfaces for debugging
    Serial.begin(9600);
 
    // Setup serial interface for Xbee
    Serial1.begin(9600);
    xbee.setSerial(Serial1);
 
    // Start the Ethernet connection:
    if (Ethernet.begin(mac) == 0) {
        Serial.println("Failed to configure Ethernet using DHCP");
        Ethernet.begin(mac, ip);
    }
 
    // Give the Ethernet shield a second to initialize:
    delay(1000);
 
}
 
void loop(){
 
    // Consume data if available from the Ethernet client
    if (client.available()) {
        char c = client.read();
        Serial.print(c);
    }
 
    // If there's no net connection, but there was one last time
    // through the loop, then stop the client:
    if (!client.connected() && lastConnected) {
        Serial.println();
        Serial.println("Disconnecting...");
        client.stop();
    }
 
    xbee.readPacket();
 
    if (xbee.getResponse().isAvailable()) {
        // We've got something to read
 
        if (xbee.getResponse().getApiId() == RX_16_RESPONSE ) {
            // We've got a rx packet
 
            int sourceAddress;
 
            xbee.getResponse().getRx16Response(rx16);
 
            uint8_t option = rx16.getOption();
            sourceAddress  = rx16.getRemoteAddress16();
 
            //uint8_t analogHigh = rx16.getData(0);
            //uint8_t analogLow = rx16.getData(1);
 
            uint8_t message = rx16.getData(0);
 
            //int value = analogLow + (analogHigh * 256);
 
            Serial.println(message);
 
            // Flash led to indicate success
            flashLed(statusLED, 5, 50);
 
            if(sourceAddress == XMAIL_ADDRESS){
                switch(message){
                    case XMAIL_MSG_RESET_CODE:
                        sendNotification(XMAIL_NAME, XMAIL_MSG_RESET); break;
                    case XMAIL_MSG_NEW_LETTER_CODE:
                        sendNotification(XMAIL_NAME, XMAIL_MSG_NEW_LETTER); break;
                }
            } else if (sourceAddress == XWASH_ADDRESS){
                // TODO for the next sensor
            }
 
        } else {
            // Not something we were expecting
            flashLed(statusLED, 2, 1000);
        }
 
    } else if (xbee.getResponse().isError()) {
 
        //nss.print("Error reading packet.  Error code: ");
        //nss.println(xbee.getResponse().getErrorCode());
        flashLed(statusLED, 2, 1000);
    }
 
    // Store the state of the connection for next time through
    // the loop:
    lastConnected = client.connected();
 
}
 
// Function that will flash a led n times with a delay of wait between each flash
void flashLed(int pin, int times, int wait) {
 
    for (int i = 0; i < times; i++) {
        digitalWrite(pin, HIGH);
        delay(wait);
        digitalWrite(pin, LOW);
 
        if (i + 1 < times) {
            delay(wait);
        }
    }
}
 
// Function that will connect to the GCM service and send the notification
void sendNotification(const char* sensor, const char* message) {
 
//    Serial.println(sensor);
//    Serial.println(message);
//    Serial.println();
 
    if (client.connect(server, 80)) {
        // If there's a successful connection:
        Serial.println("Connecting...");
 
        char getURL[] = "GET /normandy/server/send.php?secret=XXXXXXXXXX&sensor=";
        strcat(getURL, sensor);
        strcat(getURL, "&message=");
        strcat(getURL, message);
        strcat(getURL, " HTTP/1.1");
 
        // Send the HTTP PUT request:
        client.println(getURL);
        client.println("Host: www.adrova.com");
        client.println("User-Agent: arduino-ethernet");
        client.println("Connection: close");
        client.println();
    } else {
        // if you couldn't make a connection:
        Serial.println("Connection failed.");
        Serial.println("Disconnecting.");
        client.stop();
    }
}

As you can see, I have the function sendNotification defined which loads the php script with the sensor and messaged passed in the query string. I don’t really need to handle the result (You could potentially handle errors or check if the server is down here to retry to send the notification later). I added a secret variable for “authorization” purposes since a notification is sent every time the page is loaded. The code itself is self-explanatory, just loading the website and that’s it.