After opening up the furnace i found a board with blinking lights repeating pattern 3 green 1 orange and infrequently changing to 3 green 3 orange. These codes translated to blower motor not running at the right speed or not running at all. Starting a search for the solution on the net I’ve stumbled on this long thread which suggested that this might be due to a failed thermistor and that repair could be as simple as replacing it. Taking the power supply off the motor i was happy to find a charred and broken apart thermistor.

The part number was SG348 and after further research i found that this was a Inrush Current Limiter – a thermistor with negative temperature coefficient (NTC) which means that it’s resistance decreases as it gets hotter.  The primary purpose of it is to limit starting current in motors and transformers. This particular ICL thermistor has a resistance of 1 Ohm when it’s cold and can sustain 20 Watt of power. It was made by RTI Electronics under the brand name of SURGE-GARD and was often used in GE motors. The SG348 is not longer in production, but SG100/SG301 can be used instead. In fact any NTC thermistor with room temperature resistance of 1Ohm and 20A maximum current (or 1Ohm*20A=20Watt maximum power). In fact  DigiKey had 3 parts satisfying that requirement with 570-1041-ND being the cheapest at $1.77

Finding the replacement part was easy – finding it locally proved impossible. So after calling all of the local electronics stores I had no choice but to order from DigiKey and wait for the part to arrive. In the mean while i started looking for a work-around. Some people on the forum suggested short-circuiting contacts where thermistor was but i found it too risky. I decided to place a fixed resistor in place, however finding one that would not melt down at 20A was also not easy. Luckily, a local Radio Shack still had some memories of it’s former glory and carried 1 Ohm 10W resistors. Putting them in parallel to distribute the load i had a temporary work around:

Workaround using Radio Shack's 1Ohm 10W power resistor

This solution was a better alternative to the short-circuit however it reduced the efficiency of the fan essentially by wasting energy in the resistor all the time rather than only during startup as in case of a ICL thermistor. The picture above is after fan has been working for a week or so and you can see those resistors heated up quite considerably and even melted down part of a rectifier nearby. There was also a discoloration on the end of one of the resistors.  so i can certainly can’t call it a perfect solution but it worked for me.

Here’s how the power supply looked like with the replacement parts in place:

Replacement Inrush Current Limiting Thermistor in place

At the end, the most impressive part for me was the power internet allowing free peer to peer sharing of knowledge. I was pleasantly surprised how easy it was to find this knowledge on the net and how valuable it was – was I call a HVAC technician it would cost me several hundred dollars in replacement power supply or even entire motor.

I decided to start small and make a couple of pairing knives using stock removal method:

#1 Front

#1 Back

I designed the shape of the blade using Photoshop’s vector graphics with an aesthetic goal in mind and hoping that it would be somewhat functional as well. The shape is all curves with no straight lines. Although I am pleased with the how knives look, it would benefit from a narrower blade for everyday practical use.

#2 Front

For the steel I used O1 1/16″ thick stock which I then heat treated to 60 HRC using electric kiln for austenitizing and kitchen oven for tempering. I don’t have hardness testing equipment so I can vouch for 60 HRC (at least that’s what I should have theoretically). Blades have been mirror polished using black and white rouge. As you can see below I still have to master my sanding techniques – there are a lot of deep scratches that polishing does not hide. I’ve etched both blades using electrolysis using nail polish lacquer for ground. Again, a lot of mistakes made and a lot learned from those mistakes. Nail polish lays down thick but chips when scratched producing jagged edges. Electrolysis is fast in removing metal but does not produce an even etch.

#1 Blade

#1 Blade

#2 Blade

#2 Blade

Guard is made out of brass and again i avoided straight lines which made the job of fitting it with the handle so much harder.

Handle is made out of Jatoba or Brazilian Cherry which i sawed out of left over parquet planks. Jatoba is one of the hardest woods in the world and makes for a heavy handle. I sealed it with Tung oil and wax. Another lesson learned – tape the wood completely before polishing to prevent black polish and metal particles from getting into the wood pores.

#1 Handle

#1 Handle

#2 Handle

My choice of O1 was dictated mostly by availability and price and although i was aware that it easily rusts i was planning on taking a good care of it and not letting it be rust. Well, after couple of months of use here are results:

After months of use

Rusted Closeup

Rusted Closeup

The blue-gray-yellow background is patina expected from regular use and even valued by some knife-enthusiasts. This patina appeared almost immediately. The rusted blotches however are the result of leaving the blade with some water on it for couple of hours. The patina and rust does not reduce cutting qualities of the knife as long as rust is not on the cutting edge. However pits caused by rust will invite more rust and a place for bacteria to hide. Hindsight, the non-stainless steel is not a good choice for the pairing knife since it is used frequently and for short-duration jobs, so wiping it off after every use can quickly become tiring. However after 10 minutes on the polishing wheel, the knife can be restored back to it’s former glory (almost):

After Polishing

After Polishing

Wheel Balancing Jig

Here’s the jig itself:

Balancing Jig

Balancing Jig

And here is how it fits the wheel:

To manufacture it, first drill a piece of wood and then turn it on a lathe to the inner diameter of the wheel. Drilling it first ensures that the hole that thread emerges from is exactly in the center of the wheel. Here are before and after photos. I managed to balance one wheel (not shown) to be pretty much horizontal, however with the second wheel (shown) the jig did not extrude far enough out of the wheel which made it overly sensitive, so i could not make it exactly horizontal.

Before Balancing

After Balancing

Hey Aleksey,

See attached photos.

I recently built & installed your makiwara assembly in our aikido dojo to help us learn to punch more authentically. Since I had to anchor it to a cement block wall, I decided that using screws to anchor the boards might not be strong enough. Instead I used stove bolts which you can see in the photo where I removed the cover plate. Basically, the wall board is screwed into the masonry anchors (#12 x 2.5″ screws) after first inserting the stove bolts so they face outwards. BTW, drilling masonry requires patience and knowledge that if you hit something stronger than the bit, just drill another hole. Then each spacer board and the striking board assembly are jiggled onto the bolts which are then tightened with the nuts and thereby secure all boards as one unit. The cover plate just protects the users legs from the ends of the bolts and it looks nicer.

I also DS taped an old Microsoft mouse pad and then stapled some scrap leather to the top of the striking board instead of the traditional sisal. So far, sensei skinned his knuckles on the leather already, and I loaned him my daddy’s old bag gloves, but my hands are tougher than his and the leather seems just right as long as I strike properly.

I built your project because our sensei commented that it would be cool to have, but also because I want to build your accelerometer to get me back into electronics. Thanks for taking the time to document this project. Yes, you may post the pix and these comments.

Cheers,

Brian Dubberley

eZ430-F2013 development tool

It consists of a USB dongle and a replaceable breakout board with MSP430F2013 processor on it. The dongle allows programming and debugging (which is super cool coming from arduino world). The are interfacing through the 4 wire JTag/SpyByWire. The purpose of this setup is to familiarize developer with the processor family and development environment and perhaps move them to more expensive programmers and tools. What you can also do is to solder a board header on the processor part of it and connect to other peripherals:

Target board for EZ430-F2013 with header soldered

This all is fine and dandy, however i soon hit it’s physical limitations: my prototype breadboard needed to be very close to dongle and i could not use it to program a stand alone processor. Although the first problem could be solved by USB extension cord, the second one needed a more involved solution:

EZ430-F2013 JTag breakout cable

EZ430-F2013 JTag breakout cable - dongle

This is essentially an extension cable that connects to the dongle on one end and has a breakout pins on the other end. The breakout pins can be connected to the microcontroller on the breadboard which can be some distance away from the dongle. Hopefully with this i can program any 4 wire JTag/SpyByWire based microprocessor and don’t have to shell out $99 for the MSP430 USB Debugging Interface.

Here’s the parts list:

• Development tool: EZ430-F2013
• 0.05″ Female 4 position connection header: LPPB041NFFN-RC
• 3/64″ Heatshrink sleeve: F221B3/64 BK100
• 4 conductor cable
• Ferrite bead (optional for short cable, took mine mini-usb to usb cable)
• Connection pin 22-26AWG: 5-104505-3
• 1/8″ Heatshrink sleeve: Q2-F3X-1/8-01-QB48IN-25

Couple of warnings:
The 4 wire JTag/SpyByWire interface does not have any error correction in it and is not designed for distances of more than 1 foot, so keep your cable as short as possible. There are several tricks to make it work over longer distances, but to be sure just make it long enough to allow for breakout and then use USB extension cord for distance. I have managed to push it to about 3 feet but in retrospect it was probably not worth it. Anyway, to make it longer you can try (courtesy of Ricreations, Inc):

• Use twisted pair cable and twist TCK/Test wire with GND wire
• If you can’t twist the whole cable at least twist them at the end (like i did)
• Use a ferrite bead (like i did0
• Put 220 Ohm resistors in serial with TCK and TDO lines

Enjoy,

Aleksey

This image is saved at 300 dpi

Be forewarned, however, soldering this tiny thing is not easy as it comes in 20-PIN LPCC package only which has all of it’s contacts under the chip, however, pre-soldering board and using lots of liquid flux and letting the solder float under the chip should do the trick.

This project took some time, but the savings and most importantly DYI pride are well worth the effort.

Enjoy!

Noise

I have measured the output of ADXL193 accelerometer with the Digital Storage Oscilloscope so here’s how it looks through time as read at the sensor location:

ADXL193 output during AD conversion

AD conversion frequency

As you can see there’s a definite noise caused by the AD conversion which happens 44kSa/s, however this noise should have no effect on the readings as it happens after the AD7680 AD converter latches the input voltage level. Here it is again with Chip Select on the other channel and another wave showing SPI clock. As you can see interference starts way after CS goes down and is actually due to the SPI clock. You can also clearly see 3 transmissions 1 byte each in length:

ADXL193 out and CS

ADXL193 out and SPI clock

I am not sure why scope captured CS going down twice, but the second one is the true reading. The spikes at times when CS goes down and up are not there when CS is not measured, so i believe it’s the scope’s impact. There’s definite additional noise at the start of 3rd transmission – it’s source, however, escapes me.

Below is the signal at the AD7680 AD converter input which is worse then at the sensor due to the long cord picking up more interference:

AD converter input - no filtering

Collected data from results of AD conversion shows a range of 15-25 mV which matches the noise level of 14 mV peak to peak between spikes. If the SPI transmission spikes were getting into AD converter I would expect 40+ mV of noise which isn’t so.

So, after rejecting visible spikes as the source of the noise i started to look at the signal between spikes:

Noise between spikes with FFT

The frequency analysis with FFT (Fast Fourier Transform) shows predominate noise at 3 Mhz and also at 2 Mhz and 1 Mhz. After trying to find the source of this noise i discovered that it is inherent in any circuit including simple probe ground to probe tip loop. With help from the folks at EEVBlog’s Forum i figured out that this is due to the FM radio and that the solution is to use low pass filter to weed these frequencies out. Since i am sampling at 40 kSa/s, i can’t see anything above 40 Mhz, so there’s no harm in putting a 10-40kHz low pas filter. Here is result with such low-pass filter enabled in the scope:

AD input with low-pass filter

The noise level is reduced to about 2.5 mV which is only 0.3 g. So the lessons learned here are a) beware of radio noise when measuring small signals and b) to avoid that noise do AD conversion very close to input source and put a low-pass filter. The AD193XL breakout that i got from SparkFund did have a 10nF decoupling capacitor but it is connected between VCC and GND filtering power supply rather than output.

Acceleration vs Momentum

After i asked if acceleration is the right measure to use a lot of people responded and suggested that although the Momentum (mass*velocity) is a better measure of energy transfer the peak acceleration is the good indicator of that. Although i agree with that, i figure that the answer depends on the purpose of the punch.

If the goal of the punch is to move opponent then the greater momentum or energy your punch can transfer the faster opponent will move. Momentum is mass of the board * velocity of the board or in terms of acceleration mass * integral of acceleration. Energy is mass * velocity^2 / 2 so it’s also dependent on acceleration integral.

However, if the purpose of the punch is damage (or pain), then compression of soft tissues is your goal. Consider following model for human head:

Two Mass & Spring model of human head

If a punch force is small but nevertheless applies for very long time the whole head (both masses M and m) will end up moving very fast, however the spring will be compressed very small (F/K where K is spring coefficient) and once the punch force is removed there will be little vibration. Most of the punch energy will go into the kinetic energy of the total system movement rather than oscillation.

if however, the punch force is really large but acts during a very short period of time, the spring will compress significantly and once the force is removed most of the energy will be in the oscillation of tow masses rather then them moving in the same direction away from the punch. If the interaction time is instant then in fact all of the punch energy will be transferred into the movement of mass M which then will cause spring to compress the largest.

So it’s the maximum force we’re looking for which is proportional to board acceleration. It is interesting to note that the two hands having the same energy or momentum but different weights will produce different forces and therefore damage. I would expect the heavier hand moving slower will have greater interaction time and therefore smaller force compared to the smaller faster and more “force full” hand – Bruce Lee’s fans rejoice. This however is provided that both hands have the same energy or momentum, which is usually not the case when comparing lightweight and heavyweight fighters. Again, energy is proportional to force * distance the object moves under the force. Since distance is the same and heavyweight fighters have more muscle mass and therefore can produce greater force will end up with more kinetic energy to transfer to target. Which effect will win: slower speed vs larger energy is beyond me.

Will Robertson from University of Adelaide, Australia sent me an interesting research article comparing full reverse punch against short (3 inch) power punch: A comparison of the reverse and power punches in oriental martial arts. There’s a good discussion of force vs momentum starting on page 16.

Long Capture

I have also had a chance to capture a longer time sequence of readings using the scope, so here’s the chart covering most of the action:

Acceleration, Speed and Position of Punch Target

Note: lines have different units and are not plotted to scale.

The plot shows the board acceleration, velocity and position until it reaches maximum deflection. I was surprise that the acceleration has such complex shape rather than simple hill. In my correspondence with Will Robertson, he also explained that after the initial contact with the hand the board can start moving faster than the hand and interrupt the contact. There’s the inverse relationship between the force of the strike and the interaction time – the harder you hit something, the faster it escapes your reach. I think this graph shows that effect in the first dip of the acceleration – board got away from the hand and started to slow down due to tension until the hand reached again and accelerated it even farther. You can also see consecutive vibration where acceleration goes between a positive and negative values and speed fluctuates accordingly until the board comes to rest. I believe this is a different effect from the first two hills and is the vibration of board + completely extended hand as the hand is trying to keep they board flexed. On one of the even longer captures that i have made i could see the actual board release and another set of damping oscillations as the board comes to rest in it’s original position.

Here’s how it starts:

Swann Night Hawk Camera

And here is how it ends:

Swann Night Hawk Camera - Teardown

Swann Night Hawk Camera - Teardown

Dissasembly is very easy – front of the camera unscrews by hand and the rest is all regular phillips screws:

The first board that you see when you unscrew the front of the camera is the LED board. There’s an o-ring (not visible on the photo) between the front and the back of the camera which provides protection against elements and it more or less does it job – inside of the camera case look clean and water free. Main elements on the LED board are the 12 infrared LEDs connected in series of 3; light sensitive resistor which turns LEDs on in low light conditions; and 2 position DIP switch marked “ON KHS22″ which selects the transmission channel (1 through 4) . The back side has a 3 pin device marked Y2, a 5 pin chip marked 3272 – probably an op-am, and a variable resistor to adjust sensitivity. Board is marked with AEE, V812IC10:

The second board is the image sensor and 8v to 5v conversion board. It is marked with V801CV28. Notable components include image sensor – no markings on top but based from Swann’s specifications is a 1/3″ Color CMOS, 510 x 492, 380 lines sensor in a 48-CLCC package rated for 5 volts. Sensor is covered by the focusing cover which allows adjusting sensor to lens distance via rotation of the lens holder. On the back of the board there’s a 14.318 MHz (NTSC sampling frequency) crystal. Voltage conversion is done via 75L05 5v voltage regulator and a 10 uF, 5v capacitor. In the entire camera only LEDs are using supplied 8v from the power supply, rest of the components use 5v supply:

The third board is the RF board and is marked VT24A0X4 040315. This board is connected to video sensor board via yellow data wire, red (torn out on the photo) and black power supply wires. It is also connected to the channel selection switch on the LED board via white and yellow wire and to the Microphone board via the white data wire. Board contains following chips: “bj8p153snj ar03-a 0812″ which is a 2.4Ghz transmitter (channel selection switches are soldered directly onto 2 pins on the chip); 17.734475 Mhz crystal which i could only identify as PAL related frequency. On the back there’s “E07SL E1C744 M52″ which i found is described as “Single Serial Input PLL Frequency Synthesizer On-Chip 2.5 GHz Prescaler”. My RF knowledge is very limited so i did not pursue this board any further:

Fourth board is the microphone and power jack board. Unlike the main camera case this one is not protected via o-ring and shows quite a bit of water damage. I consider this a major flaw in design as at least one camera in my possession failed because connections on the circuit board rusted out. The board contains a microphone, a side switch perhaps for enabling/disabling audio and something with 3 pins and 4th large ground marked “8A 804″:

I have also acquired a cheap Swann Receiver:

Swann Wireless Receiver

Conclusion:
Out of 4 cameras that were broken i have managed to fix two. First one had rusted out power supply connection and what looks like a bad case of electronics-rage: all camera innards were twisted and ripped but then stuffed back and closed (why?). After re-soldering all wires and patching rusted out connections on the microphone board, camera came alive once again. Another camera had a bad transmitter. I figured that one out by connecting two cameras to the same power supply and rewiring the sensor of one camera to use transmitter of the other. After installing good transmitter board from another camera this one started to work as well. The other 2 cameras seem to have bad sensor board/chip. One of them has a short (12 Ohm) between power and ground which i was unable to trace and another just doesn’t output anything. Perhaps i can give it a try later when i am more experienced. If some one out there has any ideas or the pointers on how to decode these “Y2″ and “8A 804″ devices please let me know.

Aleksey

DIY Cardboard Lighting Tent

DIY Cardboard Lighting Tent - back

DIY Cardboard Lighting Tent - inside

Granted this works different from true lighting tent – true lighting tent is lit from outside and diffuses light with all it’s sides. My lighting box bounces light from top and inside of the box. Nevertheless, results are very good compared to no light box at all, so while i would recommend replacing commercial lighting tent setup with this, it should work great when no such set is available or your scale of operations just does not justify $150+ investment into commercial lighting tent and lights. One requirement though: you need an on-camera flash unit for this to work – the main path of light needs to point to the roof of the box so you need a flexibility to adjust the flash direction (pardon my crude drawing):

DIY Cardboard Lighting Tent - diagram

Materials

• Cardboard box, bankers box preferred
• Tape
• Paper

Construction

• Assemble the box
• Cut out the side of the box that connects to the large bottom piece – that piece becomes the roof
• Tape box together where it’s loose
• Lay out with paper
• Insert the roof piece and bend it to form the roof. If the piece bends too much, use following “device”:

DIY Cardboard Lighting Tent - bend limiter

That’s all there’s to it. Here’s before and after pictures of my Punch Sensor:

Acceleration Sensor

Punch Acceleration Sensor

More photos:

Beginner Arduino Notes.

Any Arduino based program has at least 2 entry points:

void setup()
{
}
void loop()
{
}

ISR (TIMER1_OVF_vect) 
{
}

This is an interrupt handling routine for the Timer1 overflow interrupt. Just writing this code however is not enough as you need to enable that interrupt. Some of the interrupts are already handled by Arduino Wire library (such as Timer0 overflow) so they are not available to user code without additional steps.

There are several ways to do i/o operations. Arduino provides friendly pinMode(), digitalWrite(), digitalRead() functions but you can use native AVR way of reading/writing to various microcontroller registers.

Reading from A/D Converter.

The AD7680 A/D converter is read using Serial Peripheral Interface (SPI). The initialization of this interface is done within setup() function:

  // initialize SPI interface
  digitalWrite(CS_PIN,HIGH); // initial value
  pinMode(CS_PIN, OUTPUT);
  pinMode(SCK_PIN, OUTPUT);
  pinMode(MISO_PIN, INPUT);
  // configure SPI to: enable, master, clock high when idle, sample on falling edge, freq divider 4
  SPCR = (1<<SPE) | (1<<MSTR) | (1<<CPOL) | (1<<CPHA); 
  SPSR |=  (1<<SPI2X); // double the clock speed

SPE bit enables SPI, MSTR bits set’s microcontroller to be the master, DORD=0 for most significant bit first order, SPR1=0 and SPR2=0 to set clock frequency to the processor clock divided by 4 but it is then doubled by setting SPI2X bit of SPSR register so in the end it’s the chip clock/2.

CPOL=1 and CPHA=1 settings could be very confusing (they were to me) so an additional explanation is required. CPHA sets clock phase and CPOL sets clock polarity. These settings determine when the data is sampled and have to match between the master and slave. Here’s the timing diagram for the AD7680:

AD7680 Timing Diagram

Note that when CS is set AD7680 expects clock to be high and that the best time to read data is on the raising edge of the clock. Now here are 4 modes of SPI operation for microcontroller set by the CPHA and CPOL bits:

ATMega SPI modes

As you can see from the diagram, the mode that matches AD7680 diagram is mode 3 where CPCHA=1 and CPOL=1. It also starts with SCK high and samples on the raising edge of the clock.

To perform an actual reading, following code is used:

  digitalWrite(CS_PIN,LOW); //   start ad conversion
  SPDR = 0; // start transmission of byte 1
  while(!(SPSR & (1<<SPIF)));
  byte b1 = SPDR;
  SPDR = 0; // start transmission of byte 2
  while(!(SPSR & (1<<SPIF)));
  byte b2 = SPDR;
  SPDR = 0; // start transmission of byte 3
  while(!(SPSR & (1<<SPIF)));
  byte b3 = SPDR;
  digitalWrite(CS_PIN,HIGH); // end transmission
  unsigned int reading = (b1 << 11) | (b2 << 3 ) | ( b3 >> 5 );

SPDR is SPI Data Register. Writing to the register initiates data transmission. SPSR is SPI Status Register. When a serial transfer is complete, the SPIF Flag (SPI Interrupt Flag – most significant bit of SPSR) is set. So once we write 0 to SPI Data Register, we need to wait until SPI Interrupt Flag is set. That’s what while(!(SPSR & (1<<SPIF))); does. After which we can read results of the transmission from SPI Data Register. If you look at the AD7680 timing diagram above you will also see that AD7680 starts transmitting data on the 4th clock and ends on the 19th. I can’t instruct microcontroller to wait 3 clocks and then start reading so I have to tell it to get all data including leading and trailing zeroes. The ( b1 << 11 ) | ( b2 << 3 ) | (b3 >> 5 ); line extracts the useful 16 bits of data from 24 bits (3 bytes) read. First useful byte of data consists of last 5 bits of b1 and first 3 bits of b2: ( b1 << 3 ) + ( b2 >> 5 ), however we have to make it a most significant byte of our result so we shift it by 8 bits left (or multiply by 256): ( b1 << ( 3 + 8 ) ) + ( ( b2 >> 5 ) << 8 ) ). The second useful byte is the lower 5 bits of b2 and higher 3 bits of b3: ( b2 << 3 ) + ( b3 >> 5 ). Combining it with the first byte yields ( b1 << 11 ) + ( b2 << 3 ) + (b3 >> 5 )

Maximum Acceleration.

Detecting maximum acceleration is just a matter of calculating minimum and maximum value of the a/d reading and then converting it to the acceleration in g using following formula:

Acceleration = (ADReading / 2^16 * 5 - 2.5) / 0.008

Here, 2^15 is the maximum 16 bit value which corresponds to the analog voltage of 5V, 2.5 is the no-acceleration value and 0.008 is sensitivity volts per g.

The only tricky part in this part of the code is to know when to reset this maximum acceleration. The rule that i used was: reset when there is a transition from “rest” state to not “rest” state. The “rest” state is defined as system has not been experiencing acceleration for that past 0.5 sec. In order to implement this rule there are 3 state variables:

• atRestJit – no acceleration at the moment
• atRestJitTS – time stamp when atRestJit changed
• atRest – the “rest” state

atRestJit is a “jittery” at rest and changes every time acceleration passes 10g threshold. The atRest is then calculated as follows. If atRestJit is false then atRest is false as well. When atRestJit is true and has not changed for the last 0.5 sec then aRest is true.

Displaying Results on 7 Segment LED

Displaying Single Digit

As described in the previous post, in order to display a digit on a 7 segment LED display we need to set the pin that selects the digit to high and then pins that select the segments to be lit to low. In this implementation, digit select pins are driven directly from ATMega while segment selection pins are driven by shift register.

Digit selection pins are bits 2,3,4,5 of the PortD which corresponds to pins 2,3,4,5 on the Arduino board as well. These can be set via digitalWrite(2, HIGH); but also directly via PORTD |= (1<<PORTD2);.

Segment selection is driven by sn74hc594 8bit shift register. First step is to computer the value to be sent to shift register and that is done via the switch statement. Note that since the segments that we want to turn on have to have LOW value, the value to be sent to register is inverted (~):

  switch(char_to-display)
  {
    case '0':
    case 'o':
    case 'O':
      segments = ~((1<<SEG_A) | (1<<SEG_B) | (1<<SEG_C) | (1<<SEG_D) | (1<<SEG_E) | (1<<SEG_F) );  
      break;
      
    case '1':
      segments = ~( (1<<SEG_B) | (1<<SEG_C) );  
      break;
....

Sending it to shift register via SPI interface is a breeze:

  // shift out segments
  shiftOut(SEG_SER,SEG_CLK,MSBFIRST,segments);
  // need to pulse clock high one more time since register is 1 clock behind data in
  digitalWrite(SEG_SER,HIGH);
  digitalWrite(SEG_CLK,HIGH);
  digitalWrite(SEG_CLK,LOW);

Here SEG_CLK is clock and mapped to Arduino pin 6 (Port D 6) and SEG_SER is data on Arduino pin 7 (Port D 7). The only tricky part is that clock needs to be pulsed one more time because in this implementation shift register clock (SRCLK) and storage register clock (SRCLK) are tied in together and when that happens data that is output by sn74hc594 is always one clock behind data that is sent to it.

Displaying Multiple Digits

The easiest way to display multiple digits is just to display them one after another:

while(true)
{
   DisplayDigit(1);
   delay(100);
   DisplayDigit(2);
   delay(100);
   DisplayDigit(3);
   delay(100);
   DisplayDigit(4);
   delay(100);
}

However if I were to do that then the program would not do anything else but display digits. The solution is to use interrupts on the timer:

int digit=1;
void timer_interrupt() // assume timer is set to call this every 100 ms
{
   DisplayDigit(digit);
   digit++;
   if (digit>4) digit=1;
}

The implementation is very similar to that, except an additional timer interrupt is used to turn all digits off 0.6 ms after they been turned on. This is done to avoid burning LEDs out since no current limiting resistors were used. 16 bit Timer 1 of the ATMega is used for this purpose:

void setup()
{
  TCCR1A = 0; // normal operation. other modes are used for PWM
  TCCR1B = (1<<CS10); //Set Prescaler to clk/1 : freq: 16Mhz, 1 click = 0.0625 micro secs
  TCCR1C = 0; // no forcing output compare
  OCR1A = BRIGHTNESS; // output compare a value - brightness (10,000)
  TIMSK1 = (1<<OCIE1A) | (1<<TOIE1); // Output Compare A Match Interrupt Enable, Overflow Interrupt Enable. Overflow will happen every 2^16 ticks. freq: 244.14 Hz
}

byte currentDigit = 0;

// called on timer1 overflow - 244 Hz
ISR (TIMER1_OVF_vect) 
{
  LED7x4_display_digit(currentDigit);
  currentDigit++;
  if (currentDigit>3) currentDigit=0;
}


// called BRIGHTNESS ticks after overflow
ISR (TIMER1_COMPA_vect) 
{
  // turn off all digits
  DIG_PORT &= ~( (1<<DIG_1) | (1<<DIG_2) | (1<<DIG_3) | (1<<DIG_4));
}

Miscellaneous

In order to produce the chart in the first part of this post, different code was used. This code would continuously store data in internal buffer overriding old values when it ran out of room (which happened pretty quickly since the ATMega328 internal SRAM is only 2k so i could store no more than 900 16 bit samples). When an acceleration event was detected, program recorded next 800 samples and then printed entire buffer via Serial interface. This provided 100 samples before the acceleration event as well as 800 samples of the event itself. At first I have attempted to print to serial directly as A/D is read but even at highest baud rate I was missing a lot of data, so i had to switch to this store and print approach.

Overall, the programming aspects of the project was quite enjoyable with the exception of cryptic c++ errors that i was getting from time to time (mostly from forgetting basic things like how break code between .h and .cpp files). One annoying thing that i’ve encountered is the lack of clear documentation on which Arduino/Wire library to include for various purposes. I wanted to use a boolean and byte types but for some reason while they worked in the main file, they didn’t in the LED7x4.cpp file. Turns out they are not built in types but instead defined in some .h file. It took a while to figure out which .h file i need – #include <WProgram.h>. The reason i didn’t need it in main file is that Arduino puts it there automatically before compiling – but not in any of the other files.

Anyway, it was a fun project and I hope some one will find this rather too detailed description useful. I have tried to target it to the starting embedded electronics hobbyist such as myself – this was my first electronics project since college.

Cheers,

Aleksey

Previous: Part 2 – Hardware

Next: Follow up