Coder Legion - Recent posts tagged task

Zapier for Small Business: Pricing, Limits, and Best Fit

Sat, 24 Oct 2026 15:50:00 +0000

Zapier is a strong first automation platform for a small business that needs a simple workflow live quickly. The Free plan is useful for testing one-trigger, one-action workflows, Professional unlocks multi-step automation, and Team adds shared connections and controls. The trade-off is task billing: every successful counted action uses capacity, so cost can rise as workflows become longer or run more often.

Prices and task rules can change. The plan details below were verified against Zapier's official pricing and task documentation on August 1, 2026.

Quick decision: is Zapier the right fit?

Situation	Best starting point	Why	Watch for
One simple app-to-app workflow	Zapier Free	Fast setup, 100 tasks per month, and two-step workflows.	The free plan allows one trigger and one action per workflow.
Several multi-step workflows	Zapier Professional	Multi-step workflows, premium apps, webhooks, and built-in logic.	Successful actions and some AI steps consume tasks.
A team sharing automations	Zapier Team	Shared workflows, folders, app connections, roles, and SAML SSO.	Confirm the current user and task limits before buying.
High-volume or complex branching	Compare Make and n8n	Another billing model or self-hosting may reduce cost and add control.	More control also creates more setup and maintenance work.

What Zapier actually is

Zapier is a workflow automation tool, in the same family as Make and n8n. You build a Zap: a trigger that starts it, then one or more actions that do the work. New lead in a form, then create a CRM record, send an email, post a Slack alert. That chain is your Zap. It is the same trigger-steps-workflow model I walked through in what is n8n, just with Zapier's names on it.

What Zapier is genuinely best at

Zapier is not the cheapest tool, and I will get to that. But it is the best at several things that matter to a small business:

The most integrations, by a wide margin. Zapier connects 9,000+ apps. If you use a tool, even a niche one, the odds that Zapier already supports it are higher than with any competitor. That alone solves a lot of "but does it work with ___" questions.
The easiest start. The setup is the friendliest in the category. Pick a trigger, pick an action, map a few fields, turn it on. Most people get their first Zap running without reading a manual.
It is reliable and well-documented. Zapier has been doing this the longest, so between templates, help docs, and the guides online, you are rarely the first person to try what you are trying.
A practical free plan for testing. It includes 100 tasks per month, unlimited workflow assets, and two-step workflows with one trigger and one action.

Zapier includes more than workflows

Zapier now bundles more of its core platform into the Free, Professional, and Team plans. That matters because a small business can keep a lightweight form, data table, and automation in the same account:

Forms and Interfaces collect data through simple pages without requiring a separate form product for a basic intake flow.
Tables stores leads, projects, inventory, or workflow state. Zapier's current task-rate page lists Tables and Forms among the built-in tools that do not use tasks.
Zapier MCP lets supported AI assistants call Zapier actions. The current rate is two tasks per MCP tool call, so usage still needs a budget.

The platform is more unified than it was, but "included" does not mean unlimited. Plans still have task, record, page, user, and feature limits. Check the live plan comparison before building a core process around any one allowance.

What Zapier costs

Zapier bills most automation work with tasks. A standard successful action normally uses one task. Polling triggers do not use tasks, and Zapier currently lists built-in tools such as Filters, Paths, Formatter, Delay, Tables, and Forms at zero tasks.

Plan	Published starting price	Useful limit or feature	Best fit
Free	$0	100 tasks per month and two-step workflows.	Testing one small automation.
Professional	$19.99/month, billed annually	Starts at 750 tasks with multi-step workflows and premium apps.	An individual or small team with real production workflows.
Team	$69/month, billed annually	Shared workflows and app connections, roles, and up to 25 users.	A team that needs collaboration and account controls.
Enterprise	Custom	Governance, observability, deployment controls, and enterprise support.	Large or regulated organizations.

These are starting prices published by Zapier and may change with billing interval, currency, tax, task tier, or product updates. I put the billing models side by side with Make and n8n in Zapier vs Make vs n8n pricing.

Where Zapier can get expensive

The same task-based pricing that keeps simple Zaps cheap is what bites at scale. Picture a four-step Zap that runs 500 times a month. That is roughly 2,000 tasks, and a fifth step adds another 500. The cost grows with both how many steps you have and how often they run. For a light, simple automation this is a non-issue. For a heavy multi-step workflow running thousands of times a month, the invoice is where Zapier tends to lose to Make and n8n.

AI steps need a separate check. Since June 15, 2026, AI by Zapier uses model tiers: Standard uses one task per step, Advanced uses three, and Premium uses five. Tool calls add tasks at the same tier. A workflow that looks like one AI step in the editor can therefore consume more than one task per run.

It is not a flaw, it is a trade-off. You are paying for the easiest, most-connected tool on the market. The question is just whether that premium is worth it for your specific workflow.

What you can automate with Zapier

Theory is dull, so here is what Zapier actually does for a small team. Each of these is a real Zap you can build today:

Catch and follow up on new leads before they go cold, pulling them from forms, email, and chat into your CRM and inbox. See small business automation in the Philippines.
Automate the right thing first. Most small businesses pick the wrong starting point. Here is how to choose a first Zap that actually pays off: most businesses automate the wrong thing first.
Turn a free Google Form into an intake pipeline, so every submission is logged, tagged, and acted on without you touching it. See how to connect Google Forms to Sheets and Gmail without Zapier.
Replace manual copy-paste between the apps you already pay for, so nobody moves data by hand all day.

None of these need a developer on staff. They need a clear process and a tool that can run it. Before you commit a core process to it, it is worth knowing what the same workflow costs on each platform, which I broke down in how much it costs to automate lead follow-up.

Is Zapier right for your business?

Often, yes, especially at the start. Zapier is the right choice when you value simplicity and breadth over price, when you need an integration with a less common app, or when you just want your first few automations live this afternoon without a learning curve. For a small team automating a handful of simple things, it is hard to beat.

It becomes a weaker fit when a workflow has many counted actions, runs at high volume, or must be self-hosted. At that point compare n8n, which prices Cloud by full workflow executions and offers a self-hosted option, or Make's credit model. If the source and destination already have a dependable native integration, use that first. The pricing comparison shows the same workflow under all three billing models.

Where to learn Zapier

Zapier has its own free learning hub. It is lighter than Make's academy and you can get through it quickly, but it gives you the core ideas fast, which is exactly what Zapier is about. For most people that plus the in-product templates is enough to get going.

Personally, the resource I would point a beginner to is this free 4-hour Zapier course from freeCodeCamp. Four hours sounds like a lot, but the delivery is so easy it flies by. One rule: do not just watch it. Build every example alongside the video in your own account, that is the difference between having seen it and being able to do it. freeCodeCamp is a great channel in general, with a huge amount of free material worth digging into.

Where to start

Pick the most annoying repetitive task in your week and describe it in one sentence: when X happens, do Y, then tell me. Build that one Zap on the free plan and let it run for a week. Keep it small; a Zap that quietly saves ten minutes a day teaches you more than an ambitious one that breaks on its first edge case. Once it is running, the next few tasks become obvious. If you would rather have the first few built properly, with error handling so they do not fail silently, that is what I do.

Sources

Not sure which tool fits?

Tell me the most repetitive task in your week. I can map a simple workflow for it and tell you honestly whether to build it on Zapier, Make, or n8n, and what it will cost to run.

Get the map

Originally published on FloxoLab.

Why Claude + MCP Is the Most Powerful Tool I Have Ever Put to Work

Thu, 16 Jul 2026 23:21:39 +0000

Why Claude + MCP Is the Most Powerful Tool I've Ever Put to Work

AI & MCP · Updated July 2026 · 9 min read · by Jacob Campbell

I build websites for a living, so I'm hard to impress with 'AI tools.' Most of them talk. Claude, connected through MCP servers, is the first one I've watched actually do the work — reach into my real tools, make the change, and check it — all inside one conversation. This isn't a chatbot review; it's what happened when I pointed it at this very website, and why I now think the combination of Claude and MCP is the most capable tool I've ever put to work.

Key facts

1 ask — One request, many tools working together
88 — Files translated and updated in a single task
11 — Languages kept in sync automatically
MCP — The open standard that connects Claude to your tools

From answering questions to doing the work

The old model of AI was a smart parrot: you asked, it answered, and you did the work. MCP flips that. The Model Context Protocol lets Claude connect to your actual applications — your files, your CMS, your automations — and act in them directly. Instead of 'here's how you'd fix that,' it's 'I fixed it, here's the diff, and I verified it.' That single shift is the difference between advice and a colleague.

What MCP actually is, in plain English

MCP (Model Context Protocol) is an open standard — think of it as a universal adapter between Claude and software. Each 'server' exposes a set of tools (read a file, publish a post, query a database) that Claude can call safely, only after you connect it. You're not wiring up brittle scripts; you connect a tool once and Claude can use it in any conversation. Because it's an open standard, the same Claude can drive thousands of different apps.

What that looked like on this very site

This isn't theoretical — here's a sample of what Claude did on this site in one session. It fixed the mobile language picker and phone placement across every page. It added a fresh, topic-specific section to eight of my blog guides and translated it into all eleven languages — 88 files updated in a single pass, each validated. Through a Zapier MCP server it read my newest posts from Webflow and published a roundup to an RSS feed — two separate apps cooperating in one request. Then it built an entire new multilingual article and wired it into routing, the sitemap and the feed. See one of those posts: SEO, AEO, GEO & SERP explained.

The real unlock: set Claude up to succeed

The magic isn't luck; it's setup. Give Claude the right context — access to the folder, the connected tools, and a clear task — and it plans, executes, and checks its own work. The pattern that makes every task land is simple: connect the tools it needs, state the outcome you want, and let it verify before it calls something done. Set it up to succeed and it succeeds; leave it guessing and it guesses. Most 'AI didn't work' stories are really setup stories.

Learn faster by watching Claude work

Here's the part I didn't expect: I learn more by watching Claude do a task than by reading a tutorial about it. It narrates each step, shows the code it changed, and explains why — so a job like 'wire a translated article into the sitemap' becomes a walkthrough I can actually follow. After a few tasks you absorb the how, not just the result. It's teaching by doing, on your own project, at your pace — the fastest way to learn something new that I've found.

Why this is a step-change — and how to start

Tools that only advise leave all the doing (and all the learning curve) on you. A tool that connects to your stack, acts, verifies, and explains as it goes compounds: every task ships and teaches at the same time. You don't need to be technical to start — connect one or two tools you already use, hand Claude a real task, and watch. The first time you see one ask move work across two apps, the paradigm clicks.

Sources & further reading

Related services

Frequently asked questions

What is MCP?

MCP (Model Context Protocol) is an open standard that connects Claude to your real software — files, a CMS, automations, databases — so it can act in those tools directly instead of only giving advice.

What can Claude do with MCP that it couldn't before?

It can read and change things in the apps you connect: edit files, publish content, run automations across services, and verify the result — all within one conversation, rather than handing you steps to do yourself.

Does Claude act on my tools without permission?

You choose which tools to connect, and connections are approved by you. Claude works within the tools you've granted, and for sensitive actions the right pattern is to review what it proposes before it runs.

How do I get started with Claude and MCP?

Connect one or two tools you already use, then give Claude a small, real task that spans them. Seeing a single request pull from one app and act in another is the fastest way to understand the value.

How does this help me learn faster?

Because Claude narrates and shows its work as it goes, you learn by watching a real task on your own project — the code it changes, the tools it calls, and why. It's teaching by doing, which sticks better than a generic tutorial.

Want a site — and a workflow — built to move this fast?

I build custom sites and set up the tools and automations around them so the whole thing runs like you saw here. One flat fee.

Get my free quote

How Do Smart Devices Perform Multiple Tasks?

Mon, 04 May 2026 10:58:23 +0000

Hello, I'm Ganesh. I'm building git-lrc, an AI code reviewer that runs on every commit. It is free, unlimited, and source-available on Github. Star Us to help devs discover the project. Do give it a try and share your feedback for improving the product.

Ever wonder how your Alexa, robot vacuum cleaner, and smartwatch seamlessly perform multiple tasks without getting stuck in the middle? How exactly are these devices programmed to handle it all?

You came to the right place to understand how it happens under the hood.

In this article, we will understand how these tasks are performed and how they work.

As all these devices use a microcontroller. I will be explaining using the simple microcontroller ESP8266.

How will the task be performed?

Every smart device consists of a microcontroller. These microcontrollers are programmed to perform specific tasks.

These tasks are performed using a single loop function.

void loop() {
 // Perform Task
}

This loop function will run continuously.

In this loop, we can do multiple things.

Let's take the example of a weather monitoring device.
These operations are done using a single loop function. As there is nothing else to do.

Start Device
Start Loop
Read sensor data
Display data / Store data
Repeat the process

void loop() {
 // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

 // Send data to cloud
  sendDataToCloud(temperature, humidity);
}

But this comes with a problem.

This loop will be running with a microsecond delay.
If we run this loop function, it will run continuously. Means there will be no delay between the operations.

How will a normal loop cause a problem?

Let's assume the above operation takes 1 ms (which is not true in real-world use, as it depends on which microcontroller you use).

The DHT11 sensor should have a 1-second delay between readings.

That means the above loop will run 1000 times in 1 second to just see if the sensor data has changed.

Can you see the problem?

1000 times operation means 1000 times power consumption.

1000 times the power consumption means the battery will drain fast, or the embedded system will heat up.

To avoid this, we can use a delay function.

void loop() {
 // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

 // Send data to cloud
  sendDataToCloud(temperature, humidity);

 // Wait for 1 second
  delay(1000);
}

By adding a delay, we are making sure that the loop function is not running continuously.

This is a good implementation if we have only one task to perform.

But if we want to do multiple operations to be performed in specific intervals.

Adding Other Operations in a loop

Like this, if we want to read the DHT11 sensor every 1 second and read the MQ2 sensor every 5 seconds. We can't use the delay function.

It will be like this.

void loop() {
 // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

 // Send data to cloud
  sendDataToCloud(temperature, humidity);
 // Read data from sensor
  float gas = analogRead(MQ2_PIN);

 // Send data to cloud
  sendDataToCloud(gas);

 // Wait for 5 seconds
  delay(5000);
}

This will cause a 5-second no-data reading from the DHT11 sensor.

Hence, there will be data loss for 5 seconds.

Here is where the task scheduler comes into the picture.

What is Task Scheduler?

A task scheduler is a lightweight system that allows a processor to juggle multiple activities seemingly at the same time, a concept known as multitasking.

A Task Scheduler solves this problem using a "to-do list" approach.

Instead of freezing, the program loops continuously at top speed.

Every time it loops, the scheduler checks the clock and looks at its list of tasks to see if any are due to run right now.

If a task's time is up, the scheduler runs it and then immediately goes back to checking the clock.

To understand the internal clock, imagine the microcontroller holding a stopwatch that starts counting milliseconds the moment it powers on.

In the Arduino framework, this stopwatch is read using a function called millis().

Instead of pausing the whole system to wait, the scheduler constantly checks this stopwatch against a simple formula for each task:

Current Time - Last Time Executed >= Interval

Here is a simple example of how the task scheduler works in ESP8266.

Ex:

unsigned long previousDHTTime = 0; // Remembers the last time DHT ran
unsigned long previousMQ2Time = 0; // Remembers the last time MQ2 ran

const long dhtInterval = 1000; // 1000 milliseconds = 1 second
const long mq2Interval = 5000; // 5000 milliseconds = 5 seconds

void setup() {
 // Initialization code goes here
}

void loop() {
 // 1. Read the internal stopwatch
  unsigned long currentMillis = millis(); 

 // 2. Check the DHT Task
  if (currentMillis - previousDHTTime >= dhtInterval) {
 previousDHTTime = currentMillis; // Reset this task's timer
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

 // Send data to cloud
    sendDataToCloud(temperature, humidity);

 }

 // 3. Check the MQ2 Task
  if (currentMillis - previousMQ2Time >= mq2Interval) {
 previousMQ2Time = currentMillis; // Reset this task's timer

    float gas = analogRead(MQ2_PIN);

 // Send data to cloud
    sendDataToCloud(gas);
 }
}

This way, we can perform multiple operations in specific intervals without blocking the loop function.

Core Logic of Task Scheduler

I want to perform two operations in ESP8266.

Blink the LED every 2.5 seconds 1 time.
Blink the LED every 5 seconds 2 times.

Let's see how to do this without using the built-in task scheduler.

Set up serial communication and the LED pin.
Start Loop.
Check if 2.5 seconds have passed since the last task activation.
If yes, perform the blink.
Check if 5 seconds have passed since the last task activation.
If yes, perform the blink

#include <Arduino.h>

unsigned long t25, t50;

/**
 * Performs a single blink on the built-in LED (Active Low).
 * @param message Debug message to output to Serial.
 */
void performBlink(const char *message) {
  Serial.println(message);
  digitalWrite(LED_BUILTIN, 0); // LED ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // LED OFF
  delay(80);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start with LED OFF
}

void loop() {
 // Task 1: Every 2.5s (triggers at 2.5s, 5.0s, 7.5s...)
  if (millis() - t25 >= 2500) {
 t25 = millis();
    performBlink("[2.5s] ");
 }

 // Task 2: Every 5.0s (triggers at 5.0s, 10.0s...)
 // At 5s, both tasks trigger, resulting in a double blink.
  if (millis() - t50 >= 5000) {
 t50 = millis();
    performBlink("[5.0s] ");
 }
}

Output:

[2.5s] 
[5.0s] 
[2.5s] 
[2.5s] 
[5.0s]

See, as we defined, to use a 2.5 sec interval for the first task and a 5 sec interval for the second task.

This also means the 2nd time, a 2.5 sec blink will happen after 5 sec from the 1st blink.

This will create a 2-second blink in 5 sec.

<h2

How to use Task Scheduler in ESP8266?

Sun, 12 Apr 2026 22:21:41 +0000

In this article, We will be exploring inbult task function in ESP8266.

Core Logic of Task Scheduler

I want to perform two operations in ESP8266.

Blink LED every 2.5 seconds 1 time.
Blink LED every 5 seconds 2 times.

Let's see how to do this without using inbuilt task scheduler.

Setup Serial communication and LED pin.
Start Loop.
Check if 2.5 seconds have passed since the last task activation.
If yes, perform the blink.
Check if 5 seconds have passed since the last task activation.
If yes, perform the blink

#include <Arduino.h>

unsigned long t25, t50;

/**
 * Performs a single blink on the built-in LED (Active Low).
 * @param message Debug message to output to Serial.
 */
void performBlink(const char *message) {
  Serial.println(message);
  digitalWrite(LED_BUILTIN, 0); // LED ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // LED OFF
  delay(80);
}

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start with LED OFF
}

void loop() {
  // Task 1: Every 2.5s (triggers at 2.5s, 5.0s, 7.5s...)
  if (millis() - t25 >= 2500) {
    t25 = millis();
    performBlink("[2.5s] ");
  }

  // Task 2: Every 5.0s (triggers at 5.0s, 10.0s...)
  // At 5s, both tasks trigger, resulting in a double blink.
  if (millis() - t50 >= 5000) {
    t50 = millis();
    performBlink("[5.0s] ");
  }
}

Output:

[2.5s] 
[5.0s] 
[2.5s] 
[2.5s] 
[5.0s]

See as we defined to use 2.5 sec interval for first task and 5 sec interval for second task.

This also mean 2nd time 2.5 sec blink will happen after 5 sec from 1st blink.

This will create 2 times blink in 5 sec.

Using Task Scheduler

We are going to use task scheduler library to perform multiple operations in specific intervals.

Let's see how to do this using task scheduler library.

Include task scheduler library.
Create a scheduler object.
Define tasks.
Add tasks to the scheduler.
Enable tasks.
Run the scheduler.

#include <Arduino.h>
#include <TaskScheduler.h>

Scheduler runner;

/**
 * Performs a single blink pulse.
 * Note: NodeMCU V2 built-in LED is active LOW.
 */
void pulse() {
  digitalWrite(LED_BUILTIN, 0); // ON
  delay(80);
  digitalWrite(LED_BUILTIN, 1); // OFF
  delay(80);
}

void Callback(const char *msg) {
  Serial.println(msg);
  pulse();
}

// Task Definitions
Task t25(2500, TASK_FOREVER, []() { Callback("[2.5s] "); });
Task t50(5000, TASK_FOREVER, []() { Callback("[5.0s] "); });

void setup() {
  Serial.begin(115200);
  pinMode(LED_BUILTIN, OUTPUT);
  digitalWrite(LED_BUILTIN, 1); // Start OFF

  runner.init();

  // Add tasks to the scheduler
  runner.addTask(t25);
  runner.addTask(t50);

  // Enable tasks
  t25.enable();
  t50.enable();
}

void loop() { runner.execute(); }

By this way we can perform multiple operations in specific intervals without blocking the loop function.

Output:

[5.0s] 
[2.5s] 
[5.0s] 
[2.5s] 
[2.5s]

You can also see 5.0s blink is happening first and sometimes 2.5s blink is happening first.

This is because of the task scheduler.

Conclusion

By this we understood how task scheduler works in ESP8266.

And we actualy used task scheduler to perform multiple operations in specific intervals without blocking the loop function.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

How to perform multiple operations in the ESP8266?

Fri, 10 Apr 2026 21:18:16 +0000

In this article, We will be exploring how to perform multiple operations in ESP8266.

As we are using ESP8266, we will be using Arduino framework.
Let see how operations are performed in ESP8266 or any other embedded system.

How Operations are performed in ESP8266?

Before going to understand how to perform multiple operations in ESP8266. Let's understand what is how regular programming works in embedded systems.

Any activity in embedded system is done using loop function.

void loop() {
  // Do something
}

This loop function will run continuously.

In this loop we can do multiple things.

For example we can read dht11 sensor data

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);
}

But this comes with a problem.

If we run this loop function, it will run continuously. Means there will be no delay between the operations.

How Normal Loop will cause problem?

Let's assume above operation takes 1 ms (which is not true in real world).
And DHT11 sensor should have 1 second delay between readings.

That means above loop will run 1000 times in 1 second to just see if the sensor data is changed.

Can you see the problem?

1000 times operation means 1000 times power consumption.

1000 times power consumption means battery will drain fast or embedded system will heat up.

To Avoid this we can use delay function.

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);

  // Wait for 1 second
  delay(1000);
}

By adding delay we are making sure that the loop function is not running continuously.

But this also has a problem.

If we add delay of 1 second, it means the loop function will run only once in 1 second.

So if we want to do multiple operations to be performed in specific intervals. It will be blocked.

Adding Other Operation in loop

Like this if we want to read dht11 sensor every 1 second and read mq2 sensor every 5 seconds. We can't use delay function.

It will be like this

void loop() {
  // Read data from sensor
  float temperature = dht.readTemperature();
  float humidity = dht.readHumidity();

  // Send data to cloud
  sendDataToCloud(temperature, humidity);
  // Read data from sensor
  float gas = analogRead(MQ2_PIN);

  // Send data to cloud
  sendDataToCloud(gas);

  // Wait for 5 seconds
  delay(5000);
}

This will cause 5 sec no data reading from dht11 sensor.

Here where task scheduler comes into picture.

What is Task Scheduler?

A task scheduler is a lightweight system that allows a processor to juggle multiple activities seemingly at the same time, a concept known as multitasking.

A Task Scheduler solves this problem using a "to-do list" approach.

Instead of freezing, the program loops continuously at top speed.

Every time it loops, the scheduler checks the clock and looks at its list of tasks to see if any are due to run right now.

If a task's time is up, the scheduler runs it, and then immediately goes back to checking the clock.

To understand the internal clock, imagine the microcontroller holding a stopwatch that starts counting milliseconds the moment it powers on.

In Arduino framework, this stopwatch is read using a function called millis().

Instead of pausing the whole system to wait, the scheduler constantly checks this stopwatch against a simple formula for each task:

Current Time - Last Time Executed >= Interval

Here is simple example of how task scheduler works in ESP8266.

Ex:

unsigned long previousDHTTime = 0;  // Remembers the last time DHT ran
unsigned long previousMQ2Time = 0;  // Remembers the last time MQ2 ran

const long dhtInterval = 1000;      // 1000 milliseconds = 1 second
const long mq2Interval = 5000;      // 5000 milliseconds = 5 seconds

void setup() {
  // Initialization code goes here
}

void loop() {
  // 1. Read the internal stopwatch
  unsigned long currentMillis = millis(); 

  // 2. Check the DHT Task ⏱️
  if (currentMillis - previousDHTTime >= dhtInterval) {
    previousDHTTime = currentMillis;  // Reset this task's timer
    float temperature = dht.readTemperature();
    float humidity = dht.readHumidity();

    // Send data to cloud
    sendDataToCloud(temperature, humidity);

  }

  // 3. Check the MQ2 Task ⏱️
  if (currentMillis - previousMQ2Time >= mq2Interval) {
    previousMQ2Time = currentMillis;  // Reset this task's timer

    float gas = analogRead(MQ2_PIN);

    // Send data to cloud
    sendDataToCloud(gas);
  }
}

This way we can perform multiple operations in specific intervals without blocking the loop function.

Conclusion

In this article we have seen how to perform multiple operations in specific intervals without blocking the loop function in ESP8266.

In next article we will use inbuilt task scheduler and itegrate with painlessmesh.

Any feedback or contributors are welcome! It’s online, source-available, and ready for anyone to use.
⭐ Star it on GitHub: https://github.com/HexmosTech/git-lrc

Automation periodically tasks with CRON job scheduler

Mon, 13 Jan 2025 20:57:40 +0000

What is CRON? Unix-like operating systems provide utility for run periodical tasks. For example you need to run script every day at 08:00 AM. CRON read tasks from configuration file line by line and have special syntax.

Windows have their own tool named as "Windows Task Scheduler".

Open terminal and run "crontab -e" command. When you open crontab first time, you must choose editor, which is convenient for your use. Enter number of preferred editor and press "Enter":

user@localhost:~$ crontab -e
no crontab for user - using an empty one

Select an editor.  To change later, run 'select-editor'.
  1. /bin/nano        <---- easiest
  2. /usr/bin/vim.tiny

Choose 1-2 [1]:

When you open cron system display generated configuration file with description:

# Edit this file to introduce tasks to be run by cron.
#
# Each task to run has to be defined through a single line
# indicating with different fields when the task will be run
# and what command to run for the task
#
# To define the time you can provide concrete values for
# minute (m), hour (h), day of month (dom), month (mon),
# and day of week (dow) or use '*' in these fields (for 'any').
#
# Notice that tasks will be started based on the cron's system
# daemon's notion of time and timezones.
#
# Output of the crontab jobs (including errors) is sent through
# email to the user the crontab file belongs to (unless redirected).
#
# For example, you can run a backup of all your user accounts
# at 5 a.m every week with:
# 0 5 * * 1 tar -zcf /var/backups/home.tgz /home/
#
# For more information see the manual pages of crontab(5) and cron(8)
#
# m h  dom mon dow   command

Structure of executable command:

# ┌───────────── minute (0–59)
# │ ┌───────────── hour (0–23)
# │ │ ┌───────────── day of the month (1–31)
# │ │ │ ┌───────────── month (1–12)
# │ │ │ │ ┌───────────── day of the week (0–6) (Sunday to Saturday;
# │ │ │ │ │                                   7 is also Sunday on some systems)
# │ │ │ │ │
# │ │ │ │ │
# * * * * * <command to execute>

Here cheat-sheet of some examples:

Run task every minute:

* * * * * cd /home/user && ./my_script.sh

Run task every 5 minutes:

*/5 * * * * cd /home/user && ./my_script.sh

Run task every 1 hour:

0 * * * * cd /home/user && ./my_script.sh

Or use "@hourly" definition.

Run task every day at 00:00:

0 0 * * * cd /home/user && ./my_script.sh

Or use "@daily" definition.

If your command not running by any reason use "bash -c":

*/5 * * * * bash -c 'cd /home/user && ./my_script.sh'

Run task at system startup:

@reboot cd /home/user && ./my_script.sh

Save changes and exit from editor. Now we're need to reload CRON service. Its need for read configuration file again. Just use "service cron reload" command:

user@localhost:~$ service cron reload
Reloading configuration files for periodic command scheduler: cron.