Show Posts
Pages: 1 ... 57 58 [59] 60 61 ... 110
871  Development / Other Software Development / Re: New fast digital I/O and Software SPI libraries on: October 06, 2012, 10:30:36 am
Languages and other tools help but are a small factor.  This has been the holy grail for over 30 years.  I have seen numerous language/tools projects that were going to insure reliable systems. 

I expected ada to takeover embedded systems but it hasn't happened.  The problem is that ada run-time checks seldom provide needed reliability no matter what AdaCore trys to sell you.

Good architecture and design are far more important than language.  The most important factor is a skilled embedded systems team.

Look at the record of the Cal-Tech Jet Propulsion Lab http://www.jpl.nasa.gov/missions/.  An extraordinary number of successes and few failures.

Here is the table of contents from white paper by a systems house that builds reliable financial systems.  The same ideas apply to reliable embedded systems.  This is not about tools and languages. 
Quote
Architecture Does not Just Happen
Architecture is About People
Divide and Conquer
Formalize the Interfaces
Identify and Eliminate Risk
Eliminate Dependencies
Ensure Full Testability
http://www.imatix.com/articles:how-to-build-utterly-reliable-systems

872  Using Arduino / Storage / Re: Micro SD example - library SD "datalogger" on: October 06, 2012, 09:22:10 am
SurferTim,

Disabling all SPI devices except the SD is required to initialize the SD.   However this may not be the problem here since the SD library make SS an output and sets it high.  For 328 chips SS is pin 10 so the code to disable w5100 is in SD.h.  For Mega this is often the problem with initialization of the SD on the Ethernet shield.

From D:/arduino-1.0.1/libraries/SD/utility/Sd2Card.cpp at line 228.

Code:
 // SS must be in output mode even it is not chip select
  pinMode(SS_PIN, OUTPUT);
  digitalWrite(SS_PIN, HIGH); // disable any SPI device using hardware SS pin
873  Development / Other Software Development / Re: New fast digital I/O and Software SPI libraries on: October 05, 2012, 09:00:05 pm
westfw,

Your right, the cost of making apps based on the Arduino core reliable is too high.  That's one reason why using Arduino to build reliable critical systems is a bad idea.

There is a large literature of studies about the overhead required for reliability in well designed critical systems.  The typical number is 5% performance and size.

I spent most of my career around large particle accelerators and space experiments.  The above percentage matches my experience with real systems.

To achieve this low overhead means putting high priority on reliability in system architecture and design.

In your example, pin number is a variable and appears in every API function.  This mean lots of range checks in libraries that present pin number as a variable in their API.

Often pin number is a constant and you could use a C++ template so no run-time checks are require.  The code will be faster and smaller than the Arduino digital I/O implementation.

If pin number must be variable you can use a C++ object with pin number appearing in only one API function with only one check.

Ways to handle errors that occur deeply in embedded systems was solved in the 1970s for large embedded systems.
874  Development / Other Hardware Development / Re: Teensy 3.0 on: October 05, 2012, 03:56:58 pm
I just started porting SdFat to Teensy 3.0 and am really pleased with Teensy 3.0.  Paul's modified IDE works well.

SdFat has about 8,500 lines of code and it took me about an hour to get it to compile.  I commented out about 100 lines of AVR SPI code.

I found SPI examples on the Freescale website and am starting implementation of SD/SPI access routines.  This should not take long.

The biggest problem is also the biggest opportunity.  With AVR everything was based on the fact that SdFat would mostly be used on 328 processors with 2KB of memory.  This really limited how caching was implemented and what SD command sequences could be used.  Now I need to redesign SD access to take advantage of more memory and processor speed.

I am starting to redesign SD access for better performance.  While waiting for the Teensy 3.0 I experimented with a Mega.  I was able to increase write speed by almost a factor of three by using more memory and multi-block SD commands.

One shock was the old SdFat first ran much slower with more memory.  This is because I had multiple blocks in the cache and user memory and was not writing them in sequential order.  This slowed the write speed from 200KB/sec on an Uno to 90 KB/sec on a Mega.  SD cards love streaming multi-block writes and die with random writes.  Writing the blocks in the correct order increased the speed for this example from 90KB/sec to over 500KB/sec.

The Teensy will have 24 MHz SPI, a faster processor, and more memory so I hope to get 5-10 times faster file write speeds than SdFat on a Uno.

ARM for Arduino is great!

I have started looking at porting ChibiOS/RT to Teensy 3.0 and it also looks easy.  I will make the RTOS a library so you can use it with Paul's core routines and other ported libraries in a multi-tasking environment.
875  Development / Other Software Development / Re: how to go to STM32 / Arm on: October 05, 2012, 08:17:08 am
I suggest you try Teensy 3.0 http://www.pjrc.com/store/teensy3.html also http://www.kickstarter.com/projects/paulstoffregen/teensy-30-32-bit-arm-cortex-m4-usable-in-arduino-a.

I have one and it uses the Arduino IDE with gnu ARM tools.  It's real easy to use.  You just unzip the IDE like the standard Arduino IDE.

Soon, October 22, Arduino will release the Due http://hackadaycom.files.wordpress.com/2012/10/due.pdf.  I suspect it will also be easy to install and use.
876  Development / Other Software Development / Re: New fast digital I/O and Software SPI libraries on: October 05, 2012, 08:07:59 am
Rob,

If you hangout here long enough, you will become one of us and reliably won't matter.  I speak from experience, my standards are slipping.

For most programmers reliably is is handled by taking out the debug checks when software is released so the code is smaller and runs faster.

Here is a quote from long ago:
Quote
Turning off dynamic semantic checks once you've finished debugging your program is like taking off your seat belt once you've left the driveway.

This quote is wrong, modern programmers don't believe in seat belts or airbags.  We are at the level of automobiles 60 years ago, there are no seat belts.

Modern programmers don't diagnose and fix bugs, they turn Bohrbugs into Heisenbugs. One way to make life better for users is to convert Bohrbugs into Heisenbugs.

Quote
This is good enough because Bohrbugs are showstoppers for users: every time the user does the same thing, he or she will encounter the same bug. With Heisenbugs, on the other hand, the bugs often go away when you run the program again. This is a perfect match for the way users already behave on the Web. If they go to a Web page and it fails to respond, they just click “refresh” and that usually solves the problem.

Here is a definition:
Quote
Jim Gray drew a distinction between two kinds of bugs. The first kind are bugs that behave predictably and repeatedly—that is, they occur every time the program encounters the same inputs and goes through the same sequence of steps. These are Bohrbugs, named for the Bohr atom, by analogy with the classical atomic model where electrons circle around the nucleus in planetary-like orbits. Bohrbugs are great when debugging a program, since they are easier to reproduce and find their root causes.

The second kind of bug is the Heisenbug, named for Heisenberg’s Uncertainty Principle and meant to connote the inherit uncertainty in quantum mechanics, which are unpredictable and cannot be reliably reproduced. The most common Heisenbugs these days are concurrency errors (a.k.a. race conditions), which depend on the order and timing of scheduling events to appear. Heisenbugs are also often sensitive to the observer effect; attempts to find the bug by inserting debugging code or running in a debugger often disrupt the sequence of events that led to the bug, making it go away.
Jim Gray wrote this in 1985 and not much has changed.  http://www.hpl.hp.com/techreports/tandem/TR-85.7.pdf
877  Development / Other Software Development / Re: New fast digital I/O and Software SPI libraries on: October 04, 2012, 09:56:07 pm
How are you looking at the pins?

If you connect pin 34 to pin 36 and run the "T - Transfer" command does "AA" print?

If you set pin 36 to GND, does the "R - Receive" command print 0?  If pin 36 is set to 5V, "R - Receive" should print FF.

SS is needed for hardware SPI to work.  SS must be set to an output in master mode so it is often used as chip select.

For software SPI in master mode no SS signal is needed.  You can use any pin for chip select.
878  Using Arduino / Storage / Re: itdb02 sd card : unable to do working on: October 04, 2012, 03:43:09 pm
The card does not return a valid response to a read.  It must not be a true SD card.

SDFormatter 3.1 also rejects it so it won't work in some SD devices.

Windows accepts cards released before the official SD spec and MMC cards.

I didn't add code for these cards to the Arduino libraries since it would increase the size of the libraries and these old cards are now rarely used.
879  Using Arduino / Storage / Re: itdb02 sd card : unable to do working on: October 04, 2012, 12:12:05 pm
Most likely your 16MB card is formatted FAT12.

You can force it to be FAT16 by using the SdFat SdFormatter example located in SdFat/examples/SdFormatter.

All SD cards support SPI.  If your 16MB card is an MMC card, it won't be supported by SdFat or the Arduino SD.h library.
880  Using Arduino / Storage / Re: MicroSD: New Card Issues on: October 01, 2012, 06:00:32 pm
The methods are documented in html generated by doxygen.  

Click on SdFat.html in the unzipped SdFatBeta20120825 directory and explore the Classes tab.

Most of the important methods are illustrated in the examples in the SdFat/examples folder.

There are also examples in the SdFatBeta20120825/extras/exampleV1 folder.  These are older but demonstrate rewrite, seek, remove, and other basic methods.
881  Using Arduino / Storage / Re: MicroSD: New Card Issues on: October 01, 2012, 04:47:10 pm
O.K. - I have seen the CRC problem with other cheap cards.

You can enable CRC with any card and it will increase reliability a great deal.  Data is protected by a 16-bit CRC so SPI errors will be detected. 

Performance for all cards will be reduced since calculating CRC requires CPU cycles.  Run bench using a good card with and without CRC to see the hit.

I suspect that the performance of these new cards is very low.  Edit bench.ino and decrease the file size to one MB by changing FILE_SIZE_MB like this:

Code:
#define FILE_SIZE_MB 1
#define FILE_SIZE (1000000UL*FILE_SIZE_MB)

bench.ino should run in 1/5 the time.  Wait at least three minutes.
882  Using Arduino / Storage / Re: MicroSD: New Card Issues on: October 01, 2012, 01:19:58 pm
Ordering new cards seems like a good idea.

I noticed that BENCH.DAT was created even though open failed.  This means data was written to the card but a failed status was returned.

I am curious to see what happens if you edit Sd2Card.cpp to accept the incorrect return status.

At about line 670 of Sd2Card.cpp change this
Code:
  status_ = spiRec();
  if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
    error(SD_CARD_ERROR_WRITE);
    goto fail;
  }
  return true;
to this
Code:
  status_ = spiRec();
  return true;  // Ignore write response
  if ((status_ & DATA_RES_MASK) != DATA_RES_ACCEPTED) {
    error(SD_CARD_ERROR_WRITE);
    goto fail;
  }
  return true;

Run bench and see if BENCH.DAT contains text lines like this:
Quote
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST
ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRST
883  Using Arduino / Storage / Re: MicroSD: New Card Issues on: September 30, 2012, 07:46:03 pm
I don't think other configuration options will help.

If possible try the card in another Arduino and SD module.  This is a long shot since read operations seem to work with the Teensy.

It may be that the card has problems with single block write commands in SPI mode.
884  Using Arduino / Storage / Re: MicroSD: New Card Issues on: September 30, 2012, 03:04:29 pm
This card fails by returning an error status after a 512 byte data block is sent to the card during a write. The following error code is for a CRC error for the data block.  
Quote
error: write MBR
SD error: 13,b
SD cards should ignore a block's CRC by default in SPI mode.

Try enabling CRC checking by editing SdFatConfig.h and setting USE_SD_CRC to 1 or 2.
Code:
/**
 * To enable SD card CRC checking set USE_SD_CRC nonzero.
 *
 * Set USE_SD_CRC to 1 to use a smaller slower CRC-CCITT function.
 *
 * Set USE_SD_CRC to 2 to used a larger faster table driven CRC-CCITT function.
 */
#define USE_SD_CRC 0
Try the SdFormatter example again.  If this fixes the problem, the card does not function correctly in SPI mode.  The Arduino has no CRC hardware so enabling software CRC will reduce write performance.

Another possible cause is a bad MOSI SPI signal.  I don't think this is the problem with your 3.3V setup.
885  Using Arduino / Storage / Re: MicroSD: New Card Issues on: September 29, 2012, 07:13:40 pm
I wrote SdFat, Fat16, and the base code for SD.h.  These three libraries have similar code but the new beta of SdFat supports more SD cards than other libraries so download and install SdFatBeta20120825.zip http://code.google.com/p/beta-lib/downloads/list.

Run these three examples: QuickStart, SdInfo, and bench.

Post the error codes if any of the above examples fail.  Also post the results of the bench example if it runs without errors.

If all examples run O.K. change this line in bench.ino from this
Code:
#define FILE_SIZE_MB 5
to
Code:
#define FILE_SIZE_MB 25
And rerun it.  This should do a write stress test.
Pages: 1 ... 57 58 [59] 60 61 ... 110