Linduino : Isolated Arduino-Compatible Board for LTC Demo Boards

[quantumvolt]

After I fried my "scope" - an external USB sound card (fleabay USD 10  ) -  modified with DC coupled buffer and level shifter, I was happy I didn't kill the laptop.

I am going to buy a scope, so no more sound cards. But I started to think about opto couplers, battery powering and isolating power supplies and what not for other test and measurement stuff I have that goes into USB.


While I searched the web I found this. It is called Linduino One (Linear Technology "Arduino UNO" ?):




and:

" ... it comes with a LTM2884 uModule that provides full USB isolation ... "
Source: http://www.linear.com/blog/79

"An LTM2884 USB Isolator breaks the ground connection to the PC, allowing projects to operate at a different ground potential than the computer that is controlling it."
Source: http://www.linear.com/blog/b15

It is meant to serve as an intermediate between LT's Demo / Evaluation Boards and a PC:

"This board features a 14-pin “QuikEval” connector that can be plugged into nearly 100 daughter boards for various Linear Technology parts, including Analog to Digital converters, Digital to Analog Converters, high-voltage power monitors, temperature measurement devices, RF synthesizers, battery stack monitors, and more."

But it is also an Arduino clone and can do everything an Arduino can.

The schematic for the board is here: http://cds.linear.com/docs/en/demo-board-manual/dc2026afa.pdf

I will study this and see if I can find a DIY solution for my Arduinos (Yes, I do like them and do use them - my first experience with computers was FORTRAN Punch Cards on a VAC in the early 1970's - and Arduino is much simpler  ).

Edit: Title.

[Richard_Fry]

For anything I've made at home and for products at work, I always connected them to a PC through a USB hub - so there's a less change of the motherboard getting fried from having VBUS connected to D+ etc.
We found out the hard way at work when having to connected all units built to a PC to upgrade firmware and one had 'developed a fault'.
After blowing up 1 PC and then plugging the faulty unit into another PC 'just to make sure' it got figured out!

On the main subject, the Linduino looks quite good.
I've got one of the Demo 590B boards somewhere, but that just connects to LT software for measuring performance etc.
It has opto isolation in the data connections I think, so that schematic may prove interesting reading too.

[quantumvolt]

Yes, I guess I won't do real-time measurements on the USB port anymore 

I have studied the DC590B board a bit (http://www.linear.com/demo/DC590B). It has a PIC. LT does not give the code for the PC GUI. But the Linduino emulates DC590B in addition to being an Arduino clone. And there is open code. Maybe they have libraries that are not with code. I haven't checked yet.

The isolation is cool. I can find no data on it yet, but may be it is similar to ADuM3160 and ADuM4160. I really have not checked anything yet. And I am new to this floating relative USB ground stuff. Only knew about optocouplers.

But I am working on getting my latest (will be # 7  ) Arduino from LT. Hope I get lucky ...

[Linduino]

Hey guys!

Just wanted to say thank you for the interest in Linduino. If you have any questions or comments please do let me know.

Also, just wanted to point out that our library has been updated. We also have an automatic installer that will download our suggested Arduino IDE and point it to the correct library installation, however due to the way the IDE handles library locations this will redirect any existing IDE installs. If you know what you're doing, and it sounds like you guys do, just download the library and stick it in the right folder.

We're planning on keeping all of the library components open source, and we planning on adding to the parts that it supports.

Thanks for taking a look at our stuff and please let me know if there's anything I can do to help.

[quantumvolt]

Hi Linduino - and if you are a LT representative - welcome.

I have kindly been given a Linduino board after asking LT in an email, but I haven't got it yet. But I have been looking a bit at the code. Even if the code is written for dedicated use with the LT demo boards, the code is a well of resources since it obviously (at least parts of it) has been written by a trained professional programmer.

Most code on the web for Arduino is nothing but helpless dumb junk. The Linduino libraries is a very welcome gift of decent more advanced code.

I have already in principle "hacked" the parts of the code that "locks" the QuikEval GUI (LT only gives an .exe-file - you MUST have a LT board connected to make it run) by looking for the USB connected board and it's EEPROM signature. I guess LT is OK with this, since the whole idea with Arduino is openness and reuse.

So I will - after some testing - be able to use the code and GUI software on my own bread-/vero DIY-boards with SPI and I2C. Nothing wrong with the LT demo boards, it is just that either you have to pay (sometimes big) dollars for them or be someone in a company or similar in order to get them.

The gate into QuikEval ( )  (Source: LT Sketchbook from http://www.linear.com/designtools/linduino.php)

Code: [Select]

 

  quikeval_I2C_init();                    //! Initializes Linduino I2C port.

  quikeval_SPI_init();                    //! Configures the SPI port for 4Mhz SCK
  quikeval_SPI_connect();                 //! Connects SPI to QuikEval port

  Serial.begin(115200);                   //! Initializes the serial port to the PC
  print_title();                          //! Displays the title

  demo_board_connected = discover_demo_board(demo_name); //! Checks if correct demo board is connected.

  if (demo_board_connected)               //! Prints the prompt if the correct demo board is connected
  {
    print_prompt(0);                      // Prints prompt and indicates that "A" is selected.
  }

[Linduino]

Well actually if you want to "hack" your boards to work with the QuikEval suite. You can do that with the Linduino.

If you look at the code under Sketchbook->utilities->DC590B

Look for this line:

Code: [Select]

     case 'I':
      // get controller id string
      quikeval_SPI_connect();   // Connect SPI to main data port
      psuedo_reset = 0;
      byte_count = read_quikeval_id_string(&ui_buffer[0]);
      if (byte_count!=0)
      {
        Serial.print(ui_buffer);
        Serial.print('\0');
        Serial.flush();
      }
      break;




If you have it return the right string, then QuikEval will actually pull up the correct demo module. If you send me an email at linduino@linear.com I can help you figure out what the string is.

[Harvs]

Just wanted to say thank you for the interest in Linduino. If you have any questions or comments please do let me know.

A couple of things from me,

Where can you buy them and at what price?  Google just returns nothing useful.

The LTM2884 uModule, what's the story with that part?  No datasheet available?

[quantumvolt]

Well actually if you want to "hack" your boards to work with the QuikEval suite. You can do that with the Linduino.

If you look at the code under Sketchbook->utilities->DC590B

Look for this line:

Code: [Select]

     case 'I':
      // get controller id string
      quikeval_SPI_connect();   // Connect SPI to main data port
      psuedo_reset = 0;
      byte_count = read_quikeval_id_string(&ui_buffer[0]);
      if (byte_count!=0)
      {
        Serial.print(ui_buffer);
        Serial.print('\0');
        Serial.flush();
      }
      break;




If you have it return the right string, then QuikEval will actually pull up the correct demo module. If you send me an email at linduino@linear.com I can help you figure out what the string is.

Thanks. But no need for questions yet. I have already done it. I have found that the simplest starting point for DIY boards is the DAC board DC1333. Of course it would be nice to have an official board, but as LT publishes parts list (a few dollars in total parts cost), schematics and PCB layout I guess it is OK to DIY-it.

So now anyone with an Arduino (if they cannot get their hands on a Linduino) can build quite a few of the LT Demo Boards themselves and use the Linduino code and the QuikEval GUI Test software at a very low cost.

The EEPROM is as you say totally unnecessary for the function of the boards - it just returns a string so that the QuikEval software knows which board is running. This string is just a single line in the Linduino code.

I even see that LT has had to bang the string themselves since there seems to be 4 different refs with the DC1333A DAC board (I have modified the code with info from the LT website). When I have a working emulator for this board (which has an extensive menu), I will make some kind of tutorial. Great fun 

Code: [Select]

void setup()
// Setup the program
{
  quikeval_SPI_init();                  // Configure the spi port for 4Mhz SCK
  quikeval_SPI_connect();   // Connect SPI to main data port
  quikeval_I2C_init();                            // Configure the EEPROM I2C port for 100khz
  Serial.begin(115200);                         // Initialize the serial port to the PC
  print_title();
  demo_board_connected = discover_demo_board(demo_name);
  if (demo_board_connected)
  {
    // The DC1333A does not have the option indicated in the demo board name
    // Uses product name for the option
   
    //quantumvolt begin
    //LTC2640-LZ12: 12-Bit SPI DAC (2.5V ref, Reset to Zero-Scale), req DC590
    //LTC2640-HZ12: 12-Bit SPI DAC (4.096V ref, Reset to Zero-Scale), req DC590
    //LTC2640-LM12: 12-Bit SPI DAC (2.5V ref, Reset to Mid-Scale), req DC590
    //LTC2640-HM12: 12-Bit SPI DAC (4.096V ref, Reset to Mid-Scale), req DC590
    //quantumvolt end
   
    if (strlen(strstr(demo_board.product_name, "-LM")) > 1)
      demo_board.option = 'A';
    if (strlen(strstr(demo_board.product_name, "-LZ")) > 1)
      demo_board.option = 'B';
    if (strlen(strstr(demo_board.product_name, "-HM")) > 1)
      demo_board.option = 'C';
    if (strlen(strstr(demo_board.product_name, "-HZ")) > 1)
      demo_board.option = 'D';
    initialize_dac();
    restore_calibration();
    print_prompt();
  }
}


[Linduino]

Just wanted to say thank you for the interest in Linduino. If you have any questions or comments please do let me know.

A couple of things from me,

Where can you buy them and at what price?  Google just returns nothing useful.

The LTM2884 uModule, what's the story with that part?  No datasheet available?

1) It can be purchased by emailing linduino@linear.com. I believe the official price is $75. We wanted to price ourselves out of the range of being a direct competitor to Arduino. Basically, we wanted people to buy our demo board only if they really really needed that isolation.
The whole point of this project was to provide source code to everyone, an Arduino clone just happened to be the easiest hardware base we could build on.
Usually you can buy it from here: www.linear.com/purchase/DC2026A?
but for whatever reason our website seems to not show it right now.

2) LTM2884, it's actually not released yet. It's a USB isolator, and unfortunately because the datasheet isn't available I can't tell you too much else about it. I know it's handwavy, and I HATE being handwavy but until it's officially released that's the best I can do.

[Linduino]

So now anyone with an Arduino (if they cannot get their hands on a Linduino) can build quite a few of the LT Demo Boards themselves and use the Linduino code and the QuikEval GUI Test software at a very low cost.

That's the goal of this whole Linduino program. Actually the goal was to make it as portable as possible, you don't even need an Arduino. If you're a die hard PIC user, you'd just have to rewrite the LT_I2C or LT_SPI (depending on the protocol you use) libraries and you should be off to the races.

Our goal here was to make it as easy as possible to use our parts.

What's REALLY cool in my book, is if you go to the part pages of our parts, we now have example code. For example: http://www.linear.com/product/ltc1867#code

So if you just want source code reference, you don't even need to download our entire library. It's all available on the LTC parts page. Sorry if I'm rambling, I'm actually really excited about this part of Linduino. I am an Apps Engineer at LTC and the thing is, I've gotten so many questions from small startups or hobbyists about example code. The problem is we just don't have the bandwidth to help a lot of the little guys and Linduino lets us try and help out the people who need it the most.

[quantumvolt]

Well actually if you want to "hack" your boards to work with the QuikEval suite. You can do that with the Linduino.

If you look at the code under Sketchbook->utilities->DC590B

Look for this line:

Code: [Select]

     case 'I':
      // get controller id string
      quikeval_SPI_connect();   // Connect SPI to main data port
      psuedo_reset = 0;
      byte_count = read_quikeval_id_string(&ui_buffer[0]);
      if (byte_count!=0)
      {
        Serial.print(ui_buffer);
        Serial.print('\0');
        Serial.flush();
      }
      break;




If you have it return the right string, then QuikEval will actually pull up the correct demo module. If you send me an email at linduino@linear.com I can help you figure out what the string is.

Very nice well documented code. I have it running on an ordinary Arduino in less than an hour.

However - it seems that the place to change the code is in QuikEval_EEPROM.cpp. Here are the changes I have made:

Code: [Select]

uint8_t read_quikeval_id_string(char *buffer)
{
  uint8_t i, j;                // Iteration variables
  uint8_t comma_position[8];  // Contains the position of the commas in the buffer
  uint8_t comma_count = 0;      // The number of commas found in the buffer
  uint8_t buffer_count;       // The number of characters read
  int8_t option;              // Temporary demo board option
  // read the id string from the demo board EEPROM
  // starting EEPROM address=0, terminator=0x0a, max buffer length=52 bytes
  // Enable I2C

/* quantumvolt commented out
  pinMode(QUIKEVAL_MUX_MODE_PIN, OUTPUT);   // Configure MUX to disconnect I2C pins on QuikEval connector. Remember EEPROM has its own I2C pins on the the

connector.
  int8_t QUIKEVAL_MUX_MODE_PIN_state;
  QUIKEVAL_MUX_MODE_PIN_state=digitalRead(QUIKEVAL_MUX_MODE_PIN);
  digitalWrite(QUIKEVAL_MUX_MODE_PIN, LOW);
  buffer_count = eeprom_read_buffer_with_terminator(EEPROM_I2C_ADDRESS, buffer, 0, QUIKEVAL_ID_TERMINATOR, QUIKEVAL_ID_SIZE+2);
  digitalWrite(QUIKEVAL_MUX_MODE_PIN, QUIKEVAL_MUX_MODE_PIN_state);  // Restore the QUIKEVAL_MUX_MODE_PIN (8) to its previous state.  (But, it will be left

as output.)
*/

/* quantumvolt
The QuikEval ID string has the following 50 byte format :
@verbatim
LTCxxxx,cls,Dxxxx,xx,yy,DC,DCxxxx--------------,\n\0
Example: LTC2309,Cls,D1859,01,01,DC,DC1337A-A,------------\n\0
@endverbatim
*/

// quantumvolt begin
buffer_count= 52;
buffer= "LTC2309,Cls,D1859,01,01,DC,DC1337A-A,------------\n\0";
// quantumvolt end

  if (buffer_count == 0) return(0);   // quit if no data read
  // find comma positions
  for (i = 0; i < buffer_count; i++)
  {
    if (buffer[i] == ',') comma_position[comma_count++]=i;
  }
  // get product name. All characters before the 1st comma.
  for (i = 0; i < comma_position[0]; i++)
  {
    demo_board.product_name[i]=buffer[i];
  }
  demo_board.product_name[i]='\0';  // add terminator
  // Get demo board name between the 5th and 6th comma
  j = 0;
  if (comma_position[6] < comma_position[5]) comma_position[6]=strlen(buffer);  // some demo boards are missing the last comma
  for (i = comma_position[5]+1; i < comma_position[6]; i++)
  {
    demo_board.name[j++]=buffer[i];
  }

  demo_board.name[j]='\0';  // add terminator
  // get demo board option from the demo board name
  for (i = 0; i < strlen(demo_board.name); i++)
  {
    if (demo_board.name[i] == '-') option = demo_board.name[i+1];
  }
  if ((option >= 0x41) && (option <= 0x5A)) demo_board.option = option;
  // final demo board name is 6 characters without the option
  demo_board.name[6]='\0';
  return(buffer_count);
}


When run on an ordinary Arduino Uno this returns in the serial monitor:


*****************************************************************
* DC1333 Demonstration Program                                  *
*                                                               *
* This program demonstrates how to send data to the LTC2640     *
* 12-bit DAC found on the DC1333 demo board.                    *
*                                                               *
* Set the baud rate to 115200 and select the newline terminator.*
*                                                               *
*****************************************************************
Demo board DC1333 not found,
found DC1337 instead.
Connect the correct demo board, then press the reset button.


So this means that the code for DC1333 finds the hard coded signature for the DC1337 board.

Maybe you could publish the code signature for LTC2400. I want to try to run the LTC2400 DVM shield from this thread  https://www.eevblog.com/forum/projects/ppmgeek!-5-5-digit-dvm-volt-ref-cal-%28for-arduino-or-any-uc-w-spi%29/ on the QuikEval software.

Thanks.

[Linduino]

I'll get you this on Monday

Can you do me a favor and send me an email at Linduino@linear.com to remind me please?

[quantumvolt]

I'll get you this on Monday

Can you do me a favor and send me an email at Linduino@linear.com to remind me please?

No need, thanks - it is easy to find by looking at other hard coded names, the 'comma rule' (explained in the code) or reading the EEPROM by using the 'Serial EEPROM Test' code in the LTSketchbook.

[quantumvolt]

For those who might not understand my enthusiasm for the Linduino and the LTSketchbook code library, I will try to explain. First of all it should be obvious that if a large chip maker uses Arduino as a platform for more than 100 demo boards, one might expect many benefits both in software and hardware for the Arduino user group. Afterall, most users of Arduino have very little knowledge and resources to add to the platform or to C++ coding for the Atmega family.

Secondly, LTC has PC software of high class and usability. One very versatile program is the QuikEval GUI test program http://www.linear.com/designtools/software/#QE1 for demo boards. It detects via the computer USB port which of those more than 100 demo boards that is hooked up, and changes user interface and functions accordingly.


The connection chain is: 

PC w. QuikEval         <-- USB cable --       

                                                           DC590B w. PIC and firmware      <-- Ribbon cable --     

                                                                                                                                            Any demo board w. EEPROM signature



The interface board that goes directly into the computer USB port is called DC590B http://www.linear.com/demo/DC590B. The DC590B has a connector to which you can connect any demo board via a flat cable. DC590B then reads the EEPROM on the demo board and tells QuikEval that a demo board is connected AND which board it is. Hence QuikEval brings up the right user interface for the demo board.


This video (from a Japanese 'volt-nut'?) shows the the 3 parts - in this case QuickEval on the PC, the big DC590B board and the small DC573B demo board for the LTC2400 24 bit ADC http://www.linear.com/demo/dc573a.

[quantumvolt]

So what's the big deal?

LTC has produced the Linduino board as a platform for their newly developed C++ code that goes with their ICs. The Linduino is said to be 'Arduino-compatible'.

The Linduino can replace the DC590B interface board as the go-in-between the QuikEval PC GUI and the actual demo board for a an IC. So my thought was that if Linduino is Arduino-compatible and Linduino is able to interface QuikEval on one side and the more than 100 demo boards on the other side - well, then an Arduino with the LTC code should be able to do the same.

But alas, IMO it does not work. Linduino is - I am sure - Arduino-compatible, but I am just as sure that Arduino is not Linduino-compatible.

LTC has put a multiplexer chip on the Linduino board and - if I am not totally mistaken - the Linduino code multiplex - as well as switch between software / hardware - SPI and/or I2C. This I cannot see how should easily be done on an Arduino.

[EDIT: I have ordered the Fairchild MUX from England (fast shipping), and will try to make a MUX breakout for an Arduino Uno and then test the code again.]

So at least all code from LTC that starts like this (with a call to "quikeval_SPI_connect()"), will IMO not run on an Arduino. I might be wrong and am willing to withdraw all I say. But not before someone prove me wrong ...

Code: [Select]


void setup()
// Setup the program
{
  digitalWrite(QUIKEVAL_GPIO, LOW);
  digitalWrite(QUIKEVAL_CS, HIGH);
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
  digitalWrite(5, LOW);
  digitalWrite(6, LOW);
  digitalWrite(7, LOW);
  pinMode(QUIKEVAL_GPIO, OUTPUT);
  pinMode(QUIKEVAL_CS, OUTPUT);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);

  Serial.begin(115200);          // enable the serial port for 115200 baud

  quikeval_SPI_init();
  quikeval_SPI_connect();   // Connect SPI to main data port

quantumvolt comment (2 lines)
// Won't work for an ordinary Arduino ... because
// (File LT_SPI.cpp / void quikeval_SPI_connect())
// Connect SPI pins to QuikEval connector through the Linduino MUX. This will disconnect I2C.

  quikeval_I2C_init();           // Configure the EEPROM I2C port for 100khz SCK




Even the code for the part (not a demo board, just a part/component/integrated circuit) LTC2607 http://www.linear.com/product/LTC2607#code that is presented as an '.ino'-file (not a '.cpp' -file), starts with:

Code: [Select]


//! Initialize Linduino
void setup()
// Setup the Program
{
  char demo_name[] = "DC934";             // Demo Board Name stored in QuikEval EEPROM
 
  output_high(LTC2422_CS);                //! Pulls LTC2442 Chip Select High
 
  quikeval_I2C_init();                    //! Initializes Linduino I2C port.
 
  quikeval_SPI_init();                    //! Configures the SPI port for 4MHz SCK
  quikeval_SPI_connect();                 //! Connects SPI to QuikEval port
 
  Serial.begin(115200);                   //! Initializes the serial port to the PC
  print_title();                          //! Displays the title
 


and can IMO not be used to initialize an Arduino.

I hope LTC answers and prove me wrong. On the other hand - no one from LTC has AFAIK said that you actually CAN USE a generic Arduino board in stead of the Linduino. It might be that I am the only one who thought so because the Linduino is presented as 'Arduino-compatible'.

And I would still like to have a Linduino board - especially because of its galvanic isolation of the USB port.

[Linduino]

Hey there!

So the mux is there to basically read from the EEPROM. That's the only real purpose of that part on our board.

So, you can get by without all that setup code if you simply spoof the readback from the EEPROM. Then your non LTC Arduino is ready to go.

[quantumvolt]

Thanks. But the role of the MUX/EEPROM is IMO quite necessary if one wants to use QuikEval - it stores calibration constants / function modes etc.

So in the choice of chopping the code or beat Linduino by emulating it's hardware, I have found that the last solution is the the smartest.

The FSA2257MUX is a Dual SPDT Switch with low on resistance. I will try to build one from 2 x CD4051 on an Arduino shield. If it doesn't work - well - I have ordered the real part from fleabay UK (will be here in a week).

I am sure I will succeed - I just got me a surprise when I realized how intimately the code is linked to the non-Arduino hardware.

The more I think about it - the more sure I am. If LTC wants to have the LTSketchbook library spread out in the Arduino community, LTC should (since the Linduino is quite expensive and really is a superset of the Arduino board) make a shield with the MUX and a few regulators and LEDs and sell it almost for nothing. Then you really makes it easy to run QuikEval on purchased or DIY demo boards. The exotic 24LC05 EEPROM can be replaced by anything I2C based (almost free from Chinese fleabay sellers).

Just my 2 pennies. I will succeed anyway by making one myself 

[Linduino]

Pardon me, but are all Quikeval calibration values are stored on the PC and not on the EEPROM.

I will have to double check this to make sure of this tomorrow but I'm 99% positive of this.

However what does get stored would be the calibration routines within the Arduino sketch for the ADC. Is this what you're talking about? We're viewing the Linduino and Quikeval as 2 separate entities internally.

[quantumvolt]

Nah, I may be wrong. I'll check it later. If menu choices from the sketches are saved, then it will be on the EEPROM (as you say - no PC involved).

Anyway, I am getting pretty sure that one has to find hammer and saw anyway. Pin 4 on the demo board - SPI SCK - is connected to nowhere on the Linduino but 5 V (R10 4.99 k) and the MUX (pin4). So no money (MUX), no love (DATA) 

[quantumvolt]

Well, I am on my way. I am now reading the 24LS05 EEPROM on the DC573A LTC2400 demo board via I2C.



Since the board DC934A with an I2C DAC and an SPI ADC is a very nice board  , I have decided I will go for full hardware compability (in order to get data transfer I2C, data transfer SPI and dedicated I2C for the EEPROM all at the same time). I therefore decicate one of my many Chinese fleabay Arduino Uno clones to make a Linduino backpack.

[quantumvolt]

[quantumvolt]

Hey there!

So the mux is there to basically read from the EEPROM. That's the only real purpose of that part on our board.

So, you can get by without all that setup code if you simply spoof the readback from the EEPROM. Then your non LTC Arduino is ready to go.

I have now worked intensely with the LTSketchbook library, and I really like most of it. The code has high quality and is obviously being worked with and updated at LTC.I found a link to code that is only a few days old:

Code: [Select]


....

http://www.linear.com/product/LTC2309

http://www.linear.com/product/LTC2309#demoboards

REVISION HISTORY
$Revision: 2045 $
$Date: 2013-10-17 11:45:52 -0700 (Thu, 17 Oct 2013) $

Copyright (c) 2013, Linear Technology Corp.(LTC)
All rights reserved.

....

*/

//! @defgroup LTC2309 LTC2309: 8-channel, 12-Bit SAR ADC with I2C interface

/*! @file
    @ingroup LTC2309
    Library for LTC2309: 8-channel, 12-Bit SAR ADC with I2C interface
*/

#include <Arduino.h>
#include <stdint.h>
#include "Linduino.h"
#include "LT_I2C.h"
#include "LTC2309.h"
#include <Wire.h>

// Commands
// Construct a channel / uni/bipolar by bitwise ORing one choice from the channel configuration
// and one choice from the command.

// Example - read channel 3 single-ended
// adc_command = LTC2309_CH3 | LTC2309_UNIPOLAR_MODE;

// Example - read voltage between channels 5 and 4 with 4 as positive polarity and in bipolar mode.
// adc_command = LTC2309_P4_N5 | LTC2309_BIPOLAR_MODE;

// Reads 12 bits
int8_t LTC2309_read(uint8_t i2c_address, uint8_t adc_command, uint16_t *adc_code)
{
  int8_t ack = 0;

  ack = i2c_read_word_data(i2c_address, adc_command, adc_code);
  *adc_code >>= 4;  // Shifts data 4 bits to the right. uint16 to prevent 1's from shifting in if sign bit is 1.
  return(ack);
}

// Calculates the LTC2309 input unipolar voltage.
float LTC2309_unipolar_code_to_voltage(uint16_t adc_code, float LTC2309_lsb, int16_t LTC2309_offset_code)
{
  float adc_voltage;
  adc_voltage=(float)(adc_code+LTC2309_offset_code)*LTC2309_lsb;        //! 1) Calculate voltage from ADC code, lsb, offset.
  return(adc_voltage);
}

// Calculates the LTC2309 input bipolar voltage
float LTC2309_bipolar_code_to_voltage(uint16_t adc_code, float LTC2309_lsb, int16_t LTC2309_offset_code)
{
  float adc_voltage, sign = 1.0;
  if ((adc_code & 0x800) == 0x800)
  {
    adc_code = (adc_code ^ 0xFFF)+1;                                    //! 1) Convert ADC code from two's complement to binary
    sign = -1;
  }
  adc_voltage=(float)(adc_code+LTC2309_offset_code)*LTC2309_lsb*sign;   //! 2) Calculate voltage from ADC code, lsb, offset.
  return(adc_voltage);
}

// Calibrate the lsb
void LTC2309_cal_voltage(int16_t zero_code, int16_t fs_code, float zero_voltage, float fs_voltage, float *LTC2309_lsb, int16_t *LTC2309_offset_code)
{
  float temp_offset;
  *LTC2309_lsb = (fs_voltage-zero_voltage)/((float)(fs_code - zero_code));                              //! 1) Calculate the LSB
 
  temp_offset = (zero_voltage/ *LTC2309_lsb) - zero_code;                                               //! 2) Calculate Unipolar offset
  temp_offset = (temp_offset > (floor(temp_offset) + 0.5)) ? ceil(temp_offset) : floor(temp_offset);    //! 3) Round
  *LTC2309_offset_code = (int32_t)temp_offset;                                                          //! 4) Cast as int32_t
}

I have also studied the role of the MUX on the Linduino board.

Traditionally the DC590B board has had its I2C port dedicated to the EEPROM board name chip through QuikEval connector pins 9 EESDA and 11 EESCL. This hardware I2C is not muxed but is still today hardwired between the demo boards and the DC590B PIC and the Linduino Atmega.

The LTC devices on the demo boards have traditionally been communicating via SPI through pins 4-7 (BAR)CS, SCK, MOSI and MISO.

However - and this is crucial - when LTC introduces devices with I2C on the demo boards, there is no I2C port on the "old" QuikEval connector. So instead of making a new connector interface to the demo boards and an adapter for the old boards, LTC chooses to multiplex I2C and SPI on the SPI bus. Hence there are now 3 buses on 2 wire sets : auxiliary I2C (hardware I2C) for the EEPROM board identification chip, data SPI (muxed to hardware SPI), and data I2C (muxed to hardware SPI).

This works good. But everyone should know that for instance the board DC934A - which includes an I2C DAC, an SPI ADC and a MUX for sending both data streams to the SPI bus - can NEVER be read by an ordinary Arduino without hardware surgery or totally new high precision timed software that samples the SPI bus and splits the bits from the single SPI data stream into two data streams I2C and SPI.

[liquibyte]

I'd love to play around with one of these but, alas, I'll have to content myself with the library.  $75 is too steep a hill for me right now.

On a side note, the pdf of the demo manual is 404'ing.  Just an FYI.

[quantumvolt]

I'd love to play around with one of these but, alas, I'll have to content myself with the library.  $75 is too steep a hill for me right now.

On a side note, the pdf of the demo manual is 404'ing.  Just an FYI.

It's been on and off for days. Here is an alternative link http://cds.linear.com/docs/en/demo-board-manual/dc2026afa.pdf

I didn't manage to get a Linduino this time, so I'll have to wait and see. But I am modifying an Arduino clone to hardware compability (except from the isolation) with the Linduino because I really like the LTSketch library.

I guess this thread will go nowhere. The same old thing - playing with AVR and PIC is OK - but don't use the word Arduino ... 

[liquibyte]

I'd love to play around with one of these but, alas, I'll have to content myself with the library.  $75 is too steep a hill for me right now.

On a side note, the pdf of the demo manual is 404'ing.  Just an FYI.

It's been on and off for days. Here is an alternative link http://cds.linear.com/docs/en/demo-board-manual/dc2026afa.pdf

I didn't manage to get a Linduino this time, so I'll have to wait and see. But I am modifying an Arduino clone to hardware compability (except from the isolation) with the Linduino because I really like the LTSketch library.

I guess this thread will go nowhere. The same old thing - playing with AVR and PIC is OK - but don't use the word Arduino ... 

Thanks for that.  I wanted to have a look at the schematic but couldn't get it.  To top it off, the same day I posted that my root drive died and I'm just now getting up on a spare drive I had, posing this from a Gentoo live cd.  I don't understand why arduinos are so frowned upon, they're a neat little gizmo to play with.  I've got a few spare Atmel chips on the way with plans of pairing them up as a volt/ammeter with one of the VFD's from the givaway from Noritake.  That's kind of why I wanted a peek at the LT librariess, the Noritake stuff could use some improvements.

[NiHaoMike]

I'm surprised they isolated the USB rather than the serial lines.

Not too sure why Arduino seems so hated. It is pretty slow compared to higher end stuff like ARM and dsPIC, but it still has a place.

[Harvs]

I'm surprised they isolated the USB rather than the serial lines.

LT sell these nice modules that have a DC-DC converter and isolator in the one small package.  I've used their RS485 version before.  Looks like this USB isolator is a new version that they'll release to the greater unwashed at some stage.

Only downside is they're many times the cost of other solutions.

Not too sure why Arduino seems so hated. It is pretty slow compared to higher end stuff like ARM and dsPIC, but it still has a place.

I'm not sure it really is.  It seems that uC topics like this that have no single technical answer just attract a disproportionate level of emotive involvement.  Just go and have a look at the "why would you use an 8bit uC" thread.  That thread spans hundreds of posts and multiple years, yet it has to be one of the technically least interesting topics that gets brought up on this forum.  Such is the beast of the internet.

[quantumvolt]

Never mind the uC hi-class nerds. Soon their GHz processors will be just as 'heritage' as building-sized computers from the 1960's...

LT has isolation uModules - and AD and Microchip and others also. I can always buy a part and build something. But I am a board collector. I don't care about broads - give me boards ...

Anyway - I now probably have the world's first Linduino-Protocol-Hardware-Emulator Shield for Arduino. Two CD4051 (pin A switches I/O nos. 0 and 1).  This has the exact same electrical function as the original dual SPDT switches in the FSA2257 in the schematic.

[quantumvolt]

My "Linduino clone" Multiplexed I2C / SPI Arduino works fine. I will build a permanent shield. My best option for isolation so far seems to be ADuM3180/4180 (fleabay USD15-20 inc. postage). Any other ideas (isolated ground/power+data)?


--------------------------------------------
The original on-board LTM2884 must be
something like

http://www.linear.com/product/LTM2881

http://www.linear.com/product/LTM2882

http://www.linear.com/product/LTM2883

[quantumvolt]

For those who have read about the Linduino and taken a look at the schematic/C++ library, you will have noticed that the board has 3 serial buses on 2 wire sets : auxiliary I2C (hardware I2C) for the EEPROM board identification / calibration data storage chip, data SPI (muxed to hardware SPI), and data I2C (muxed to hardware SPI).

I made my first clone using two CD4051 (pin A switches I/O nos. 0 and 1).  This has the exact same electrical function as the original dual SPDT switches in the FSA2257 in the schematic. Later I have found out that all I need is 1 pcs. CD4066.

At first the onboard EEPROM on LTC's ADC and DAC evaluation boards was an annoyance to me. Later I have understood how useful it can be to store data along with the chip.

It seems I am not the only one. A quick search gives many links and is in general covered by this:

EEPROM memory is used to enable features in other types of products that are not strictly memory products. Products such as real-time clocks, digital potentiometers, digital temperature sensors, among others, may have small amounts of EEPROM to store calibration information or other data that needs to be available in the event of power loss. http://en.wikipedia.org/wiki/EEPROM

There is even a video on the theme (see end of post).

The Linduino has the LTSketchBook library with easy to copy code and menus like this:
 

Code: [Select]

  Serial.println(F("\nCommand Summary:"));
  Serial.println(F("  1-Write to input register (no update)"));
  Serial.println(F("  2-Write and update DAC"));
  Serial.println(F("  3-Update / power up DAC"));
  Serial.println(F("  4-Power down DAC"));
  Serial.println(F("  5-Set reference mode"));
  Serial.println(F("  6-Calibrate DAC"));
  Serial.println(F("  7-Enable / Disable calibration"));

  Serial.println("\nPresent Values:");
  Serial.print("  DAC Reference: ");
  if (reference_mode == REF_INTERNAL)
    Serial.println("Internal");
  else
  {
    Serial.print(F("External "));
    Serial.print(reference_voltage, 5);
    Serial.println(F("V reference, please verify"));
    Serial.print(F("Enter a command:"));


So now I will add a 32k EEPROM to my best voltage reference boards. I will be able to store date of measurement, instrument and range used, PSU, temp, humidity and measured value in around 15-20 bytes (if I am not wrong). That means I can store a thousand or two thousand measurements on one 32k chip. Has anyone any experience with long time use of DIY or purchased devices with EEPROM calibration values or data?

[Spikee]

LT has posted a video about this Linduino on youtube:

[dannyf]

LT has posted a video about this Linduino on youtube:

I like his smile.

[Linduino]

Oh good lord. You guys weren't supposed to see this... ever.

[quantumvolt]

The video is good and so is the board / library. But the thumbnails are the prize we pay for digitally stored videos. You can just have somebody change it.

BTW
If you want to keep this thread alive, please help by posting. I think some insider reports from LTC would make good reading ...

[Linduino]

Well as far as insider stuff goes.

Right now we're working hard trying to fill in a back log of parts that we do not have code for. I'm also working on a short article/tutorial on how to convert our library code into a fully functioning data logger along with the code for a simple Windows based GUI to control the data logger.

If anybody has requests for certain parts that they want code support for, well please let me know. Right now our first goal is to cover most of the popular Delta Sigmas. We also plan on having code support ready whenever a new part rolls out.

[quantumvolt]

What I would really like is if LTC made a pro GUI with open code. I have seen your PScope and LTPowerplay. Fancy software.

Did you now that Microchip publishes the full code for their DataView.

http://www.microchip.com/stellent/idcplg?IdcService=SS_GET_PAGE&nodeId=1406&dDocName=en024782

Make a template for DIY GUI's for Linduino like the MakerPlot or something similar in C++. Many people will thank LTC for it.

(FYI MakerPlot is cheap and good, but no code  )

[Linduino]

The problem with giving people code is it often costs more in man hours for us to support than it would if we just dealt with it on a case by case basis.

If you dig into the DC590B emulator code, you'll begin to realize why. We have a serial protocol in place, and a lot of the code inside of QuickEval or PowerPlay ends up being obtuse strings such as: MIsS98S85sS99QQQQRp or something along those lines.

So people who dig into our GUI code not only have to deal with learning how the loop works, but then need to learn our "T++" (internal nickname for it) protocol and we end up burning more time explaining it.

But, that's why we started Linduino. Sure it's not a GUI, but it's easily explainable and transferable across multiple platforms.

[quantumvolt]

Well ... I finally managed to get my hands on a real Linduino. Thanks a lot to LTC.

So now I have two - that is - the second one (my Linduino-Emulator shield for Arduino) is only digitally function compatible (no USB isolation).

I have put he new Linduino to test use: 18 Bit DAC (LTC2756) to 24 Bit ADC (LTC2400) Loop Back.

The DAC is connected to PC via Linduino to USB. The DAC outputs the voltage that is chosen in QuikEval software.

The ADC voltage is measured by the ADC. The ADC is connected to PC via Arduino w/ the Linduino-clone shield to another USB port.

A DIY GUI Java applet (just a barebone start) made in Processing receives the ADC data and outputs them to screen.





When I have made an input field for the DAC voltage in the Java GUI (and drops QuikEval alltogether), I will incorporate both Linduinos (com x and y) to the same running program. Next step is to also measure the DAC output voltage with the 34401A and output the RS232 measurement to a third Arduino on com z. All three datasets - the DAC setting, the ADC reading and the DMM reading - are then accessible in the same program.

So I will be able to do:



But TTT (Things Take Time ...)

[helgel]

Hi,
Any updates on the Arduino version of Linduino ?
I've tried to download the DC590B on an arduino UNO and try to connect to QuikEval PC software.
I end up with "The USB-to-Serial Controller is not connected" message.
I guess this may be a USB driver problem and not related to the actual arduino software.

A tutorial from someone that has succeeded whould be nice :-)
Or maybe I have to buy the Linduino to save some time (not money...)...

[hillflyer]

After using processing to display a graph of the of the ADC readings via an Arduino, I can only second what Helgel has asked.
Is it feasible to use QuikEval with a normal Arduino and a homebrew LTC ADC board?
Greetings
Hannes

[Linduino]

Hi,
Any updates on the Arduino version of Linduino ?
I've tried to download the DC590B on an arduino UNO and try to connect to QuikEval PC software.
I end up with "The USB-to-Serial Controller is not connected" message.
I guess this may be a USB driver problem and not related to the actual arduino software.

A tutorial from someone that has succeeded whould be nice :-)
Or maybe I have to buy the Linduino to save some time (not money...)...

Hi,
One of the differences between a Linduino and Arduino UNO is that Linduino uses an FTDI chip for USB to serial data conversion, while Arduino has a different ATMEL chip. QuikEval software is programmed to to look for the FTDI chip and it would not work on an Arduino UNO. However, if you are trying to simply talk to some LTC part, we have code libraries that would work on an Arduino (with a few changes to the Linduino code). Hope this helps!

[timb]

Hi,
Any updates on the Arduino version of Linduino ?
I've tried to download the DC590B on an arduino UNO and try to connect to QuikEval PC software.
I end up with "The USB-to-Serial Controller is not connected" message.
I guess this may be a USB driver problem and not related to the actual arduino software.

A tutorial from someone that has succeeded whould be nice :-)
Or maybe I have to buy the Linduino to save some time (not money...)...

Hi,
One of the differences between a Linduino and Arduino UNO is that Linduino uses an FTDI chip for USB to serial data conversion, while Arduino has a different ATMEL chip. QuikEval software is programmed to to look for the FTDI chip and it would not work on an Arduino UNO. However, if you are trying to simply talk to some LTC part, we have code libraries that would work on an Arduino (with a few changes to the Linduino code). Hope this helps!

An alternative if you have an Uno and FTDI cable laying around may be to just hook the cable up to the UART pins so the onboard USB converter is bypassed!

Linguini Linduino, could I contact you about getting a Linduino and possibly one or two evaluation boards for an OSH project I'm working on? It would save me so much time versus rigging up my own test jigs. (This project will be going into small scale production later this year.)


Sent from my Tablet

[Linduino]

Sure! I would be happy to help. Email me at linduino@linear.com.

[quantumvolt]

Since I am the one who started this topic - sorry for not following it up (health reasons, I do not read or post anywhere anymore) .

Hello to Leo and all. I still use the Linduino that LT kindly gave me. It is a very good board with USB ground isolation and clean power, and has excellent free code. I also use the clone that I built myself (see earlier posts and video).

I am a bit sorry that Linduino has not taken off in the Arduino world, but as LT has stated: They do not want to set a price that competes with Arduino and clones. Fair enough. LT is not a sandbox player but a professional business.

Du to reasons stated above, I have had little chance to work with electronics. However, if anyone wants to make a Linduino clone from an Arduino, it is quite easily done. But you must read my earlier posts about MULTIPLEXING OF I2C AND SPI.

On page 11, Block Diagram in

http://cds.linear.com/docs/en/demo-board-manual/DC2026AFB.PDF

you will see that there is a multiplexer. You will have to reproduce this MUX or it's function. On page 14 you will see the schematic with the Atmega processor U7 and the MUX chip U4. This is the MUX you will have to buy, or emulate its switching by using junk box logic (as I have written in earlier posts). You can mount the MUX and the other components around it on an empty Arduino shield.

Now look at the schematic

http://cds.linear.com/image/resized/934asch.jpg from http://www.linear.com/solutions/3305.

You will see that the board has an a DAC, an ADC, a MUX and an EEPROM.

The WIRED Arduino I2C is OCCUPIED by the EEPROM. The DAC and ADC shares Arduino SPI via the MUX. The resultant signal is DEMULIPLEXED in the earlier mentioned Linduino MUX. So there are two MUXes - one for mixing the signals on the DAC/ADC board, and one for separating them before they reach the Atmega on the Linduino board.

So, unless you understand what I have just said, you will in my opinion find it difficult to use an Arduino as a Linduino  clone.

OK. That's it. I am sorry I cannot follow this up. I highly recommend the Linduino and the code Library, and hope more people will use it. Thanks again to LT for generous help.

[helgel]

I'm a bit confused, but let me see if I have understood this:

1. Linduino uses an FTDI chip for USB to serial data conversion. Thus, QuickEval will not detect the UNO. That could be fixed by "bypassing the onboard USB controller" with a "FTDI cable"  as indicated by Timb. Can someone explain how that is done ? Are there other alternatives ? What about modifying the QuickEval ?

2. There is a MUX on the Linduino that is used to "detect" the various ADC/DAC modules. This can be fixed by the hardware modification described by Quantumvolt. But is it also correct that it can (instead) be fixed by modifying the arduino code as described by Linduino in this post: http://www.linear.com/solutions/4537. Or are these different things ?

3. The Linduino has USB optoisolation. I guess this is not vital, except for noise, measurement accuracy etc.

[plesa]

What about using Arduino Nano with FTDI for this kind of emulation?

[helgel]

I briefly tried with an Arduino Pro Mini with the following FTDI based USB to TTL Serial Cable: http://www.ebay.com/itm/400356015296?_trksid=p2059210.m2749.l2649&ssPageName=STRK%3AMEBIDX%3AIT.

No success, though I didn't try very hard...

[quantumvolt]

I'm a bit confused, but let me see if I have understood this:

1. Linduino uses an FTDI chip for USB to serial data conversion. Thus, QuickEval will not detect the UNO. That could be fixed by "bypassing the onboard USB controller" with a "FTDI cable"  as indicated by Timb. Can someone explain how that is done ? Are there other alternatives ? What about modifying the QuickEval ?

2. There is a MUX on the Linduino that is used to "detect" the various ADC/DAC modules. This can be fixed by the hardware modification described by Quantumvolt. But is it also correct that it can (instead) be fixed by modifying the arduino code as described by Linduino in this post: http://www.linear.com/solutions/4537. Or are these different things ?

3. The Linduino has USB optoisolation. I guess this is not vital, except for noise, measurement accuracy etc.

It really is very simple.

If you must use QuikEval you have to emulate Linduino and any supported LT demo board. This involves USB 'handshake'-ing to Linduino and (flat cable) read from Linduino of the signature of the EEPROM on the connected demo board. Leo now also says that QuikEval looks for FTDI stamp.

Dropping QuikEval you can:

Use any I2C exclusive-or SPI demo board (LT original or DIY) with ANY Arduino (as Leo explains in the link you give yourself). Effectively you just set the bus to EITHER I2C or SPI, and throw out the code that Linduino uses for checking that a demo board is connected. [This is a totally different case from the following:]

If your board uses BOTH SPI and I2C (like I2C DAC and SPI ADC - see for instance LT Demo Board DC934A - http://www.linear.com/solutions/3305), LT's Linduino code will work ONLY IF you make the hardware mods I have described. Any Arduino is OK. But still you might/will not be able to use QuikEval.

The ground isolation is totally irrelevant to all these considerations. It is just a nice feature to avoid (potentially harmful) ground currents.

[Edit: DC943Ato DC934A.  Added link]

[altay]

@quantumvolt

I have LTC2983 demo board. But i don't have a Linduino board. I want to use my demo board with Arduino. QuickEval is not necessary now. I just want to read temperature datas from LTC2983. Can i use LTSketchbook examples for this demo board directly? or do i need some modification because of MUX?

[quantumvolt]

I guess the 'LTC2983 demo board' is DC2296 http://cds.linear.com/docs/en/demo-board-manual/dc2296fa.pdf.

First - from the LTC2983 datasheet http://cds.linear.com/docs/en/datasheet/2983fc.pdf - the chip is an SPI device.

Secondly - from the DEMO MANUAL DC2296 (top link) schematic on page 21 there is NO I2C device on the board. So I quote myself from my last post over:


"Dropping QuikEval you can:

Use any I2C exclusive-or SPI demo board (LT original or DIY) with ANY Arduino (as Leo explains in the link you give yourself). Effectively you just set the bus to EITHER I2C or SPI, and throw out the code that Linduino uses for checking that a demo board is connected."

So - as you are NOT using QuikEval AND the board is EXCLUSIVELY SPI you can use ANY Arduino. All you must be able to do is to talk to U1 in the schematic for the demo board [CS(bar), SCK, MOSI, MISO on J2]. You can use Linduino code and forget everything about the U2 EEPROM chip I2C stuff (which is just for QuikEval identification of the board).

LTC explains how to change the Linduino code in 'Going Generic' (= using Arduino) here http://www.linear.com/solutions/4537. But you really do not need the Linduino code - your board is nothing but another SPI chip - so any Arduino SPI tutorial or example program does the trick. However - the Linduino code will have the right data formats in the right sequence already.

Also there seems to be some LTC software that generates C-code to configure, program and run the LTC2983 device http://cds.linear.com/docs/en/software-and-simulation/2983dsmf.pdf.

So this is what I would do:

1. Learn Arduino SPI.
2. Modify Linduino code for LTC2983 to run on Arduino.
3. Run the LTC2983DSM and cut and paste what you need / want for your number of channels and sensor types and whatever other options there might be.

Good luck. It is not difficult - just a lot of work.

PS (Your PM). If you want to build a Linduino clone you must study the Linduino schematic http://cds.linear.com/docs/en/demo-board-manual/DC2026CFD.PDF. You will see that Linduino=Arduino+Mux+PullUpResistors+OtherResistors+Capacitors+.... Then you take an Arduino and put the rest on an empty shield and draw some wires. Voila - you have a Linduino

[altay]

@quantumvolt

Thank you very much for your detailed reply. I succeeded on working with LTC2440 ADC both using my own arduino spi code and linduino library code.

This link is very helpful for me:  http://www.linear.com/solutions/4537 .Thanks

Next step is modifiying LTC2983 code for my application 

[quantumvolt]

https://www.eevblog.com/forum/beginners/arduino-shield-for-lt-demo-boards-quikeval-linduino-dc2026-usb-dc590b/

Abandoned. Explanation in the link.