so basically im using a arduino nano where i have connected the 74HC595 and using pins (1,2,3,4,5,6,7,15) on the microcontroller i have a connected a 7 segment display my question is how would I using bigbanging make the decimal point flash continously?
all help would be appreciated
Show us your code, in code tags please. Please, please read the sticky posts at the top of the forum to learn how to post code properly. Typically, bitbanging is what drives the display. Blink functionality would be a layer over that. We need to see your attempt at bitbanging.
So your question needs some redefinition - right now it's like, "How would I use a can opener to open a can of tuna, instead of a can of salmon?". It's more about how you're going to make a sandwich.
Also, pin 1 is a bad choice for a display pin because serial uses it. And... do you have current limiting resistors on the display? Is the "H" segment pin connected to a driver pin? Best if you provide a schematic, really....
const int LATCH=12;
const int CLOCK=11;
const int DATA=14;
#define heartbeat_on PORTB = PORTB | B00100000
#define heartbeat_off PORTB = PORTB & B11011111
#define LATCH_ON PORTC = PORTC | B00001000
#define LATCH_OFF PORTC = PORTC & B11110111
#define CLOCK_ON PORTB = PORTB | B00010000
#define CLOCK_OFF PORTB = PORTB & B11101111
#define DATA_ON PORTB = PORTB | B00000001
#define DATA_OFF PORTB = PORTB & B11111110
#define NUMB0_SEG B00111111
#define NUMB1_SEG B00000110
#define NUMB2_SEG B01011011
#define NUMB3_SEG B01001111
#define NUMB4_SEG B01100110
#define NUMB5_SEG B01101101
#define NUMB6_SEG B01111101
#define NUMB7_SEG B00000111
#define NUMB8_SEG B01111111
#define NUMB9_SEG B01100111
// constants won't change. Used here to set a pin number:
const int dp = LED_BUILTIN;// the number of the LED pin
// Variables will change:
int ledState = LOW; // ledState used to set the LED
// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0; // will store last time LED was updated
// constants won't change:
const long interval = 1000; // interval at which to blink (milliseconds)
//module6 variables
bool init_module6_clock;
void setup() {
// set the digital pin as output:
DDRB |= B00100000;
DDRC |= LATCH_ON;
DDRB |= DATA_ON;
DDRB |= CLOCK_ON;
Serial.begin(9600);
}
void loop() {
{ // module 6
// heartbeat module
static unsigned long module_time, module_delay;
static bool module_doStep;
static unsigned char module_i; // state variable for module 1
if (init_module6_clock) {
module_delay = 500;
module_time=millis();
module_doStep=false;
init_module6_clock=false;
module_i=0;
}
else {
unsigned long m;
m=millis();
if ((long)(m - module_time) > module_delay) {
module_time = m; module_doStep = true;
}
else module_doStep = false;
}
if (module_doStep) {
switch (module_i) {
if (ledState == LOW) {
ledState = HIGH;
heartbeat_on;
} else {
ledState = LOW;
default: module_i=0;
}
}
}
// here is where you'd put code that needs to be running all the time.
// check to see if it's time to blink the LED; that is, if the difference
// between the current time and last time you blinked the LED is bigger than
// the interval at which you want to blink the LED.
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
// save the last time you blinked the LED
previousMillis = currentMillis;
// if the LED is off turn it on and vice-versa:
if (ledState == LOW) {
ledState = HIGH;
heartbeat_on;
} else {
ledState = LOW;
heartbeat_off;
Serial.println(ledState);
}
}
}
}
so this is my code, just a bit of background info on some of the variables and stuff basically the thing im trying to work is the DP and i want it to flash. so this DP will be combined with other pieces of code that will drive other components in the circuit diagram (attached to this message). so just this part of the code is referred to as the heartbeat (as its going to be flashing throughout the code when it will be all combined for around half a second until the board loses power) . by the way, the codes a mess may be some parts which i dont even need.
this is one of my first codes ever writtern and i am new to C programming so excuse the mistakes:)
system_schematic.pdf (40.6 KB)
Give this a try. It's supposed to count your digits up from 0-9 and back to zero again, once per second. It should also toggle the DP every 300mS.
Compiles, not tested...
const uint8_t LATCH=12;
const uint8_t CLOCK=11;
const uint8_t DATA=14;
const uint8_t dp = LED_BUILTIN;
#define heartbeat_on PORTB = PORTB | B00100000
#define heartbeat_off PORTB = PORTB & B11011111
#define LATCH_ON PORTC = PORTC | B00001000
#define LATCH_OFF PORTC = PORTC & B11110111
#define CLOCK_ON PORTB = PORTB | B00010000
#define CLOCK_OFF PORTB = PORTB & B11101111
#define DATA_ON PORTB = PORTB | B00000001
#define DATA_OFF PORTB = PORTB & B11111110
#define NUMB0_SEG B00111111
#define NUMB1_SEG B00000110
#define NUMB2_SEG B01011011
#define NUMB3_SEG B01001111
#define NUMB4_SEG B01100110
#define NUMB5_SEG B01101101
#define NUMB6_SEG B01111101
#define NUMB7_SEG B00000111
#define NUMB8_SEG B01111111
#define NUMB9_SEG B01100111
uint8_t
grNumMasks[] =
{
NUMB0_SEG, NUMB1_SEG, NUMB2_SEG, NUMB3_SEG, NUMB4_SEG,
NUMB5_SEG, NUMB6_SEG, NUMB7_SEG, NUMB8_SEG, NUMB9_SEG
};
bool
bDraw = false,
ledState = false;
uint32_t
timeDP=0,
timeCount=0;
uint8_t
count = 0;
uint32_t
timeNow_mS = millis();
void setup()
{
// set the digital pin as output:
DDRB |= B00100000;
DDRC |= LATCH_ON;
DDRB |= DATA_ON;
DDRB |= CLOCK_ON;
pinMode( dp, OUTPUT ); //LED pin
CLOCK_OFF;
DATA_OFF;
LATCH_OFF;
bDraw = true; //force a digit draw right away
Serial.begin(9600);
}//setup;
void loop()
{
//count up digits once per second
if( (timeNow_mS - timeCount) >= 1000ul )
{
timeCount = timeNow_mS;
count++; //bump the digit to show
if( count == 10 ) //if we roll over past 9, go back to zero
count = 0;
bDraw = true; //force a digit update
}//if
//flash the LED every 300mS
if( (timeNow_mS - timeDP) >= 300ul )
{
timeDP = timeNow_mS;
ledState ^= true; //^ operator is exclusive OR. this toggles the state of teh ledState boolean
digitalWrite( dp, ledState ); //reflect state of DP on built-in LED
bDraw = true; //indicate we need to update the digit
}//if
//if a digit/DP update is needed, "draw" it
if( bDraw == true )
{
ShiftNumber( count, ledState ); //send digit and state of DP to draw
bDraw = false; //then clear the draw flag
}//if
}//loop
void ShiftNumber( uint8_t num, bool bDP )
{
uint8_t
mask,
shiftval;
//make sure the # to be drawn is within bounds
if( num > 9 )
return;
//get the pattern of bits to send into shiftval
shiftval = grNumMasks[num];
//the msb of shiftval is the DP; if the DP flag is set, turn this bit on
shiftval |= (bDP == true) ? 0x80:0x00;
//we look at each bit, starting from the msb
mask = 0x80;
do
{
//if the bit is set in the mask, we set data
if( shiftval & mask )
DATA_ON;
else
DATA_OFF;
//toggle clock high then low
CLOCK_ON;
CLOCK_OFF;
//move the mask one bit to the right (so 80 40 20 10 08 04 02 01 -> 00 (00 indicates we're done all bits)
mask >>= 1;
}while( mask );
//once all are shifted out, toggle the storage reg latch
LATCH_ON;
LATCH_OFF;
}//ShiftNumber
Serial.begin(9600);
You can't expect Serial to work if you are using Pin 1 for something else.
const uint8_t DATA=14;
I take it you are using Pin A0 for digital I/O. It's better to use the name A0 instead of 14. If you ever port to another board (like a MEGA or Micro) the number for A0 is not 14.
Blackfin:
Give this a try. It's supposed to count your digits up from 0-9 and back to zero again, once per second. It should also toggle the DP every 300mS.Compiles, not tested...
const uint8_t LATCH=12;
const uint8_t CLOCK=11;
const uint8_t DATA=14;
const uint8_t dp = LED_BUILTIN;
#define heartbeat_on PORTB = PORTB | B00100000
#define heartbeat_off PORTB = PORTB & B11011111
#define LATCH_ON PORTC = PORTC | B00001000
#define LATCH_OFF PORTC = PORTC & B11110111
#define CLOCK_ON PORTB = PORTB | B00010000
#define CLOCK_OFF PORTB = PORTB & B11101111
#define DATA_ON PORTB = PORTB | B00000001
#define DATA_OFF PORTB = PORTB & B11111110
#define NUMB0_SEG B00111111
#define NUMB1_SEG B00000110
#define NUMB2_SEG B01011011
#define NUMB3_SEG B01001111
#define NUMB4_SEG B01100110
#define NUMB5_SEG B01101101
#define NUMB6_SEG B01111101
#define NUMB7_SEG B00000111
#define NUMB8_SEG B01111111
#define NUMB9_SEG B01100111
uint8_t
grNumMasks[] =
{
NUMB0_SEG, NUMB1_SEG, NUMB2_SEG, NUMB3_SEG, NUMB4_SEG,
NUMB5_SEG, NUMB6_SEG, NUMB7_SEG, NUMB8_SEG, NUMB9_SEG
};
bool
bDraw = false,
ledState = false;
uint32_t
timeDP=0,
timeCount=0;
uint8_t
count = 0;
uint32_t
timeNow_mS = millis();
void setup()
{
// set the digital pin as output:
DDRB |= B00100000;
DDRC |= LATCH_ON;
DDRB |= DATA_ON;
DDRB |= CLOCK_ON;
pinMode( dp, OUTPUT ); //LED pin
CLOCK_OFF;
DATA_OFF;
LATCH_OFF;
bDraw = true; //force a digit draw right away
Serial.begin(9600);
}//setup;
void loop()
{
//count up digits once per second
if( (timeNow_mS - timeCount) >= 1000ul )
{
timeCount = timeNow_mS;
count++; //bump the digit to show
if( count == 10 ) //if we roll over past 9, go back to zero
count = 0;
bDraw = true; //force a digit update
}//if
//flash the LED every 300mS
if( (timeNow_mS - timeDP) >= 300ul )
{
timeDP = timeNow_mS;
ledState ^= true; //^ operator is exclusive OR. this toggles the state of teh ledState boolean
digitalWrite( dp, ledState ); //reflect state of DP on built-in LED
bDraw = true; //indicate we need to update the digit
}//if
//if a digit/DP update is needed, "draw" it
if( bDraw == true )
{
ShiftNumber( count, ledState ); //send digit and state of DP to draw
bDraw = false; //then clear the draw flag
}//if
}//loop
void ShiftNumber( uint8_t num, bool bDP )
{
uint8_t
mask,
shiftval;
//make sure the # to be drawn is within bounds
if( num > 9 )
return;
//get the pattern of bits to send into shiftval
shiftval = grNumMasks[num];
//the msb of shiftval is the DP; if the DP flag is set, turn this bit on
shiftval |= (bDP == true) ? 0x80:0x00;
//we look at each bit, starting from the msb
mask = 0x80;
do
{
//if the bit is set in the mask, we set data
if( shiftval & mask )
DATA_ON;
else
DATA_OFF;
//toggle clock high then low
CLOCK_ON;
CLOCK_OFF;
//move the mask one bit to the right (so 80 40 20 10 08 04 02 01 -> 00 (00 indicates we're done all bits)
mask >>= 1;
}while( mask );
//once all are shifted out, toggle the storage reg latch
LATCH_ON;
LATCH_OFF;
}//ShiftNumber
i tried uploading this code but all it does is shows a 0 on the 7 seg display and nothing is flashing?
If you want the decimal point to flash for the number 3.14, then you do:
void loop()
{
display.goto(0, 0); //row, col
display.print("3.14");
while (true) {
delay(1000);
display.goto(0, 1);
display.print(" ");
delay(1000);
display.goto(0, 1);
display.print(".");
}
}
Untested pseudocode, how you implement is up to you. Bitbanging? 
m005a:
i tried uploading this code but all it does is shows a 0 on the 7 seg display and nothing is flashing?
Oh, oops. I'd had variables in loop() but decided to move them out into global land but neglected to handle the reading of millis(). Try this:
const uint8_t LATCH=12;
const uint8_t CLOCK=11;
const uint8_t DATA=14;
const uint8_t dp = LED_BUILTIN;
#define heartbeat_on PORTB = PORTB | B00100000
#define heartbeat_off PORTB = PORTB & B11011111
#define LATCH_ON PORTC = PORTC | B00001000
#define LATCH_OFF PORTC = PORTC & B11110111
#define CLOCK_ON PORTB = PORTB | B00010000
#define CLOCK_OFF PORTB = PORTB & B11101111
#define DATA_ON PORTB = PORTB | B00000001
#define DATA_OFF PORTB = PORTB & B11111110
#define NUMB0_SEG B00111111
#define NUMB1_SEG B00000110
#define NUMB2_SEG B01011011
#define NUMB3_SEG B01001111
#define NUMB4_SEG B01100110
#define NUMB5_SEG B01101101
#define NUMB6_SEG B01111101
#define NUMB7_SEG B00000111
#define NUMB8_SEG B01111111
#define NUMB9_SEG B01100111
uint8_t
grNumMasks[] =
{
NUMB0_SEG, NUMB1_SEG, NUMB2_SEG, NUMB3_SEG, NUMB4_SEG,
NUMB5_SEG, NUMB6_SEG, NUMB7_SEG, NUMB8_SEG, NUMB9_SEG
};
bool
bDraw = false,
ledState = false;
uint32_t
timeDP=0,
timeCount=0;
uint8_t
count = 0;
uint32_t
timeNow_mS;
void setup()
{
// set the digital pin as output:
DDRB |= B00100000;
DDRC |= LATCH_ON;
DDRB |= DATA_ON;
DDRB |= CLOCK_ON;
pinMode( dp, OUTPUT ); //LED pin
CLOCK_OFF;
DATA_OFF;
LATCH_OFF;
bDraw = true; //force a digit draw right away
Serial.begin(9600);
}//setup;
void loop()
{
timeNow_mS = millis();
//count up digits once per second
if( (timeNow_mS - timeCount) >= 1000ul )
{
timeCount = timeNow_mS;
count++; //bump the digit to show
if( count == 10 ) //if we roll over past 9, go back to zero
count = 0;
bDraw = true; //force a digit update
}//if
//flash the LED every 300mS
if( (timeNow_mS - timeDP) >= 300ul )
{
timeDP = timeNow_mS;
ledState ^= true; //^ operator is exclusive OR. this toggles the state of teh ledState boolean
digitalWrite( dp, ledState ); //reflect state of DP on built-in LED
bDraw = true; //indicate we need to update the digit
}//if
//if a digit/DP update is needed, "draw" it
if( bDraw == true )
{
ShiftNumber( count, ledState ); //send digit and state of DP to draw
bDraw = false; //then clear the draw flag
}//if
}//loop
void ShiftNumber( uint8_t num, bool bDP )
{
uint8_t
mask,
shiftval;
//make sure the # to be drawn is within bounds
if( num > 9 )
return;
//get the pattern of bits to send into shiftval
shiftval = grNumMasks[num];
//the msb of shiftval is the DP; if the DP flag is set, turn this bit on
shiftval |= (bDP == true) ? 0x80:0x00;
//we look at each bit, starting from the msb
mask = 0x80;
do
{
//if the bit is set in the mask, we set data
if( shiftval & mask )
DATA_ON;
else
DATA_OFF;
//toggle clock high then low
CLOCK_ON;
CLOCK_OFF;
//move the mask one bit to the right (so 80 40 20 10 08 04 02 01 -> 00 (00 indicates we're done all bits)
mask >>= 1;
}while( mask );
//once all are shifted out, toggle the storage reg latch
LATCH_ON;
LATCH_OFF;
}//ShiftNumber
with all due respect, this is doing a countdown and i just need to get the decimal point on the 7 segment display flashing continously. is there a possibility if the countdown can be removed out of the code?
m005a:
with all due respect, this is doing a countdown and i just need to get the decimal point on the 7 segment display flashing continously. is there a possibility if the countdown can be removed out of the code?
The code should show a blinking DP while the countdown occurs.
Do you not seeing it blinking now?
Does the LED on the board (LED_BUILTIN) blink?
The led onboard of the Arduino nano is flashing but thats not the right led i need the the dot on the 7 segment display to be flashing continuously the code you made includes a countdown which is not required
You can lead a horse to water, but...
TheMemberFormerlyKnownAsAWOL:
You can lead a horse to water, but...
well, do you think i would be posting questions on forums if i had the ability in me to re-code so that i can get DP on the display flashing i can re-code this to make a different LED that is directly connected to the arduino but this required bit-banging which i do know about a bit but im not sure about big banging with the 7 segment display. so just a kind reminder if you do not know the situation of others do not judge and keep the silly comments to yourself.
m005a:
The led onboard of the Arduino nano is flashing but thats not the right led i need the the dot on the 7 segment display to be flashing continuously the code you made includes a countdown which is not required
The DP should be blinking even if the 7-seg is showing a digit count.
I've disabled the count here; it will just show '0'. But the DP should be blinking, my logic analyzer sez so:
DP on:
DP off:
If you're not seeing that I would double check your wiring and check the health of the DP diode.
const uint8_t LATCH=12;
const uint8_t CLOCK=11;
const uint8_t DATA=14;
const uint8_t dp = LED_BUILTIN;
#define heartbeat_on PORTB = PORTB | B00100000
#define heartbeat_off PORTB = PORTB & B11011111
#define LATCH_ON PORTC = PORTC | B00001000
#define LATCH_OFF PORTC = PORTC & B11110111
#define CLOCK_ON PORTB = PORTB | B00010000
#define CLOCK_OFF PORTB = PORTB & B11101111
#define DATA_ON PORTB = PORTB | B00000001
#define DATA_OFF PORTB = PORTB & B11111110
#define NUMB0_SEG B00111111
#define NUMB1_SEG B00000110
#define NUMB2_SEG B01011011
#define NUMB3_SEG B01001111
#define NUMB4_SEG B01100110
#define NUMB5_SEG B01101101
#define NUMB6_SEG B01111101
#define NUMB7_SEG B00000111
#define NUMB8_SEG B01111111
#define NUMB9_SEG B01100111
uint8_t
grNumMasks[] =
{
NUMB0_SEG, NUMB1_SEG, NUMB2_SEG, NUMB3_SEG, NUMB4_SEG,
NUMB5_SEG, NUMB6_SEG, NUMB7_SEG, NUMB8_SEG, NUMB9_SEG
};
bool
bDraw = false,
ledState = false;
uint32_t
timeDP=0,
timeCount=0;
uint8_t
count = 0;
uint32_t
timeNow_mS;
void setup()
{
// set the digital pin as output:
DDRB |= B00100000;
DDRC |= LATCH_ON;
DDRB |= DATA_ON;
DDRB |= CLOCK_ON;
pinMode( dp, OUTPUT ); //LED pin
CLOCK_OFF;
DATA_OFF;
LATCH_OFF;
bDraw = true; //force a digit draw right away
Serial.begin(9600);
}//setup;
void loop()
{
timeNow_mS = millis();
#if 0
//count up digits once per second
if( (timeNow_mS - timeCount) >= 1000ul )
{
timeCount = timeNow_mS;
count++; //bump the digit to show
if( count == 10 ) //if we roll over past 9, go back to zero
count = 0;
bDraw = true; //force a digit update
}//if
#endif
//flash the LED every 300mS
if( (timeNow_mS - timeDP) >= 300ul )
{
timeDP = timeNow_mS;
ledState ^= true; //^ operator is exclusive OR. this toggles the state of teh ledState boolean
digitalWrite( dp, ledState ); //reflect state of DP on built-in LED
bDraw = true; //indicate we need to update the digit
}//if
//if a digit/DP update is needed, "draw" it
if( bDraw == true )
{
ShiftNumber( count, ledState ); //send digit and state of DP to draw
bDraw = false; //then clear the draw flag
}//if
}//loop
void ShiftNumber( uint8_t num, bool bDP )
{
uint8_t
mask,
shiftval;
//make sure the # to be drawn is within bounds
if( num > 9 )
return;
//get the pattern of bits to send into shiftval
shiftval = grNumMasks[num];
//the msb of shiftval is the DP; if the DP flag is set, turn this bit on
shiftval |= (bDP == true) ? 0x80:0x00;
//we look at each bit, starting from the msb
mask = 0x80;
do
{
//if the bit is set in the mask, we set data
if( shiftval & mask )
DATA_ON;
else
DATA_OFF;
//toggle clock high then low
CLOCK_ON;
CLOCK_OFF;
//move the mask one bit to the right (so 80 40 20 10 08 04 02 01 -> 00 (00 indicates we're done all bits)
mask >>= 1;
}while( mask );
//once all are shifted out, toggle the storage reg latch
LATCH_ON;
LATCH_OFF;
}//ShiftNumber
TheMemberFormerlyKnownAsAWOL:
You can lead a horse to water, but...
Here's a little face splash to maybe trigger (right word?) some thirst...
#define DP_SEG B10000000
I figured that out from looking at the schematic. You illuminate and control the DP just the same as all the other segments. Of course, because that is how the display module is organized. That's why it's nonsense to talk about bit banging. Any banging that you need is already happening in the code. I told you that before.
m005a:
well, do you think i would be posting questions on forums if i had the ability in me to re-code so that i can get DP on the display flashing i can re-code this to make a different LED that is directly connected to the arduino but this required bit-banging which i do know about a bit but im not sure about big banging with the 7 segment display. so just a kind reminder if you do not know the situation of others do not judge and keep the silly comments to yourself.
Well, I can see that you're an engineering student at a university. That kind of sets a bar.
Let’s define the requirement a little better...
EDIT: Sorry, I wrote this immediately after reading another thread using two digits shifting, my brain wrapped around. The details are still correct, just 8 bits rather than 16...
Because you’re bit banging the shift registers, you MUST refresh the whole display for every change to be displayed.
In the examples above, you’re shifting out all 16 bits needed for the two digits and decimal points.
If you want the dp to change state independently of the digit segments, you need to toggle only the dp bits as required, and pump out the WHOLE 16 bits for EVERY update.
The digits only need to change when the values change, but the dps will be refreshed every 300mS, so you need to pump the whole 16 bit long bitstream out every 300mS.
lastchancename:
Let’s define the requirement a little better...
Because you’re bit banging the shift registers, you MUST refresh the whole display for every change to be displayed.
In the examples above, you’re shifting out all 16 bits needed for the two digits and decimal points.
If you want the dp to change state independently of the digit segments, you need to toggle only the dp bits as required, and pump out the WHOLE 16 bits for EVERY update.The digits only need to change when the values change, but the dps will be refreshed every 300mS, so you need to pump the whole 16 bit long bitstream out every 300mS.
Look at the schematic. There is only one SR and one digit. So none of this applies, except that the DP has to be or'ed with the segment data as you implied.
aarg:
Here's a little face splash to maybe trigger (right word?) some thirst...#define DP_SEG B10000000I figured that out from looking at the schematic. You illuminate and control the DP just the same as all the other segments. Of course, because that is how the display module is organized. That's why it's nonsense to talk about bit banging. Any banging that you need is already happening in the code. I told you that before.
but in order to control the segments wouldnt you require bit banging as the 7 segment is not directly connected to the arduino nano but connected to the 74HC595 and then the arduino?