Is it possible to seek to the last line of a file without having to read it all into memory? I want to be able to "pick up where I left off" in terms of number being played with but my file will be way too big to read through the whole thing.

Thanks.

http://www.ebay.com/itm/360507624892
I just got one of these. It's a gamble, I hear sometimes they bloat up or catch fire. But mine seems find so far except that I can't figure out how the indicator lights work.

Is this Roland pickup a midi device? If so you should not have any trouble interfacing with it.
http://arduino.cc/en/Tutorial/Midi

If you are considering doing anything with actual analog audio, forget about it, the arduino can't handle it... Unless you want very basic info from it, certainly not transmitting it.

But on the shield they are supposed to be independent. What I'm saying is, I can't even get the SD card to work when I completely ignore the Ethernet stuff. I have no problem with the Ethernet stuff. And I am aware that there is some conflict when using both. But I am running code as if it were just the SD card and it doesn't work.

For instance the cardinfo sketch:

Code:

/*
  SD card test
   
 This example shows how use the utility libraries on which the'
 SD library is based in order to get info about your SD card.
 Very useful for testing a card when you're not sure whether its working or not.
 
 The circuit:
  * SD card attached to SPI bus as follows:
 ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila
 ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila
 ** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila
 ** CS - depends on your SD card shield or module.
  Pin 4 used here for consistency with other Arduino examples

 
 created  28 Mar 2011
 by Limor Fried
 modified 9 Apr 2012
 by Tom Igoe
 */
 // include the SD library:
#include <SD.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 4;   

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("\nInitializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output
  // or the SD library functions will not work.
  pinMode(10, OUTPUT);     // change this to 53 on a mega


  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card is inserted?");
    Serial.println("* Is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    return;
  } else {
   Serial.println("Wiring is correct and a card is present.");
  }

  // print the type of card
  Serial.print("\nCard type: ");
  switch(card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      break;
    default:
      Serial.println("Unknown");
  }

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    return;
  }


  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  Serial.print("\nVolume type is FAT");
  Serial.println(volume.fatType(), DEC);
  Serial.println();
 
  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
  volumesize *= 512;                            // SD card blocks are always 512 bytes
  Serial.print("Volume size (bytes): ");
  Serial.println(volumesize);
  Serial.print("Volume size (Kbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print("Volume size (Mbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);

 
  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);
 
  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
}


void loop(void) {
 
}

returns:

Initializing SD card...initialization failed. Things to check:
* is a card is inserted?
* Is your wiring correct?
* did you change the chipSelect pin to match your shield or module?

I've tried all of the example sketches for the SD card and they all fail to initialize the card.

Pretty much any digital reading from an aquarium except for temp is going to very expensive, just be prepared for that.

I'm trying to use the microsd card slot on my ethernet shield and it is not working. I'm not even trying to run ethernet stuff yet, just SD card examples. I've tried the code in this thread and a few others with no luck. I've formatted the card several times with windows and the official SD formatting tool.

Now I am reading that the ethernet library messes with the SD library, but if I'm not even trying the ethernet library should there be any reason for the SD card to not work? Do I have a different problem in this case?

If you don't mind waiting up to a month for shipping, these super cheap ones from china are perfectly sufficient. Just look up the wiring for a HD44780 and adjust your pot and it's good to go, pretty simple. I've gotten two from two different sellers and both were slightly different but same pinout and both work great.

I found the SD card breakout to be pretty simple and that would allow future modification without reprogramming and the exportation of stats.

I like shiftPWM for when I need the rest of my arduino pins but you are likely to get the same results as softPWM if not worse.

I had a similar idea. Unfortunately building the actual machine would likely be the hardest part. However I recently found in target a little electronic candy dispensing toy.

Something like this:
http://www.jcpenney.com/dotcom/for-the-home/departments/kitchen-dining/food-food-prep/food-gifts-candy/candy-magic-candy-dispenser/prod.jump?ppId=1dbbad9&sisearchengine=182&siproduct=GooglePLA&cm_mmc=ShoppingFeed-_-GooglePLA-_-For%20The%20Home-_-1dbbad9&srccode=cii_17588969&cpncode=35-16030842-2

Howver like strykeroz said, this isn't something that you're going to be able to throw together immediately. I suggest breaking the project down into pieces and figuring out each on individually, then work on putting them together.

If you use a premade candy dispenser, I would expect it to be easier, but don't expect it to be simple work to get it working with the arduino.

Not sure if it fits your needs but this thing produces virtually no heat and can be dropped in place of a 7805, same size and pinout. And for how cool it is it's not very expensive either.
http://www.newark.com/jsp/search/productdetail.jsp?sku=72R3616

Yes, with no resistors those LEDs may be creating too much of a short so the 74141's aren't being powered properly.

Have to tried manually shorting the pins on the nixies to ground to see if they light? Or manually shorting one of the 74141 pins to 5v to see if 0 or 1 displays properly? Doing those two things should narrow down the problem. Just be careful, obviously.

While this would definitely suit my needs, I was hoping to get the actual current. That way every few seconds I could see what the current was then at the end I could get an actual mAh reading rather than just a voltage/time number. Could I still do that?

I am interested in performing the typical which battery lasts longest experiment with some AA and AAA alkaline batteries. The idea was to simply put maybe a 20ohm resistor in circuit with it then measure the voltage. 1.5v / 20ohms = 75mA so my current in mA = analogRead / (1024 / 5 * 1.5) * 75... Or something like that, just a general idea.

My question is, when the voltage of the battery drops, is this equation still valid or will it not account for a dying battery? Because obviously that's the point.

Secondary question, I might not even worry about it, but can I drop the vRef to 3.3v by simply wiring it on the breadboard or PCB and connecting vRef to a 3.3v source? Then obviously the equation would change.

Thanks.

http://arduino.cc/forum/index.php/topic,45626.0.html