flipdot/flipcontrol_esp32/src/main.cpp

#include <Arduino.h>
#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))

/*
D7 - Ser (data)
D5 - clock
D1 - _OE
D2 - latch
D3 - _clear
*/

//Pins connected to Shift registers on own controller board
#define PIN_DATA 13
#define PIN_CLK 14
#define PIN_OE 27 //active low
#define PIN_LATCH 26


//Pins connected to stuff on annax driver board
#define PIN_DATA_DRVBRD 33
#define PIN_CLK_DRVBRD 32

//#define PIN_CLEAR 25 //active low

#define PIN_DRIVE 25 //enables 12v to panels via transistor
#define PIN_CLEAR 12 //connects CLEAR Pin from Annax board to GND (clears column)

#define NUMPANELS 1


//void sr_clear();
void shiftOutSlow(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);
bool clearSelectedColumn();
bool setSelectedDot();

void selectColumnClear(uint8_t selcolumn);
void selectColumnSet(uint8_t selcolumn);
void selectColumn(uint8_t selcolumn, bool clear);

bool HBridgeOK();
void shiftData();

void resetColumns();

unsigned long loopmillis=0;
unsigned long last_update=0;
#define UPDATE_INTERVAL 500


void setup() {
    pinMode(PIN_DATA, OUTPUT);
    pinMode(PIN_CLK, OUTPUT);
    pinMode(PIN_OE, OUTPUT);
    pinMode(PIN_LATCH, OUTPUT);
    pinMode(PIN_CLEAR, OUTPUT);
    pinMode(PIN_DRIVE, OUTPUT);
    

    pinMode(PIN_DATA_DRVBRD, OUTPUT);
    pinMode(PIN_CLK_DRVBRD, OUTPUT);
    
    
    digitalWrite(PIN_OE, HIGH); //Active Low
    digitalWrite(PIN_LATCH, LOW);
    //sr_clear();
    digitalWrite(PIN_DRIVE, LOW);

    Serial.begin(115200);
}

int countz=0;

//uint8_t rowA=0; //first shift register of own controller
//uint8_t rowB=0; //second shift register of own controller
uint16_t row;
/*uint8_t colA=0;
uint8_t colB=0;
uint8_t colC=0;
uint8_t colD=0;
uint8_t colE=0;
uint8_t colF=0;
uint8_t colG=0;*/

uint8_t col[7];

void loop() {
    loopmillis = millis();
    


    static bool init=false;
    if (!init) {
        delay(2000);
        Serial.println("Clearing Display");
        for (int l=0;l<25;l++) {
            selectColumnClear(l%25);

            shiftData();

            if (!clearSelectedColumn()) {
                Serial.println("Error clearing column!");
            }else{
                Serial.println("Cleared");
            }

            delay(50);
        }
        init=true;
        delay(1000);
    }
    

    if (loopmillis > last_update + UPDATE_INTERVAL) 
    {
        
        Serial.print("count=");
        Serial.print(countz);Serial.print(": ");

        /*
        Serial.println("High");
        digitalWrite(PIN_DATA, HIGH);
        
        delay(1000);
        
        Serial.println("Low");
        digitalWrite(PIN_DATA, LOW);
        
        delay(1000);
        */


        /*
        rowA=pow(2, (countz/2)%8);

        
        if (countz%2==0) {
            colA=0;
        }else{
            colA=64; //64=IL0
        }
        */


        
        
        //setting colX to 128, 32, 8,2 (or a combination of), then appling 12V to driver and GND to Clear, clears these colums
            // this applies +12v to selected columns
        //setting colX to 64,16,4,1 (or a combination of), then setting row shift registers to some setting sets the selected dots
            // this applies GND to selected columns
        //reset pin on annax board input should be used (not pulled to gnd for a short time) after dots have been flipped (to disable potentially activated transistors)


        //selectColumnClear(countz%25);

        //cycle testing set dots
        
        
        selectColumnSet(countz/16); //lower column number is on the left
        row=pow(2, (countz)%16);//low significant bits are lower rows (when connector at top)
    
        
        bool run_setdots=true;
        /*
        
        switch(countz) {
            case 0:
                selectColumnSet(5);
                row=pow(2, 3); //4. zeile von unten
                break;
            

            case 1:
                selectColumnSet(5);
                row=pow(2, 4); //5. zeile von unten
                break;
            
            case 2:
                selectColumnSet(5);
                row=pow(2, 5);
                break;
            
            case 3:
                selectColumnSet(5);
                row=pow(2, 8);
                break;
            
            case 4:
                selectColumnSet(2);
                row=pow(2, 1);
                break;
            

            default:
                row=0;
                resetColumns();

                run_setdots=false;

        }
        */

        if (run_setdots) 
        {
            
            Serial.print("Row="); Serial.print(row); Serial.print(" Col=");
            for (uint8_t i=0;i<7;i++) {
                Serial.print(","); Serial.print(col[i]);
            }
            Serial.println();
            //reset pin on ribbon cable high (12Vpullup/open), then low (via Transistor)
            
            shiftData();


            setSelectedDot();


            
            /*if (!clearSelectedColumn()) {
                Serial.println("Error clearing column!");
            }else{
                Serial.println("Cleared");
            }*/
        }else{
            Serial.println("END");
        }
            
        
        


        
        last_update=loopmillis;
        countz++;

    }

    
}

//

void shiftOutSlow(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val)
{
	uint8_t i;

	for (i = 0; i < 8; i++)  {
		if (bitOrder == LSBFIRST)
			digitalWrite(dataPin, !!(val & (1 << i)));
		else	
			digitalWrite(dataPin, !!(val & (1 << (7 - i))));
			
        delayMicroseconds(1000);
		digitalWrite(clockPin, HIGH);
        delayMicroseconds(1000);
		digitalWrite(clockPin, LOW);		
        delayMicroseconds(1000);
	}
}


void selectColumnClear(uint8_t selcolumn) {
    selectColumn(selcolumn, true); 
}
void selectColumnSet(uint8_t selcolumn) {
    selectColumn(selcolumn, false);
}
void selectColumn(uint8_t selcolumn, bool clear) {
    uint8_t sc_bit=3-(selcolumn%4); //each two shift registers control four columns
    uint8_t sc_byte=selcolumn/4;

    /*for (uint8_t i=0;i<7;i++) {
        col[i]=0;
    }*/
    resetColumns();

    col[sc_byte]=pow(2, (sc_bit*2+clear)); // possible numbers for clear=false: 1,4,16,64
    /*
    if (!clear) { //when setting a dot set all other columns to 12v (to avoid ghost flipping)
        for (uint8_t i=0;i<7;i++) {
            col[i]+=2+8+32+128; //set to +12v
        }
        col[sc_byte]-=pow(2, (sc_bit*2+1)); //avoid short circuit on H-bridge
    }
    */
    
    
}

bool clearSelectedColumn() {
    //Clear Columns
    if (row!=0) {
        return 0; //error. row is selected (short circuit!)
    }
    for (uint8_t cc=0;cc<7;cc++) {
        //Serial.print("checking cc="); Serial.println(cc);
        for (uint8_t i=0;i<8;i+=2) {
            if (CHECK_BIT(col[cc],i)) {
                Serial.print("Error on bit ");
                Serial.print(i); Serial.print(" col="); Serial.println(cc);
                return 0; //a column is set to ground (should not be set for clear column)
            }
        }
    }

    digitalWrite(PIN_DRIVE, HIGH);
    digitalWrite(PIN_CLEAR, HIGH);
    delay(50);
    digitalWrite(PIN_CLEAR, LOW);
    digitalWrite(PIN_DRIVE, LOW);
    return 1;
}

bool setSelectedDot() {
    
    /*for (uint8_t cc=0;cc<7;cc++) {
        //Serial.print("checking cc="); Serial.println(cc);
        for (uint8_t i=1;i<8;i+=2) {
            if (CHECK_BIT(col[cc],i)) {
                Serial.print("Error on bit ");
                Serial.print(i); Serial.print(" col="); Serial.println(cc);
                return 0; //a column is set to ground (should not be set for clear column)
            }
        }
    }*/

    if (!HBridgeOK) {
        return 0;
    }

    digitalWrite(PIN_OE, LOW); //Active Low
    digitalWrite(PIN_DRIVE, HIGH);
    delay(10);
    digitalWrite(PIN_OE, HIGH); //Active Low
    digitalWrite(PIN_DRIVE, LOW);
    return 1;
}

bool HBridgeOK() {
    for (uint8_t cc=0;cc<7;cc++) {
        //Serial.print("checking cc="); Serial.println(cc);
        for (uint8_t i=0;i<8;i+=2) {
            if (CHECK_BIT(col[cc],i) && CHECK_BIT(col[cc],i+1)) {
                Serial.print("Short circuit on bit ");
                Serial.print(i); Serial.print(" col="); Serial.println(cc);
                return 0; //a column is set to ground (should not be set for clear column)
            }
        }
    }
    return 1;
}

void shiftData() { //send out all data to shift registers
    
    
    //select Rows via shift registers on own controller board
    shiftOutSlow(PIN_DATA, PIN_CLK, LSBFIRST, row&0xff);  //lower byte
    shiftOutSlow(PIN_DATA, PIN_CLK, LSBFIRST, row>>8);  //LSBFIRST= LSB is QH, bit 8 is QA. //upper byte
    digitalWrite(PIN_LATCH, HIGH);
    delayMicroseconds(1000);
    digitalWrite(PIN_LATCH, LOW);

    //Select Columns via Shift registers
    for (uint8_t i=0;i<7;i++) {
        shiftOutSlow(PIN_DATA_DRVBRD, PIN_CLK_DRVBRD, LSBFIRST, col[6-i]);
    }
}

void resetColumns() {
    for (uint8_t i=0;i<7;i++) {
        col[i]=0;
    }
}