You need the 7-segment display with i2c backpack – that way there are only two data lines to connect up. They are readily available from ebay and look really good. Unfortunately I've only used one with a Raspberry Pi zero, so I can't give you the C code to make one work (I used Python for the Pi, and the libraries are different anyway).

Hopefully the following link to Adafruit's information and instructions won't fall foul of the forum rules:

https://learn.adafruit.com/adafruit-led-backpack/

edit: Sorry, the ebay ones are SPI rather than i2c; they should be similar to get working, but for simplicity, it might be best to use the Adafruit ones – if you're in the UK, Pimoroni sell them – they cost a bit more than the ebay ones, unfortunately. 

Edited By Andy Stopford on 20/11/2020 20:27:24

The max 7219 is good with the MD_Parola library but it uses a lot of memory

There's a chap here who has made an LCD version with teeny code

The parola library is worth the extra effort though, because it lets you do virtually anything with an LED dot matrix, pins 10 11 and 13 have given me the least problems so far

an awful lot of examples are like crippleware for a beginner with the arduino, but small tweaks suddenly make all the difference

Coding is still the same old teeth grinding brain squeezing grope in the dark subject that it was 20 years ago but at least the arduino can give you a leg up and start talking to stuff

I think the problem with dot matrixes is you have to tell it EVERYTHING, so you get stuff like below x 100s to define every character or shape, like every dot in newsprint

//////////////

const char font5x7 [] PROGMEM = {      //Numeric Font Matrix (Arranged as 7x font data + 1x kerning data)
    B00000000,  //Space (Char 0x20)
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    6,

    B10000000,  //!
    B10000000,
    B10000000,
    B10000000,
    B00000000,
    B00000000,
    B10000000,
    2,

    B10100000,  //"
    B10100000,
    B10100000,
    B00000000,
    B00000000,
    B00000000,
    B00000000,
    4,

    B01010000,  //#
    B01010000,
    B11111000,
    B01010000,
    B11111000,
    B01010000,
    B01010000,
    6,

Edited By Ady1 on 20/11/2020 23:48:02

It needs to be done in steps

1. Get your weighing machine outputting data to the computer monitor

2. connect up the 7219

3. insert my code into your weight routine to transfer data to the 7219

simples! (we wish)

Edited By Ady1 on 21/11/2020 11:53:13

Can make the 7219 scroll from other sketches so the module is working.

#include <MD_Parola.h>
#include <HX711_ADC.h>
#include <Wire.h>

HX711_ADC LoadCell(4, 5); // parameters: dt pin, sck pin<span data-mce-type="bookmark" style="display: inline-block; width: 0px; overflow: hidden; line-height: 0;" class="mce_SELRES_start"></span>

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CLK_PIN 13
#define DATA_PIN 11
#define CS_PIN 10
MD_Parola P1 = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

const int Reset = 3;
float i;

String J;

void setup() {
P1.begin();
Serial.begin(9600);

LoadCell.begin();
LoadCell.start(2000);
LoadCell.setCalFactor(851.58); // calibration factor for load cell => strongly dependent on your individual setup Higher for less
pinMode( Reset,INPUT_PULLUP );// Pin3 pull up

}

void loop() {
LoadCell.update();
float i = LoadCell.getData();
lcd.setCursor(3,0);

Serial.println(i,1);

J=String(i);
P1.print(J);

if ((digitalRead(Reset) == LOW)) { //Tare

LoadCell.tare();
delay(500);

}
//delay (1000);
}

Just a suggestion but I see Peter's code says:

J=String(i);
P1.print(J);

The problem may be because P1.print() expects to be given a C string (small s) rather than a C++ String (big S)

Try

P1.print( J.c_str() ); // get a C null terminated string from the C++ String J,

If memory is very short, causing the dreaded 'undefined behaviour', remove big S Strings from the program because they use a lot of memory.

C++ may be much clearer and less error prone with:

J=String(weight);

but pure C is faster and uses far less memory with:

char buf[24]; // big enough to hold a 23 digit number
dtostrf( weight, 6, 1, buf ); // convert weight into C string in buf, minimum 6 characters, with 1 decimal place.
P1.print( buf );

Dave

Edited By SillyOldDuffer on 23/11/2020 14:29:53

So it's trying – the output suggests the display is being controlled via SPI but sent the wrong commands, therefore lighting up the wrong segments.

The Parola library depends on the MD_MAX72XX library, and its .h file explains as there is no standard way of connecting the LCD blocks to the converter chip on the end, so the library supports 4 options. They are:

GENERIC_HW, ///< Use 'generic' style hardware modules commonly available.
FC16_HW, ///< Use FC-16 style hardware module.
PAROLA_HW, ///< Use the Parola style hardware modules.
ICSTATION_HW, ///< Use ICStation style hardware module.

Possibly your module isn't an FC16? Anyway, no harm trying the 3 alternatives to

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW

eg.

#define HARDWARE_TYPE MD_MAX72XX::GENERIC_HW

or

#define HARDWARE_TYPE MD_MAX72XX::PAROLA_HW

or

#define HARDWARE_TYPE MD_MAX72XX::ICSTATION_HW

Dave

Had another couple of thoughts.

Maybe you have the correct device, wiring, and HARDWARE_TYPE, but are sending it data it can't cope with. The floating point number generated by:

J=String(i); // Could send too many characters to fit the display, or the decimal point is illegal punctuation.

(Floating point numbers change size depending on the result. By default String does 2 places of decimals eg String(1.0/3) gives "0.33", but watch out for the likes of 1000000.0/3 giving 333333.33. The Parola documentation looks as if punctuation is allowed, so the decimal point should be ok.)

Test by assigning some short constants to J in your code , to see if they work. Eg.

J=String("ABC" ) ; // Note – fits in a 4-cell block
if that works then

J=String("123" )  ;
& if that works

J=String("1.3" ) ;
& if that works

J=String(1.3);

Assuming all that fails, have you tried any of Parola's examples? (See File->Examples menu )

This one does nothing but say 'Hello', always a good first step to prove the basics are working. If Parola's own example can't be made to work, suspect wiring error or dud device. Note HARDWARE_TYPE needs to change to do your FC31. If the LEDs display hello, experiment by sending it Strings as above.

// Program to demonstrate the MD_Parola library
//
// Simplest program that does something useful – Hello!
// Uses the Arduino Print Class extension
//
// MD_MAX72XX library can be found at https://github.com/MajicDesigns/MD_MAX72XX
//

#include
#include
#include

// Define the number of devices we have in the chain and the hardware interface
// NOTE: These pin numbers will probably not work with your hardware and may
// need to be adapted
#define HARDWARE_TYPE MD_MAX72XX::PAROLA_HW
#define MAX_DEVICES 11

#define CLK_PIN 13
#define DATA_PIN 11
#define CS_PIN 10

// Hardware SPI connection
MD_Parola P = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
// Arbitrary output pins
// MD_Parola P = MD_Parola(HARDWARE_TYPE, DATA_PIN, CLK_PIN, CS_PIN, MAX_DEVICES);

void setup(void)
{
P.begin();
P.print("Hello!" );
}

void loop(void)
{
}

Edited By SillyOldDuffer on 25/11/2020 09:31:39

Got it in today, this works ok

#include <MD_Parola.h>
#include <HX711_ADC.h>
#include <Wire.h>

HX711_ADC LoadCell(4, 5); // parameters: dt pin, sck pin

#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4
#define CLK_PIN 13
#define DATA_PIN 11
#define CS_PIN 10
MD_Parola P1 = MD_Parola(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);

const int Reset = 3;
//float weight;

String J;

void setup() {
P1.begin();
Serial.begin(9600);

LoadCell.begin();
LoadCell.start(2000);
LoadCell.setCalFactor(851.58); // calibration factor for load cell => strongly dependent on your individual setup Higher for less
pinMode( Reset,INPUT_PULLUP );// Pin3 pull up

}

void loop() {
LoadCell.update();
float i = LoadCell.getData();

Serial.println(i,1);
delay(1000);
J=String(i);
P1.print(J);

if ((digitalRead(Reset) == LOW)) {

LoadCell.tare();
delay(1000);

}}