imsolidstate » Automation

SMS remote control

imsolidstate — Sat, 17 Jul 2010 02:42:23 +0000

I’ve been expirimenting with cheap GSM cell phones as remote control devices. I wanted to be able to control stuff at my house just by sending a text from my phone. I also wanted to use an AVR since the options are pretty limitless as to what you can control. I started off simple with relay outputs for stuff like the garage door, outside lights, etc. It could also be useful for the AVR to send texts based on events, but I haven’t messed with this yet.

I planned on just having the AVR recognize a particular text string, like “open garage” if I wanted to let someone in my house when I’m not there without giving them a key for example. It’s not overly secure, but you could add a number sequence as a prefix to the command that would be like a password. Then you could periodically change your password if you wanted.

I’m using cell phones from Siemens. They are older phones with true serial comms. You can score one for $20 or so from ebay. The only thing that sucks about these phones is they use PDU mode for text messages. It’s a really inconvenient way to send text strings. There’s a ton of setup to each packet and each character is encoded in seven bits. I haven’t been able to get my code working with the PDU method yet. It gets stuck trying to decode the received message. I’m going to post it here to see if anyone has any suggestions. I’m all self-taught in C. I’ve never tried comparing strings before, so that bit is a little cumbersome. I don’t like using the built-in libraries to do that kind of stuff until I figure out how it works. The only thing I think turned out nice in the code is the unpacking function.

Obviously, you’d be ahead of the game if you found a serial-interface phone that used the regular text mode instead of PDU. I couldn’t find any phones that did text mode and didn’t have a USB interface. (at least not for cheap) Programming a USB host interface is beyond my capabilities on the AVR.

References: Developer’s Home SMS Tutorial

#include 
#include 

#define unpack_state1 0
#define unpack_state2 1
#define unpack_state3 2
#define unpack_state4 3
#define unpack_state5 4
#define unpack_state6 5
#define unpack_state7 6
#define unpack_state8 7
#define F_CPU       8000000
#define BAUD   9600
#define MYUBRR  (F_CPU/(BAUD*(unsigned long)16))-1

void init_USART(void);
void init_timer0(void);
void turnoff_timer0(void);
void init_timer1(void);
void check_sms(void);
void decode_sms(void);
char unpack(unsigned char octet);
void USART_write(unsigned char *buf);

volatile unsigned char rcv_buf[128];
volatile unsigned char rcv_buf_idx;
volatile unsigned char check_message, check_online;

void main(void)
{
 DDRD |= 0x03;
 PORTD &= ~0x03;
 DDRC |= 0x3F;
 PORTC &= ~0x3F;
 DDRB |= 0x3F;
 PORTB &= ~0x3F;
 init_USART();
 init_timer0();
 sei();

 while(check_online<0xF7)
 {
  rcv_buf_idx= 0x00;
  USART_write("at");
  while((rcv_buf_idx<0x08)&(check_online<0x30)) {}
  if( rcv_buf[0x05]==0x4F &
   rcv_buf[0x06]==0x4B)
  {
   PORTB &= ~(1<> 8);
}

void init_timer0(void)
{
 TCCR0B |= (1<0x2F) & (rcv_buf[offset+lenSMSC]<0x3A))
  len_sender_number+= (rcv_buf[offset+lenSMSC] &= ~0x30);
 else if(rcv_buf[offset+lenSMSC]=='A') len_sender_number+= 10;
 else if(rcv_buf[offset+lenSMSC]=='B') len_sender_number+= 11;
 else if(rcv_buf[offset+lenSMSC]=='C') len_sender_number+= 12;
 else if(rcv_buf[offset+lenSMSC]=='D') len_sender_number+= 13;
 else if(rcv_buf[offset+lenSMSC]=='E') len_sender_number+= 14;
 else if(rcv_buf[offset+lenSMSC]=='F') len_sender_number+= 15;
 if(len_sender_number%2) len_sender_number++;
 rcv_buf_idx= (0x1B+lenSMSC);
 unsigned char i= len_sender_number;
 while(i)
 {
  unsigned char *sender_number= rcv_buf[++rcv_buf_idx];
  sender_number++;
  *sender_number= rcv_buf[--rcv_buf_idx];
  sender_number++;
  rcv_buf_idx += 0x02;
  i-= 0x02;
 }
 offset= 0x35;
 unsigned char num_septets= ((rcv_buf[offset+lenSMSC+len_sender_number] &= ~0x30)*10);
 offset= 0x36;
 if((rcv_buf[offset+lenSMSC+len_sender_number]>0x2F) & (rcv_buf[offset+lenSMSC+len_sender_number]<0x3A))
  num_septets+= (rcv_buf[offset+lenSMSC+len_sender_number] &= ~0x30);
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='A') num_septets+= 10;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='B') num_septets+= 11;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='C') num_septets+= 12;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='D') num_septets+= 13;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='E') num_septets+= 14;
 else if(rcv_buf[offset+lenSMSC+len_sender_number]=='F') num_septets+= 15;
 offset= 0x37;
 rcv_buf_idx= (offset+lenSMSC+len_sender_number);
 unsigned char loop= 0;
 unsigned char message[16];
 unsigned char message_idx= 0x00;
 offset= 0x1C;
 while(rcv_buf_idx<=(offset+lenTPDU+lenSMSC))
 {
  unsigned char octet= 0;
  if(rcv_buf[rcv_buf_idx]=='A') octet |= 0xA0;
  else if(rcv_buf[rcv_buf_idx]=='B') octet |= 0xB0;
  else if(rcv_buf[rcv_buf_idx]=='C') octet |= 0xC0;
  else if(rcv_buf[rcv_buf_idx]=='D') octet |= 0xD0;
  else if(rcv_buf[rcv_buf_idx]=='E') octet |= 0xE0;
  else if(rcv_buf[rcv_buf_idx]=='F') octet |= 0xF0;
  else octet= ((rcv_buf[rcv_buf_idx] &= ~0x30)*10);
  rcv_buf_idx++;
  if(rcv_buf[rcv_buf_idx]=='A') octet |= 0x0A;
  else if(rcv_buf[rcv_buf_idx]=='B') octet |= 0x0B;
  else if(rcv_buf[rcv_buf_idx]=='C') octet |= 0x0C;
  else if(rcv_buf[rcv_buf_idx]=='D') octet |= 0x0D;
  else if(rcv_buf[rcv_buf_idx]=='E') octet |= 0x0E;
  else if(rcv_buf[rcv_buf_idx]=='F') octet |= 0x0F;
  else octet+= (rcv_buf[rcv_buf_idx] &= ~0x30);
  rcv_buf_idx++;
  message[message_idx]= unpack(octet);
  message_idx++;
  if(++loop==7)
  {
   message[message_idx]= unpack(0x00);
   message_idx++;
   loop=0;
  }
 }
 if( message[0x00]=='r' &
  message[0x01]=='e' &
  message[0x02]=='l' &
  message[0x03]=='a' &
  message[0x04]=='y' &
  message[0x05]==' ' &
  message[0x06]=='1' &
  message[0x07]==' ' &
  message[0x08]=='o' &
  message[0x09]=='n') {PORTB &= ~(1<>7);
   remain_val= (octet & 0xC0);
   unpack_state= unpack_state3;
   break;
  case unpack_state3:
   masked_val= (octet & 0x1F);
   septet= (masked_val<<2) | (remain_val>>6);
   remain_val= (octet & 0xE0);
   unpack_state= unpack_state4;
   break;
  case unpack_state4:
   masked_val= (octet & 0x0F);
   septet= (masked_val<<3) | (remain_val>>5);
   remain_val= (octet & 0xF0);
   unpack_state= unpack_state5;
   break;
  case unpack_state5:
   masked_val= (octet & 0x07);
   septet= (masked_val<<4) | (remain_val>>4);
   remain_val= (octet & 0xF8);
   unpack_state= unpack_state6;
   break;
  case unpack_state6:
   masked_val= (octet & 0x03);
   septet= (masked_val<<5) | (remain_val>>3);
   remain_val= (octet & 0xFC);
   unpack_state= unpack_state7;
   break;
  case unpack_state7:
   masked_val= (octet & 0x01);
   septet= (masked_val<<6) | (remain_val>>2);
   remain_val= (octet & 0xFE);
   unpack_state= unpack_state8;
   break;
  case unpack_state8:
   septet= (remain_val>>1);
   unpack_state= unpack_state1;
   break;
 }
 return septet;
}

void USART_write(unsigned char *buf)
{
 while(*buf)
    {
       while ( !( UCSR0A & (1<

Flatbed scanner panoramic camera

imsolidstate — Sat, 17 Jul 2010 02:25:42 +0000

I’ve always loved panoramic pictures, especially when they’re printed up big. I’m not new to panoramics, as I’ve done quite a few stitched sequences, as well as true panoramic film photography. A while back I was wondering if I could repurpose the scanning head part of a scanner into a rotating head panoramic camera. After an initial trial with mediocre results, I did some digging and found out that people have made these before. There’s quite a few issues though: fitting a new lens, an IR filter, the proper speed rotating part, etc. An added difficulty with flatbed scanners is the scanning head scans over a white strip before every scan to calibrate the sensor, so if you don’t have something white for the scan head to look at right at the beginning of the scan, you get some really goofy color stripes. Sheet feed scanners aren’t supposed to do this, so I tried one of those but quickly tired of fooling all of the little switches. It always thinks there’s a paper jam.

The scan head sensor is actually pretty cool, and by definition it’s a line scan camera. It would still be cool to set it up as a line scan camera to play with.

After seeing this rig at HAD, I’m convinced I’m wasting my time. Moving forward I will be designing a stepper-driven tripod mount for my camera and use stitching software instead. If anybody has any suggestions on good software to try let me know. I’ve been using Panorama Maker or whatever the Nikon bundled program was called. It just doesn’t always do a very good job, even with the special mount I made that’s supposed to eliminate parallax. I get a lot of blurring at the upper and lower edge stitches. I would also like to experiment with multi-row so I can use longer lenses.

DIY Router table

imsolidstate — Sat, 17 Jul 2010 02:24:42 +0000

I made my own router table because, as usual, what is affordable and available in stores is lame and insufficient for my needs. I don’t really want to spend something like $500 just for a good router table so I made one. I also made my own adapter instead of buying one by re-purposing the fixed base I already had.

I made the base out of 2×4s and Simpson strong-ties. The corner ties are about $5 a piece or you can use two cheaper ”Z-MAX” connectors. The top is 3/4 MDF. You can buy adapter plates for various router brands, or just make one like I did from 1/4″ acrylic that replaced the acrylic bottom piece of my fixed-base router. Use your router to cut a hole in the MDF and then use a rabbeting bit to create the countersunk part the acrylic base fits in. Remember to seal the MDF top with a clear sealer or something similar so the MDF doesn’t expand.

It works great, it’s way better than the $99 hardware store special, and I can use it for workspace in my shop instead of taking it up like a bench-top router table would. When I’m not using it I just lower the router and I have another table to work on.

Electronic choke

imsolidstate — Tue, 25 Aug 2009 23:57:17 +0000

When I had carbureted vehicles, I always hated the choke spring. They never worked right, no matter how much you twiddled with them. They either never pulled all the way off or never closed enough to start on that really cold day when it’s so much fun to adjust chokes.
I thought the design could use some modernization, so I designed a true electric choke. Or maybe electronic choke is more accurate, because “electric choke” just means a heater mounted to the bi-metallic spring.

I used a servo to command a certain choke position, and I designed a simple spring mechanism so that the servo wouldn’t burn itself up trying to get to a position when the throttle was closed and the position of the fast idle cam can’t be adjusted. I didn’t have my CNC machine running at the time or I would have made a housing and ordered a smaller servo so that it all had about the same appearance of an electric choke, except for an extra wire. That extra wire would go to a temperature sensor in the coolant circuit.

I would have also added a dip switch for making adjustments to choke pull off points based on engine temperature. If I ever have another carbureted vehicle I might finish it.

Piezo pump

imsolidstate — Tue, 25 Aug 2009 17:16:55 +0000

Some time ago I designed a piezo pump to demonstrate a concept for an extremely low flow liquid slurry pumping application. The pump was based around AdaptivEnergy’s Ruggedized Laminated Piezo actuator, or RLP-125. AdaptivEnergy also manufactures the Joule-Thief, which is also based on piezo technology. The actuator was driven by the company’s proprietary electronics that they call the Energy Key. I used umbrella valves from Vernay that allow the pump to build pressure and move fluid.

The pump works very well for extremely low flow liquid and slurry applications. The wetted parts of the actuator are 300 series stainless steel, and the valves and housing can be made of a number of materials for resistance to many fluids. This pump design is a great selection particularly if you are moving an abrasive slurry, as there are less contact wear surfaces like in a more conventional pump.

Perhaps the most interesting thing about this pump is that both the frequency and displacement of the element can be varied. This allows the pump to operate at different resonant frequencies for different fluids, and still accurately control flow.

Here is a 3D section view of the model that I made in Solidworks.

Textile needle loom

imsolidstate — Mon, 24 Aug 2009 18:06:40 +0000

Probably the most complicated piece of equipment I’ve designed and built to date would have to be a textile needle loom for Goodrich. This machine is fully instrumented with position sensors, accelerometers, load cells, etc. for characterization of a textile needling process. Every parameter from speed and feed to force and distance is adjustable real time. This was definitely the most challenging mechanical design I have completed. I modeled the entire project in Solidworks to verify the design, and had over one hundred custom parts machined.

Cascade process heater

imsolidstate — Mon, 24 Aug 2009 18:03:17 +0000

One of the first big projects I completed was a machine that supplied a variable heated flow of gas to a process. The temperature and flow of the process gas was controlled to a setpoint with PID loops, and the machine could switch between one of two different gases required by the process both manually or automatically. The process required the flow of gas to be switched automatically at a certain temperature, and had to recognize the change in temperature at any one of twelve thermocouples.

An immersion heater placed inside of a tube was used to heat the flow of gas. A frame was constructed around the heater to support it, and an electrical enclosure was mounted to the frame. The frame was mounted on wheels so that it could be removed when not needed, and full-flow quick disconnects were used for the gas lines.

This project was also my introduction to AutoCAD. I designed the whole thing in AutoCAD, including assembly prints and prints for the machine shop. Since then I’ve been using Solidworks, and I’ve never looked back. Solidworks makes designing and maintaining a design so much easier.