Completely different.
How? One starts and runs every 500ms followed by another 100ms later, in both cases… I guess it might change slightly over time… too much math to confirm or deny for me 
but simply staggering the times does the same thing.
In your example, Sent_serial runs every 500 ms and checkCombined runs every 600 ms. In my example, they both run every 500 ms only checkCombined is staggered 100 ms after Sent_serial.
Option 1 - Option 2
500 - 500
600 - 600
1000 - 1000
1200 - 1100
1500 - 1500
1800 - 1600
2000 - 2000
2400 - 2100
2500 - 2500
3000 - 2600
3000 - 3000
3600 - 3100
Assuming I did this right (my “timing” could very well be off 
) then yes, they spread out differently. And if maintaining exact spacing between timers matters, then option 2 with the delay() is better. But that is not often the issue, avoiding running functions concurrently, or at least too frequently, is the issue.
Basically 6 of one, 1/2 dozen of the other 
Understood. But eventually, with your approach, the two functions will execute concurrently. With my approach, they’ll never execute concurrently.
OK, I will concede that fact 
… I just hate confusing noobs with whether using delay() with Blynk code is bad or not. I know how to use it properly, but some seem to get confused with the whole “But I thought it wasnt allowed” routine.
Understood. But I think it’s also confusing to have to pick some phony baloney timer interval when you could simply stagger the intervals. In either case, back to the terminal widget repeating messages.
Yep… nice thing about standards, like opinions, everyone has their own 
@877 Basicly, pick a method and stager your timers, then see how it runs over time.
It is also important to have enough time between timers to actualy complete all the function’s tasks at their worst case scenario before being tasked to start over again… like some micromanaging managers I have ran into in long past jobs 
Has anyone ever confirmed,
WidgetTerminal terminal(V1);
Blynk.virtualWrite(V1, string);
is functionally equivalent to terminal.print(), terminal.println() and terminal.write() in the context of,
Are we sure there’s no “magic” under the covers of terminal.print(), terminal.println() and terminal.write()?
There is some magic… in the sense that I think they were designed to provide “custom packaged commands” and possibly buffering (in the case of terminal) for some of the early widgets… like led.on() etc.
But in the end, I believe the coding behind Blynk.virtualWrite() is the basis of both methods… you just have to add in custom things like line feeds, etc. as needed for Terminal printing.
In my experience, I get more control and less “duplication” with the Blynk.virtualWrite() for Terminal printing.
I don’t know, @Gunner. @877 is calling terminal.flush() in conjunction with Blynk.virtualWrite,
Blynk.virtualWrite(V1, content);
terminal.flush();
I’m not convinced Blynk.virtualWrite is writing to a buffer that would be flushed by terminal.flush().
If it were me, I’d give terminal.print() and terminal.println() a try. Of course, there’s a pretty good chance I’m wrong. Personally, I think the terminal.print() and terminal.println() in conjunction with terminal.flush() is more readable.
I see what you mean… No, terminal.flush() is NOT needed with Blynk.virtualWrite() as that command sends the values immediately out just like with all other display widgets.
Yes, that is what I meant by the developers making “custom packaged commands” for the early widgets (and users)… but as one becomes more experienced, we can code a bit closer to the bare metal.
Exactly! What if Blynk.virtualWrite is immediately writing to the terminal and at the same time, the same message is getting written to the buffer and later flushed. You’d see the same message in the terminal twice. Doh!
1 Like
Hi both,
Don’t worry this noob is not confused about using delay 
To clarify, I only added the terminal.flushes to see if it helped fix the problem, I’m pretty sure they are not the cause of the duplication.
I’ll try and stagger the timers and report back. I’m wondering if I could time how long each function takes to run through to ensure the timer delays are long enough 
1 Like
Would you please test terminal.print() and terminal.println() in conjunction with terminal.flush(), rather than Blynk.virtualWrite().
Yes no problems, I already have that code as I originally wrote it that way. I will post when back at my PC tomorrow. Thanks 
I can’t guarantee this will fix your “Terminal repeating” problem, however, I’m confident the result will be different using terminal.print() / terminal.println() vs Blynk.virtualWrite(Vx, content).
There are two parts to the Terminal widget. There’s the Blynk application part and the device firmware part,
WidgetTerminal terminal(Vx);
If you use Blynk.virtualWrite(Vx, content), you don’t even need to declare the WidgetTerminal terminal(Vx). Blynk.virtualWrite(Vx, content) will still write characters to the terminal widget on the Blynk app, however, I get the sense they’re missing certain “metadata”.
The notion of terminal.flush() is a function of the Terminal widget on the device. There’s “magic” underlying the terminal.print() / terminal.println() commands. For example,
class WidgetTerminal
virtual size_t write(uint8_t byte) {
mOutBuf[mOutQty++] = byte;
if (mOutQty >= sizeof(mOutBuf)) {
flush();
}
return 1;
}
virtual void flush() {
if (mOutQty) {
Blynk.virtualWriteBinary(mPin, mOutBuf, mOutQty);
mOutQty = 0;
}
}
writes characters to a 64-character buffer (mOutBuf). If the number of characters written exceeds the size of the buffer, the buffer it automagically flushed. Of course, the terminal.flush() function flushes the buffer.
If you’re invoking Blynk.virtualWrite(Vx, content) directly, all of this logic is bypassed.
I vote we test terminal.print() and terminal.println() in conjunction with terminal.flush(), rather than Blynk.virtualWrite(). If that doesn’t solve the problem, we’ll go from there. But this is the way the Terminal widget was intended to be used.
1 Like
@wickedbeernut apologies for the delay, I have been unwell over the weekend 
That makes sense, I will rewrite the code with terminal prints and report back.
Do you think the serial to terminal code could be causing any issues?
I have modified the code below, but am getting more duplicate entries than ever! It’s actually lots worse than using the Blynk.virtualWrite(V1, “text”);
(I was just getting server reconnect messages at random times before).
With terminal.print, when I reopen the iOS app after a few minutes inactivity, the screen scrolls very fast and then the duplicate entries are there.
Pasted from terminal:
1/1/1970 @ 0:0:6 Server connected
Free RAM: 46808 bytes
IP: 192.168.1.xx
[6131]
___ __ __
/ _ )/ /_ _____ / /__
/ _ / / // / _ \/ '_/
/____/_/\_, /_//_/_/\_\
/___/ v0.6.1 on ESP8266
[6207] Connecting to 192.168.1.xx:xxxx
[6263] Ready (ping: 8ms).
[6404] Time sync: OK
27/3/2019 @ 20:22:47 System disarm request
27/3/2019 @ 20:22:52 System arm request
27/3/2019 @ 20:22:55 System armed
27/3/2019 @ 20:22:59 Sounder activated!
27/3/2019 @ 20:23:4 System disarmed
27/3/2019 @ 20:23:7 System disarm request
27/3/2019 @ 20:23:11 Sounder deactivated
27/3/2019 @ 20:23:14 System arm request
27/3/2019 @ 20:23:17 System armed
1/1/1970 @ 0:0:6 Server connected
Free RAM: 46808 bytes
IP: 192.168.1.xx
[6131]
___ __ __
/ _ )/ /_ _____ / /__
/ _ / / // / _ \/ '_/
/____/_/\_, /_//_/_/\_\
/___/ v0.6.1 on ESP8266
[6207] Connecting to 192.168.1.xx:xxx
[6263] Ready (ping: 8ms).
[6404] Time sync: OK
27/3/2019 @ 20:22:47 System disarm request
27/3/2019 @ 20:22:52 System arm request
27/3/2019 @ 20:22:55 System armed
27/3/2019 @ 20:22:59 Sounder activated!
27/3/2019 @ 20:23:4 System disarmed
27/3/2019 @ 20:23:7 System disarm request
27/3/2019 @ 20:23:11 Sounder deactivated
27/3/2019 @ 20:23:14 System arm request
27/3/2019 @ 20:23:17 System armed
I’m happy to try anything else you can suggest!
Thanks
//v010 Garage alarm (see changelog below)
//
//
//Project requirements:
//The alarm panel has two outputs, Armed and Sounder
//Poll these two outputs every 1000ms and write the result to a virtual LED (Blynk app on phone)
//The alarm panel has one input SET which can arm or disarm the system
//When a virtual button is pressed (on phone Blynk app) the alarm is armed or unarmed.
//
//
//Changelog:
//v004 had issues with Blynk server heartbeat timeouts and app disconnecting and sometimes unresponsive
//v005 combines both armed and sounder functions into one, run by one timer
//v006 added serial to terminal code as per this thread https://community.blynk.cc/t/serial-arduino-to-terminal-blynk/31547/4
//v007 added correct serial to terminal code working correctly - needs rx to tx link on device
//v008 added date/time stamp to terminal widget, required rtc widget on app, and added serial prints when states change
//v009 fixes for terminal repeating (used BlynkTimer and increased timer interval. Optional add Blynk.run to function so that more CPU time is allocated for housekeeping. Rewrote serial prints as virtual writes to V1. Search for "v009" to see changes.
//v010 added delay between timer functions. More fixes for terminal repeats (changed Blynk.virtualWrite for terminal.print).
//
//Future improvements:
// Change code to Blynk.virtualWrite(vPin, "Random blatherings\n")
// Blynk.virtualWrite(V1, "\n" ); //starts new line
#define BLYNK_PRINT Serial // Defines the object that is used for printing Blynk stuff
#include <BlynkSimpleEsp8266.h>
#include <ESP8266mDNS.h> //for OTA updates
#include <WiFiUdp.h> //for OTA updates
#include <ArduinoOTA.h> //for OTA updates
#include <WidgetRTC.h> //for clock sync
//Blynk credentials
char auth[] = ""; // v009 TEST Breadboard auth token
//Wifi credentials
char ssid[] = ""; //Enter your WIFI Name
char pass[] = ""; //Enter your WIFI Password
//Server credentials
char server[] = ""; //LOCAL SERVER ONLY
int port = xxxx; //LOCAL SERVER ONLY
//Support for Blynk terminal
WidgetTerminal terminal(V1); //terminal reads from virtual pin specified, possibly not needed when using "Blynk.virtualWrite(Vx, content)"
//Support for Blynk real time clock
WidgetRTC rtc;
//SimpleTimer timer; //setup simple timer to call functions on a timed basis from void loop
BlynkTimer timer; // v009 improvement http://docs.blynk.cc/#blynk-firmware-blynktimer
//Setup constants for the sketch
const byte Armed = D5; // INPUT - is the panel armed, or un-armed/alarmed? (armed = HIGH/3.3V and Unarmed/alarmed = LOW/0V)
const byte Sounder = D6; // INPUT - is the sounder on or off? (Sounder on = LOW/0.33V and Sounder off = HIGH/3.3V)
const byte SET = D4; // OUTPUT - set or unset the alarm (HIGH = unset the alarm, LOW = set the alarm)
//Setup variables for Armed
int ArmedState = digitalRead(Armed); //reads armed state of the alarm (armed = HIGH/3.3V and Unarmed/alarmed = LOW/0V)
int lastArmedState = ArmedState; // the previous read from the input pin
//Setup variables for Sounder
int SounderState = digitalRead(Sounder); //reads state of sounder i.e on or off (Sounder on = LOW/0.33V and Sounder off = HIGH/3.3V)
int lastSounderState = SounderState; // the previous read from the input pin
//Setup variables for debouncing of inputs
unsigned long lastArmedDebounceTime = 0; //setup debounce variable for checkArmed function
unsigned long lastSounderDebounceTime = 0; // setup debounce variable for checkSounder function
unsigned long debounceDelay = 50; // the global debounce time in ms, increase if debounce issues continue
//Setup variable for Blynk virtual pin
static unsigned long last_interrupt_time = 0;
bool LastVirtualButtonState = 0; //"0","FALSE","LOW' means exactly the same
void setup()
{
Serial.begin(9600);
Blynk.begin(auth, ssid, pass, server, port); //connects to Wifi and LOCAL Blynk server (running on raspberry pi)
setSyncInterval(60 * 60); // v009 increase time if needed - Sync Blynk real time clock (RTC) interval in seconds (default 10x60 = 10 minutes)
//OTA stuff (update device from Arduino IDE remotely)
ArduinoOTA.onError([](ota_error_t error) { ESP.restart(); });
ArduinoOTA.setHostname("Wemos_no_01_TEST_GARAGE_ALARM"); // for testing purposes
ArduinoOTA.begin();
//Setup the previously assigned constants
pinMode(Armed, INPUT); //is the panel armed, or un-armed/alarmed? (armed = HIGH/3.3V and Unarmed/alarmed = LOW/0V)
pinMode(Sounder, INPUT); //is the sounder on or off? (Sounder on = LOW/0.33V and Sounder off = HIGH/3.3V)
pinMode(SET, OUTPUT); //set or unset the alarm (HIGH = unset the alarm, LOW = set the alarm)
digitalWrite(SET, LOW); //ensures the alarm defaults to SET condition after power loss of Wemos
//write the current states to the Blynk app
Blynk.virtualWrite(V5, (ArmedState * 255)); // writes set or unset state of alarm to Blynk virtual LED pin V5
Blynk.virtualWrite(V6, (!SounderState * 255)); //writes sounder on or off state to Blynk virtual LED pin V6 (inverted logic as sounder is on when at 0V
//Setup Blynktimers
timer.setInterval(500L, Sent_serial); // Timer calls function to send any serial data to terminal - default 100ms - v009 increase interval if needed
delay(100); //added 100ms delay to ensure timers do not get called at the same time
timer.setInterval(500L, checkCombined); //Timer calls function to read state of alarm panel - default 100ms - v009 increase interval if needed
//Optional print free memory to terminal
terminal.print("Free RAM: "); //v010
terminal.print(ESP.getFreeHeap()); //v010
terminal.println(" bytes"); //v010
terminal.flush(); //v010
}
void loop()
{
Blynk.run(); //This function should be called frequently to process incoming commands and perform housekeeping of Blynk connection.
timer.run(); //Initiates SimpleTimer to runs timed functions
ArduinoOTA.handle(); // For OTA
}
BLYNK_CONNECTED()
{
rtc.begin(); // Synchronize time on connection
serial_print_date_time();
terminal.println("Server connected"); //v010
terminal.flush(); //v010
}
//A function to print current date and time to Blynk terminal widget, gets called from the below functions
void serial_print_date_time()
{
//v010 changes below
String currentDate = String(day()) + "/" + month() + "/" + year();
String currentTime = String(hour()) + ":" + minute() + ":" + second();
terminal.print(currentDate);
terminal.print(" @ ");
terminal.print(currentTime);
terminal.print(" ");
}
void Sent_serial() //A function which reads the serial monitor output and send to terminal widget (requires tx and rx pins to be connected together on device).
{
// Sent serial data to Blynk terminal - Unlimited string readed
String content = ""; //null string constant ( an empty string )
char character;
while(Serial.available())
{
character = Serial.read();
content.concat(character);
}
if (content != "")
{
terminal.print(content); // v010
terminal.flush(); // Ensure that data was sent out of device //added by 877dec v009
}
}
void checkCombined()// a combined function to read the "armed" state and the "sounder" state
{
int readingArmed = digitalRead(Armed); // read the state of "Armed" into a local variable:
if (readingArmed != lastArmedState) //has the state changed?
{
lastArmedDebounceTime = millis(); // if yes(state has changed), reset the debouncing timer to the current millis
}
if ((millis() - lastArmedDebounceTime) > debounceDelay) // whatever readingArmed is at, it's been there for longer than the debounce delay, so take it as the actual current state
{
if (readingArmed != ArmedState) // has the armed state has changed?
{
ArmedState = readingArmed; // if yes(state has changed)
Blynk.virtualWrite(V5, (ArmedState) * 255); // writes ArmedState to Blnk V5 virtual LED names "Alarm armed?"
if (ArmedState == LOW)
{
serial_print_date_time();
terminal.println("System disarmed"); //v010
terminal.flush(); // Ensure that data was sent out of device
}
else
{
serial_print_date_time();
terminal.println("System armed"); //v010
terminal.flush(); // Ensure that data was sent out of device
}
}
}
lastArmedState = readingArmed; // save the readingArmed. Next time through the function, it'll be the lastArmedState:
Blynk.run(); //v009 optional extra Blynk.run to allocate more CPU/RAM to the Blynk process, to remove duplicate terminal issues
int readingSounder = digitalRead(Sounder); // read the state of "Armed" into a local variable:
if (readingSounder != lastSounderState) //has the state changed?
{
lastSounderDebounceTime = millis(); // if yes(state has changed), reset the debouncing timer to the current millis
}
if ((millis() - lastSounderDebounceTime) > debounceDelay) // whatever readingSounder is at, it's been there for longer than the debounce delay, so take it as the actual current state
{
if (readingSounder != SounderState) // has the sounder state has changed?
{
SounderState = readingSounder; // if yes(state has changed)
Blynk.virtualWrite(V6, (!SounderState) * 255); // writes SounderState to Blnk V6 virtual LED named "Sounder on?"
if (SounderState == LOW)
{
Blynk.notify("Garage alarm is sounding!"); //only send Blynk app notification when then sounder is ON
serial_print_date_time();
terminal.println("Sounder activated!"); //v010
terminal.flush(); // Ensure that data was sent out of device
}
else
{
serial_print_date_time();
terminal.println("Sounder deactivated"); //v010
terminal.flush(); // Ensure that data was sent out of device
}
}
}
lastSounderState = readingSounder; // save the readingSounder. Next time through the function, it'll be the lastSounderState:
}
// BLYNK_WRITE is a function called every time the device gets an update of a Virtual Pin value from the server (e.g. Blynk app virtual button is pressed)
// contains "latching" code to stop long hold being registered as repeated presses.
BLYNK_WRITE(V3)
{
int VirtualButtonState = param.asInt(); // assigning incoming value from pin V3 to a variable
if ((VirtualButtonState) && (!LastVirtualButtonState)) // "VirtualButtonState" is the Blynk virtual button current state |||||| this means same as "if ((VirtualButtonState == 1) && (LastVirtualButtonState == 0))"
//if V3 virtual button is still being pressed, the LastVirtualState is set to 1, and !LastVirtualState will therefore be 0. Hence 1 && 0 condition == 0 and therefore function will not be called.
{
digitalWrite(SET, !digitalRead(SET)); //writes the inverse value to the pin (booleon NOT operator )
Blynk.virtualWrite(V0, digitalRead(SET) * 255); // for information only, writes the state of the keyswitch SET contacts to Blynk virtual LED at V0
if (digitalRead(SET) == LOW)
{
serial_print_date_time();
terminal.println("System arm request"); //v010
terminal.flush(); // Ensure that data was sent out of device
}
else
{
serial_print_date_time();
terminal.println("System disarm request"); //v010
terminal.flush(); // Ensure that data was sent out of device
}
}
LastVirtualButtonState = VirtualButtonState; // sets LastVirtualButtonState to the same as pinValue, so if pinValue (V3 button) is high, LastVirtualPinState gets set to high
}
I’m a bit confused (aren’t we all!).
When I use this approach I use Serial.print for everything. The function then mirrors all of the serial monitor output to the terminal as well. That way, if your device is connected to your PC by serial connection you get the output in the serial monitor, plus it appears in the Blynk terminal screen anyway.
I don’t get any duplication of output.
My version of Sent_serial() uses Blynk.virtualWrite instead of terminal.print(content) and terminal.flush()
Here’s my version, including a switch to disable the terminal output if desired:
void Send_Serial()
{
// Sends serial data to Blynk as well as the serial monitor
//(handy for setups where the MCU isn't connected to serial because OTA is being used)
// Note that a jumper is needed between Tx and Rx, which needs to be removed
// if doing a serial flash upload (but this is not necessary for OTA flash upload)
if (terminal_output_enabled)
{
String content = "";
char character;
while(Serial.available())
{
character = Serial.read();
content.concat(character);
}
if (content != "")
{
Blynk.virtualWrite (Widget_Terminal, content);
}
}
} //end of void Send_Serial
I found it necessary to add this line immediately after Serial.begin, to give a larger serial buffer to avoid lost characters:
Serial.setRxBufferSize(1024); // Increase the serial buffer size
After that, everything is done as a Serial.print and appears in as normal in the serial monitor and in the terminal widget (with a slight lag, as I tend to run my timer every 1000 millis rather than 500), provided the terminal_output_enabled boolean variable is set to true.
Pete.