Whether you're a student submitting a math assignment or a professional documenting formulas, Google Docs provides multiple ways to insert and format equations efficiently.

In this article, you'll learn how to write math equations in Google Docs using different methods, including using Google Docs’ built-in equation editor and typing LaTeX-style commands directly, inserting complex equations with the help of the Auto-LaTeX add-on, and copying math equations from ChatGPT to Google Docs without losing formatting by using the ChatGPT to Google Docs or PDF Chrome extension.

Table of Contents

• How to Write Equations Using the Built-in Equation Editor

• How to Write Equations Using LaTeX Commands

• How to Use Auto Latex Add-on for Writing Advanced Math Equations

• How to Copy Math Equations from ChatGPT to Google Docs

• Watch: How to Write Equations in Google Docs

• Tips for Formatting Math Equations in Google Docs

• Conclusion

How to Write Equations Using the Built-in Equation Editor

Google Docs has a built-in equation editor that makes it easy to insert mathematical symbols and expressions.

To insert an equation editor box:

1. Open your Google Docs document.

2. Go to the top menu and click Insert → Equation.

3. An equation editor will appear, and a new toolbar will show up with common math symbols like fractions, exponents, Greek letters, and more.

Alternatively, you can use the following keyboard shortcuts to insert an equation editor box.

• Windows/Linux: Alt + I, then E

• Mac: Control + Option + I, then E

This shortcut quickly opens the equation editor without clicking through menus.

Toolbar Symbols:

Once the toolbar appears, you’ll find buttons for:

• Greek letters

• Miscellaneous operations

• Relations

• Math operations

• Arrows

The equation editor box and a toolbar look like the following:

Now let’s learn how to write equations using the equation editor with a practical example.

Example: Typing the Quadratic Formula

Follow these steps to insert the following quadratic formula in Google Docs:

$$x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$$

1. Go to Insert → Equation to insert an equation editor and enable the equation toolbar.

2. Type x=

3. Click the Math Operations dropdown (the one with templates like square roots, brackets), then select the fraction template. This inserts a placeholder with two parts: a numerator and a denominator.

   

4. Click inside the numerator field. Begin by typing -b.

5. Now insert the ± (plus-minus) symbol. To do this:

   • Click the Miscellaneous Operations dropdown

   • Select the ± symbol from the list.
     Your numerator should now show: -b ± as in the following image:

   • 

6. After the ± symbol, insert a square root:

   • Go back to the Math Operations dropdown and select the square root template.

   • Inside the root, type b^2 - 4ac.

     • Use ^ to enter exponents. For example, b^2 will be rendered as b².

       

7. Move to the denominator field and type 2a.

Now your full equation should appear as:

The equation will be properly formatted using Google Docs’ equation rendering, making it easy to read and mathematically accurate. You can continue typing more text below or beside the equation as needed – it behaves like any other element in your document.

This approach is useful for inserting neatly formatted equations without relying on add-ons or external tools. It’s especially helpful for students, teachers, and professionals preparing technical documents directly in Google Docs.

How to Write Equations Using LaTeX Commands

If you're familiar with LaTeX, you can take advantage of Google Docs’ support for a subset of LaTeX-style commands inside the built-in equation editor. This can greatly speed up the process of entering complex mathematical expressions, especially if you're already comfortable with LaTeX syntax.

How to Use LaTeX Commands in Google Docs

1. Open your Google Docs document.

2. Go to Insert → Equation to activate the equation toolbar and equation input field.

3. Click inside the equation box. Instead of using the toolbar buttons, type LaTeX-style commands directly.

4. As you type, Google Docs will automatically render the commands into formatted math once you press space or enter after each command or expression.

Commonly Supported LaTeX Commands in Google Docs:

Type these commands in the equation box, and when you press space or enter, they will be converted to properly formatted mathematical notation.

Example: Typing the Quadratic Formula Using LaTeX Commands

Let’s walk through how to enter the following quadratic formula using LaTeX-style commands:

$$x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$$

Steps:

1. Insert the equation box: Go to Insert → Equation.

2. In the equation input area, type the following:

x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

• \frac creates a fraction.

• -b is the numerator’s first term.

• \pm inserts the plus-minus symbol.

• \sqrt creates a square root.

• b^2 formats b squared.

• - 4ac is written normally inside the square root.

• 2a is the denominator.

3. As you type, press space or enter after each LaTeX command. Google Docs will automatically convert the code into properly formatted math notation.

After rendering, the equation will appear as:

This method is ideal for users who prefer keyboard-based input over clicking toolbar icons. It also allows you to enter complex expressions faster and more accurately, especially if you're familiar with standard LaTeX syntax.

Notes:

• Not all LaTeX features are supported in Google Docs. The supported commands are limited to basic math formatting, Greek letters, and common symbols.

• Make sure to press space after each LaTeX command so that Docs knows to render it.

How to Use Auto Latex Add-on for Writing Advanced Math Equations

When generating mathematical content using tools like ChatGPT, you'll notice that equations are rendered visually on the webpage, but behind the scenes they’re created using LaTeX code. So when you copy content from ChatGPT into Google Docs, the equations come through as raw LaTeX code rather than rendered math expressions.

For example, a quadratic formula provided by ChatGPT might look like this when pasted into your document:

x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}

While this format is ideal for precision, Google Docs doesn’t support LaTeX rendering by default.

This is where the Auto-LaTeX Equations add-on becomes essential, especially if you're moving content from ChatGPT to Google Docs. It’s also incredibly useful when importing LaTeX-based documents into Google Docs, such as content originally written in Overleaf or other LaTeX editors.

Instead of manually reformatting equations, the add-on automatically renders LaTeX code into properly formatted math equations, preserving the typesetting and structure you’d expect from a LaTeX environment.

What is Auto-LaTeX Equations?

Auto-LaTeX Equations is a free and open-source Google Docs add-on that scans your document for LaTeX expressions and converts them into a properly formatted equations.

It recognizes LaTeX code wrapped in these delimiters:

• Inline: $$ ... $$

• Display: \[ ... \]

Once detected, it renders the equations seamlessly within your document, eliminating the need to retype or manually format them.

1. Paste your LaTeX expression into the Google Docs document. Make sure the expression is enclosed using one of the supported delimiters:

   $$ ... $$ or \[ ... \]

2. Open the add-on sidebar by clicking Extensions → Auto-LaTeX Equations → Start.

3. Once the sidebar opens, you’ll see a dropdown labeled “Delimiters” and a button called “Render Equations.”

4. Select the delimiter you used when enclosing your LaTeX equations – for example, $$ or \[ \].

5. Click the “Render Equations” button.

The add-on will automatically scan your document and convert all valid LaTeX expressions into properly formatted equation images.

This step-by-step process allows you to take any LaTeX-based math copied from ChatGPT and render it cleanly within Google Docs – ready for export to Word or PDF.

Example: Converting a LaTeX coded Equation to Rendered Math Equations

Paste the following equation into Google Docs:

$$ x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a} $$

To convert it:

1. Go to Extensions → Auto-LaTeX Equations → Start.

2. Select the Delimitor as $$ ..$$ and click on the Render Equations button. The equation will be rendered and look as follows:

$$x = \frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$$

How to Install Auto-LaTeX Equations

1. In Google Docs, click Extensions → Add-ons → Get add-ons.

2. Search for Auto-LaTeX Equations.

3. Click Install and follow the prompts.

4. After installation, access it from Extensions → Auto-LaTeX Equations.

How to Copy Math Equations from ChatGPT to Google Docs

To easily transfer math equations and the surrounding content from ChatGPT into Google Docs without losing formatting, use the free ChatGPT to Google Docs or PDF Chrome extension.

This extension allows you to:

• Export a single response (with equations and tables) into Google Docs while preserving formatting

• Export an entire conversation, including math, code, and text, into a clean, one organized Google Docs, no need to export responses separately and merge multiple Google Docs into one later

• Save ChatGPT canvas content as a Google Docs or PDF

• Export ChatGPT deep research documents directly into Google Docs

• Export ChatGPT content directly into PDF format when no further edits are necessary, eliminating the need to first export to Google Docs and then convert Google Docs to PDF

It’s especially useful for students, researchers, and professionals who want to keep their AI-generated math, notes, and research well-organized in Google Docs or PDF format with minimal effort.

Watch: How to Write Equations in Google Docs

If you prefer visual learning, here’s a helpful video walkthrough that demonstrates all the methods discussed above – using the built-in equation editor, LaTeX-like commands, and the Auto-LaTeX Equations add-on.

This step-by-step tutorial covers:

• Opening and using the built-in equation toolbar

• Typing LaTeX-style commands directly in the equation editor

• Converting AI-generated LaTeX (e.g., from ChatGPT) into clean equations

Tips for Formatting Math Equations in Google Docs

Use inline equations when:

• Inserting short expressions like x², a/b, or single variables

• Including math within a sentence to maintain the flow of text

Use block equations when:

• Writing complex or multi-line formulas (e.g., the quadratic formula)

• You want the equation to be clearly separated from the surrounding text for readability

Wrapping tips for rendered equations:

• Rendered equations are treated as images in Google Docs, which may disrupt the document layout if not positioned correctly

• To fix this:

  • Click the equation image

  • Choose from:

    • In line – aligns the equation with surrounding text (best for inline use)

    • Wrap text – wraps paragraph text around the equation image

    • Break text – places the equation on its own line, isolating it

  • Use the margin handles or spacing options to fine-tune the layout and prevent overlap or crowding

Conclusion

Google Docs offers several flexible ways to write and manage math equations:

• Use the built-in equation editor for basic symbols, fractions, exponents, and common operations. It’s easy to access and great for straightforward math tasks without needing special syntax.

• Try LaTeX-like commands inside the equation editor for faster input. You can type commands like \frac, \sqrt, or \alpha to quickly insert structured equations without navigating menus.

• Install add-ons like Auto-LaTeX Equations for advanced LaTeX rendering. This is especially useful if you're copying equations from Overleaf, ChatGPT, or LaTeX documents into Google Docs, as it preserves formatting and converts code into clean equation images.

• Use external tools when copying from other formats, like the ChatGPT to Google Docs or PDF Chrome extension, which helps retain equation formatting when moving content from ChatGPT or other platforms.

Whether you’re completing math homework, preparing teaching materials, or writing a research paper, Google Docs, combined with these tools, gives you everything you need to create clear, professional-looking documents with math content.

By combining multiple files into one, users can keep information organized, streamline collaboration, and simplify document handling for larger projects or recurring tasks.

But Google Docs lacks a built-in feature for merging multiple documents. This can make this process time-consuming if you’re trying to do it manually.

While there are add-ons available for merging multiple Google Docs into one, you can also create your own scripts using Google Apps Script or the Google Docs API for customized solutions. This approach gives you greater flexibility, letting you set up recurring document consolidation and manage high volumes of merges tailored to your specific needs.

In this tutorial, I’ll explain how to merge multiple Google Docs into one document using Apps Script or the Google Docs API.

How to Merge Google Docs Using Google Apps Script

Using Google Apps Script to merge multiple Google Docs is a straightforward way to automate document merging directly within Google Workspace.

This approach should work well for you if you need a simple solution that doesn’t require complex setups or external APIs. You can run Apps Script within Google Drive, making it easy to set up and execute directly from the browser.

Below is a step-by-step guide on how to use Google Apps Script for merging documents.

Step 1: Open Google Apps Script

In Google Drive, click on New > Google Apps Script to create a new script.

Then name the project something relevant, like “Document Merger.”

Step 2: Write the Apps Script Code

Copy and paste the following code into the Apps Script editor. This script will create a new Google Doc and append content from each specified document.

function mergeGoogleDocs(docIds) {
  const mergedDoc = DocumentApp.create("Merged Document"); // Creates a new document
  const body = mergedDoc.getBody();

  docIds.forEach(id => {
    const doc = DocumentApp.openById(id);
    const docBody = doc.getBody();

    // Append content of each document to the merged document
    for (let i = 0; i < docBody.getNumChildren(); i++) {
      const element = docBody.getChild(i).copy(); // Copy each element to preserve formatting
      body.appendParagraph(element.getText());
    }
    body.appendPageBreak(); // Add a page break after each document
  });

  Logger.log("Merged Document URL: " + mergedDoc.getUrl());
}

function runMerge() {
  const docIds = [
    'DOCUMENT_ID_1', 
    'DOCUMENT_ID_2', 
    'DOCUMENT_ID_3'
  ]; // Replace with your actual document IDs

  mergeGoogleDocs(docIds);
}

Explanation of the Code:

• Creating the Merged Document: DocumentApp.create("Merged Document") creates a new Google Doc named "Merged Document," which will serve as the destination for all the content.

• Retrieving and Copying Content: DocumentApp.openById(id) opens each document in docIds, then retrieves its body content. The script copies each element, preserving its original formatting, and appends it to the new document.

• Adding Page Breaks: body.appendPageBreak() adds a page break after each document, helping maintain a clear separation between merged sections.

• Logging the Merged Document URL: The final URL of the merged document is logged, allowing you to access it directly from the Apps Script console.

Step 3: Run the Script

First, you’ll want to save the script and authorize any required permissions.

Then in the Apps Script editor, select runMerge() as the function to run. Enter an array of document IDs you want to merge, like ['DOCUMENT_ID_1', 'DOCUMENT_ID_2', 'DOCUMENT_ID_3'].

Finally, run the script, and it will create a merged document in your Google Drive. The URL will display in the console log.

How to Customize the Script

Order of Documents: The sequence in which documents are merged is controlled by the order of docIds in the array. Arrange these document IDs to define the exact order you want in the final document.

This approach is useful for structuring documents such as reports, books, or presentations, ensuring that chapters or sections appear in the intended flow.

Adding Custom Formatting: The script can be customized to add specific formatting to each section of the merged document. You can insert headers or footers to distinguish each document, include page breaks, or set up consistent styling for fonts, sizes, and colors.

For example, you can add headers programmatically at the start of each new document in the merge, helping create a cohesive structure.

Handling Specific Elements: Apps Script supports detailed customization to merge only certain types of content, like text, images, or tables, while skipping others. You can adjust the script to filter out elements by type or to prioritize specific formats.

For instance, to create a visually appealing document, you might choose to merge only text and images while excluding tables or unsupported elements. This approach provides a more polished final document by focusing on the content types you need most.

When to Use Google Apps Script for Merging

Google Apps Script is ideal if you want a simple, in-drive solution without needing to set up external API access. It’s especially useful for quick merges or individual projects within Google Workspace, and it provides enough flexibility to handle most standard document formats and structures.

For more complex requirements, such as merging across other platforms or integrating with external tools, consider using the Google Docs API explained in the next section.

How to Merge Google Docs Using the Google Docs API

Combining Google Docs using the Google Docs API allows you to programmatically combine content from multiple documents into one unified file. This is ideal for automating repetitive merges or creating customized documents on demand.

This approach is powerful for users who need precise control over document content, formatting, and layout, making it suitable for larger workflows or integrations within other applications.

Below is a detailed, step-by-step guide on how to use the Google Docs API to merge multiple Google Docs into one.

Step 1: Enable the Google Docs API

First, go to the Google Cloud Console. Create a new project or select an existing one.

In the API Library, search for "Google Docs API" and enable it for your project.

Next, create OAuth 2.0 credentials by going to APIs & Services > Credentials. Choose Create Credentials > OAuth client ID and configure this for a Web Application if you plan to integrate it into Web services.

Step 2: Install the googleapis Client Library

In a Node.js environment, you’ll need the googleapis package to interact with the Google Docs API. Install it by running:

npm install googleapis

Step 3: Write the Script to Merge Google Docs

The following script uses the Google Docs API to create a new document, retrieve content from each source document, and then append this content to the new document.

const { google } = require('googleapis');
const docs = google.docs('v1');

async function mergeGoogleDocs(auth, docIds) {
  // Step 3a: Create a new document that will serve as the merged document
  const newDoc = await docs.documents.create({
    auth,
    requestBody: { title: 'Merged Document' },
  });
  const newDocId = newDoc.data.documentId;

  // Step 3b: Loop through each document ID, retrieving content and appending it to the new document
  for (const docId of docIds) {
    // Retrieve the document's body content
    const doc = await docs.documents.get({
      auth,
      documentId: docId,
    });

    // Prepare each content element as a request for the new document
    const requests = doc.data.body.content.map((element) => ({
      insertText: {
        text: element.paragraph?.elements?.[0]?.textRun?.content || '',
        location: { index: 1 }, // Append to the start of the document, shift with each insertion
      },
    }));

    // Send a batch update request to insert all elements into the new document
    await docs.documents.batchUpdate({
      auth,
      documentId: newDocId,
      requestBody: { requests },
    });
  }

  console.log(`Merged Document URL: https://docs.google.com/document/d/${newDocId}`);
}

Explanation of the Code:

1. Creating the Merged Document: docs.documents.create() creates a new Google Doc titled "Merged Document." This document ID (newDocId) will serve as the destination where content from each document is appended.

2. Retrieving Content: The docs.documents.get() method fetches each document’s content based on its ID. This retrieves all elements from the document body, such as paragraphs, images, and other supported elements.

3. Preparing Insert Requests: The map() function converts each document element into an insertText request. Each request specifies the text and the location in the new document where it should be added.

4. Appending Text in Sequence: The batchUpdate method takes a set of requests and applies them sequentially to the new document. Here, the location index starts at 1 (the beginning of the document) and shifts with each new insertion to prevent overwriting.

Step 4: Run the Script

Now you’ll initialize the auth variable with OAuth 2.0 credentials, which authenticates access to the Docs API.

Then you’ll need to call the mergeGoogleDocs function, passing the auth object and an array of document IDs.

Once the script runs, it will output a URL for the merged document, which you can access directly in Google Docs.

Customization and Additional Options

• Order of Insertion: Control the order in which document content is appended by arranging the document IDs in docIds.

• Formatting: The Google Docs API can support additional formatting, such as bold or italic text, by modifying the insert requests. This can be achieved with advanced requests using the updateTextStyle API method.

• Element Types: The script currently handles only text paragraphs. To merge other elements like images or tables, extend the script to support more element types by using conditional checks on the element structure.

When to Use Google Docs API for Merging

The Google Docs API is ideal if you need precise control over document structure, element-specific formatting, and larger-scale automation for merging.

This approach is especially useful when handling complex formatting requirements, such as custom headers, lists, or tables, and allows for seamless integration with external applications or workflows outside Google Workspace.

If you have high-volume merge needs or you’re looking to incorporate merging into broader, automated processes, the Google Docs API provides advanced flexibility and customization options beyond what Google Apps Script can offer.

Conclusion

In conclusion, merging Google Docs is crucial for organizing and streamlining document management. While Google Docs lacks a built-in feature for this, you can leverage Google Apps Script for straightforward automation or the Google Docs API for more advanced, large-scale merging.

For those seeking a user-friendly solution without the need for coding, Merge Docs Pro provides an intuitive interface to combine multiple Google Docs into one document. It simplifies document consolidation, enhances collaboration, and saves time, making it an excellent choice if you’re looking to streamline your workflow within Google Workspace.

In this tutorial, I'll explain the Pandoc's functionalities, specifically focusing on two key areas that can significantly enhance the workflow for technical writers:

Docs and Markdown Conversions: If you write in Google Docs to leverage their collaborative writing, editing, and review features, Pandoc empowers you to convert Google Docs into markdown for publishing needs, and if you write in markdown, it helps you convert markdown to Google Docs or Microsoft Word for creating deliverables.

Merging of Multiple Docs into One: If you work in the "content as component approach", Pandoc allows you to merge multiple Google Docs into a single document with a few commands for publishing needs.

You can also create scripts to automate these processes.

Why Use Markdown for Technical Writing?

Markdown is great for technical writers because it simplifies the writing process and improves collaboration. Here's why:

Readability and Ease of Use: Markdown uses plain text symbols for formatting, making it clear and easy to learn. This lets you concentrate on writing clear content without getting caught up in styling complexities.

Platform Independence: Markdown files are plain text, allowing you to write in any text editor on any device. This flexibility provides freedom in your writing environment and eliminates software compatibility concerns.

Seamless Conversion with Free Tools: Free tools such as Pandoc offer format flexibility for markdown users, such as converting markdown to Google Docs, Word documents, or HTML, ensuring compatibility with collaborative editing needs and final deliverables. This also extends to modern workflows, where large language models generate content in markdown. You can use ChatGPT or the Gemini API for creating initial drafts, integrate them with your writing, and then use Pandoc to convert the final document to Google Docs or Microsoft Word for team editing, feedback, and creating deliverables. This streamlined workflow empowers efficient and collaborative content creation.

Version Control Friendly: Markdown's plain text nature enables seamless integration with version control systems like Git. This facilitates tracking changes, reverting to previous versions. This is particularly valuable for technical writing projects that often undergo revisions and involve multiple team members working on different sections.

Why Merge Multiple Documents into One?

Technical writing often involves creating complex documents from smaller, reusable pieces. We call these pieces "content components." These components can be individual chapters, user guides, reference articles, or any other modular unit that contributes to the final product. In other words, content components are building blocks for bigger projects.

However, writing tools such as Google Docs lack the ability to merge these components into a one document. This can be a major hurdle for projects like:

1. Technical Documentation: Building a user guide by assembling and reordering pre-written topics rather than crafting the entire document from scratch.
2. Reference Guides: Consolidating multiple articles from a knowledge base into a single, printable reference manual.
3. Book Authoring: Constructing a book by compiling individual chapters and appendices, streamlining the writing and editing process.

In all these scenarios, the need to merge content components becomes crucial for creating well-structured and efficient documentation.

How to Install Pandoc

You can install Pandoc on your system using the packages available in the releases list. The installation page has a detailed tutorial on the steps to install it on different systems.

Once Pandoc is installed, you can use it in the command line to perform different document conversion operations as explained below.

How to Convert Markdown to Word or Google Docs

To convert a markdown file to a Word document or Google Docs using Pandoc, follow these steps:

1. Open a terminal or command prompt and navigate to the directory where your markdown file is located.
2. Run the following Pandoc command to convert your markdown file to a Word document:

pandoc input.md -o output.docx

Replace input.md with the name of your input markdown file, and output.docx with the desired name of your Word document.

To convert the Docx format into Google Docs, you can upload it to Google Drive and open it in Google Docs.

With these steps, you can convert your markdown files to Word documents or Google Docs using Pandoc.

How to Convert Google Docs or Word to Markdown

In this section, I'll explain how to convert a Google Docs or Microsoft Word document into arkdown format.

While the Docs format is accepted by Pandoc, you cannot use the Google Docs URL directly with Pandoc. Therefore, you need to export the Google Doc into Docx format.

Go to File > Download > Microsoft Word (.docx) in your Google Doc to download the document in the .docx format as shown in the following image:

option to download document in .docx format

Now you'll have the Word document equivalent of the Google Docs.

To convert the Word document to markdown using Pandoc, run the following command in your terminal or command prompt:

pandoc input.docx -o output.md

Replace input.docx with the name of your Word document, and output.md with the desired name of your markdown file.

How to Merge Multiple Documents into One

To merge multiple Google Docs or Word documents into a single file using Pandoc, you can follow these two steps:

1. Convert individual documents to markdown using the Pandoc conversion command to convert each Google Doc or Word document into a separate markdown file (explained in the previous section).
2. Once you have individual markdown files, use the following Pandoc command to merge them into a single document.

pandoc file1.md file2.md -o merged_output.docx

Replace file1.md and file2.md with the names of your input markdown files. These files will be merged into one merged_output.docx.

You can use your desired output format instead of merged_output.docx based on your goals. For instance, you can create a single HTML file if you intend to publish it on the web, or use the markdown format if your publishing platform supports markdown.

This approach leverages Pandoc's strengths for format conversion and merging to achieve the desired outcome of a unified document.

For more information and helpful answers about using Pandoc, check out the Pandoc FAQs.

Conclusion

In conclusion, Pandoc is a powerful and versatile tool for technical writers, offering document conversion and merging capabilities.

With its ability to convert Google Docs into markdown and merge multiple documents into one, Pandoc streamlines the process of creating and publishing technical documentation.

Many publishers who work with writers need collaborative writing and editing features. This is where Google Docs comes into the picture. It’s a collaborative platform, enabling multiple users to write and edit simultaneously.

Google Docs also offers powerful formatting tools, simplifying the content creation process before transferring it to WordPress for publishing.

However, converting Google Docs to WordPress can add an extra step to your publishing workflow and requires some attention to detail.

This tutorial explores four seamless methods to bridge that gap and streamline your publishing journey:

• Manually converting using the copy-paste method
• Publishing with SEO optimization using the Docs to WP Pro add-on
• Using the WordPress Gutenberg editor
• Using the Markdown conversion method

Using the Simple Copy Paste Method

In this simple copy-paste approach, you can copy the contents from Google Docs and navigate to WordPress to create a new post, then paste in the content.

But when pasting content into WordPress, you may encounter some issues that require manual adjustments, especially if your WordPress site is using the Classic Editor.

First of all, you may have issues with spacing – for example, WordPress adds extra line breaks, as you can see in the image below:

Unnecessary link breaks added by Wordpress

Second, you may have to remove or clean up messy code – WordPress adds unnecessary span tags to the content.

Unnecessary span tags

Finally, you may have to manually upload images to the Media library and include them in your posts, as it's not done automatically.

The spacing issues and the messy code can affect your website performance. HTML counts toward your overall page weight, so unnecessary code slows your page down, impacting both user experience and SEO.

Images also need to be manually compressed before uploading to the WordPress Media library.

Also, the native Google Docs doesn’t offer options for SEO optimization or the use of reusable blocks to add boilerplate content. So using this method requires more manual work for publishing from Google Docs to WordPress.

Using Docs to WP Pro add-on

The Google Docs add-on Docs to WP Pro can help you publish SEO-optimized posts from Google Docs to WordPress.

The add-on allows you to configure the site once and includes additional capabilities, such as letting you create reusable blocks for content like FAQs, Author bios, and affiliate disclaimers. Beyond these, the add-on provides the following functionalities:

Automated Internal Linking

Adding internal links to your article is crucial for enhancing user experience and SEO. After creating content, identifying potential keywords and adding relevant internal links is essential.

But manually managing this process can be challenging, especially with a large number of articles and multiple authors. It becomes difficult to identify all potentially related articles without a comprehensive overview of your site, leading to more guesswork.

The Docs to WP Pro add-on can automate internal linking by automatically identifying and linking relevant keywords within your content to related posts on your site. This saves you time and effort and can help improve the SEO of your content by creating relevant internal links.

Related Posts Suggestions

Including a few related posts at the end of articles enhances reader engagement, increases dwell time, and improves overall user experience.

For this use case, the tool suggests topics that can be added as related posts. These suggestions include additional contextual data for the target posts, such as Relevance score, Number of incoming links, Post published on, and Post update on.

This information helps you link to the most recent articles when you have multiple articles on closely related topics and ensures a balanced distribution of internal links.

Suggestions for Related posts

SEO Optimization

Apart from internal linking, the tool also supports other SEO optimizations and seamlessly integrates with RankMath and Yoast.

The tool allows you to add a focus keyword and checks the content against it, suggesting optimizations such as the presence of the focus keyword in the title, subheadings, and image alt text.

The tool also evaluates whether the keyword is naturally integrated into the content or if it is overly used.

Additionally, the add-on provides useful information such as Flesch reading scores, content length, and reading time, helping you improve the readability of your content.

Image Handling

The add-on offers effortless image handling by automatically compressing images before publishing to the WordPress media library. This ensures a sleek media library and enhances your site's loading time.

It also enables you to add featured images directly from Google Docs to your WordPress posts. It can also automatically generate Alt Text for your images, contributing to improved accessibility and SEO.

The add on has a free version with paid features.

Using the WordPress Gutenberg Editor

Another option for publishing Google Docs to WordPress without additional add-ons is the WordPress Gutenberg editor. When you paste the Google Docs content into the Gutenberg editor, you won't encounter formatting issues such as extra line breaks or span tags.

This proves helpful when your content doesn't include images. But if your content contains images, the Gutenberg editor presents a few challenges.

After pasting the content into WordPress, checking the HTML code reveals that the image source is set to the location of the image in your Google Drive. This implies that you are hosting the images through your personal Google Drive, which is not recommended from a security standpoint.

Images hosted from your Google account

Also, deleting the image from your Google Drive or the Google Docs containing the image will result in the image disappearing from your website. This means you have to check your entire website and delete any links of images from your Google Drive.

An alternative approach is to upload the images manually to your WordPress media library and use those images in your posts. This adds some manual work and is error-prone. Also, the images must be manually compressed before uploading to the media library.

Markdown Conversion Method

You can convert Google Docs to Markdown format using the free and open source add on Docs to Markdown. The free tool will convert your fully formatted Google Doc to Markdown format (.md). You can paste this Markdown text into your WordPress editor for perfectly formatted text without any additional line breaks or span tags.

This option is also most useful only if your content doesn't include images. If your content does have images, it requires manual work to compress and upload your images into your WordPress media library and update the HTML accordingly.

Also, this method doesn't include built-in SEO features.

Conclusion

Transferring content from Google Docs to WordPress efficiently is essential for a smooth workflow.

This tutorial has presented four methods: manual copy-paste, using the Docs to WP Pro add-on, using WordPress Gutenberg editor and Markdown conversion method.

Each method has its own advantages and disadvantages, so the best choice for you will depend on your specific needs and preferences.

• Manual copy-paste is a simple option but requires manual adjustments for formatting and images.
• Docs to WP Pro offers features like automated internal linking, SEO optimizations and image handling, but may require additional investment.
• WordPress Gutenberg editor is a best option for the text only posts, but if you have images, then it requires additional work to host your images on WordPress media library.
• Converting to Markdown preserves formatting but requires manual image handling and lacks SEO optimization features.

Consider factors like the amount of content you create, your budget, and your technical expertise when making your decision.

In this article, we'll build a Google Docs clone using React, Material UI, and Firebase.

The final app will look like this:

If we click any document, it will open up and we can edit them however we need to.

And the most amazing feature is that we can edit a document in real time. This means that if two people are working on the same document, their progress will be reflected in both instances.

But before we start, make sure you have Node installed in your system. If not, go to https://nodejs.org/en/download/ to download and install it.

If you'd like to follow along in video format, here's this tutorial on my YouTube channel:

Basic Project Setup

Let's first create a React app using the below command:

npx create-react-app google-docs-clone

This will install all the packages and dependencies into a local folder.

Then, simply navigate into the project folder and run npm start to run the app.

We will see all these code here that we need to remove. We will start with a blank canvas.

Next create a folder called components. Inside that folder, let's create a file called docs.js.

Make this component a functional component, like this:

import React from 'react'

export default function Docs() {
  return (
    <div>
        <h1>docs</h1>
    </div>
  )
}

Now, import this file into the main App.js file.

import './App.css';
import Docs from './components/docs';

function App() {
  return (
    <Docs />
  );
}

export default App;

And we'll see this output on the screen:

Google docs clone showing output "docs" in upper left corner

Now, let's make the title appear in the center. So in docs.js, give the main div a className of docs-main.

import React from 'react'

export default function Docs() {
  return (
    <div className='docs-main'>
        <h1>Docs Clone</h1>
    </div>
  )
}

And in App.css file, add the following styles:

.docs-main{
    text-align: center;
}

Now our app looks like this:

Google docs clone with title in center

Now, we need a button to add our documents. So, let's create it with this code:

import React from 'react'

export default function Docs() {
  return (
    <div className='docs-main'>
        <h1>Docs Clone</h1>

        <button className='add-docs'>
            Add a Document
        </button>
    </div>
  )
}

And the CSS looks like this:

.add-docs{
    height: 40px;
    width: 200px;
    background-color: #ffc107;
    border: none;
    cursor: pointer;
}

Let's import some fonts from Google Fonts. Place this at the top of the CSS file:

@import url('https://fonts.googleapis.com/css2?family=Poppins&family=Roboto&display=swap');

@import url('https://fonts.googleapis.com/css2?family=Poppins&family=Roboto&display=swap');

.docs-main{
    text-align: center;
    font-family: 'Roboto', sans-serif;
}

.add-docs{
    height: 40px;
    width: 200px;
    background-color: #ffc107;
    border: none;
    cursor: pointer;
    font-family: 'Poppins', sans-serif;
}

To add fonts, simply do this in the respective classNames.

How to Install Material UI

To install Material UI, simply type the command below. If you want to read the documentation, head over to https://mui.com/.

npm install @mui/material @emotion/react @emotion/styled

Now, let's create one more component for the modal. We'll use this modal to add documents to the Firebase database.

import * as React from 'react';
import Box from '@mui/material/Box';
import Button from '@mui/material/Button';
import Typography from '@mui/material/Typography';
import Modal from '@mui/material/Modal';

const style = {
    position: 'absolute',
    top: '50%',
    left: '50%',
    transform: 'translate(-50%, -50%)',
    width: 400,
    bgcolor: 'background.paper',
    border: '2px solid #000',
    boxShadow: 24,
    p: 4,
};

export default function Modal() {
    const [open, setOpen] = React.useState(false);
    const handleOpen = () => setOpen(true);
    const handleClose = () => setOpen(false);

    return (
        <div>
            <Modal
                open={open}
                onClose={handleClose}
                aria-labelledby="modal-modal-title"
                aria-describedby="modal-modal-description"
            >
                <Box sx={style}>
                    <Typography id="modal-modal-title" variant="h6" component="h2">
                        Text in a modal
                    </Typography>
                    <Typography id="modal-modal-description" sx={{ mt: 2 }}>
                        Duis mollis, est non commodo luctus, nisi erat porttitor ligula.
                    </Typography>
                </Box>
            </Modal>
        </div>
    );
}

This is a simple modal component from Material UI. Now we have to import this component into our Docs.js component.

And we need to move a few things from Modal.js to Docs.js.

const [open, setOpen] = React.useState(false);
const handleOpen = () => setOpen(true);

If we click the Add a Document button, the modal will open using these functions:

import React, { useState } from 'react';
import Modal from './Modal';

export default function Docs() {
    const [open, setOpen] = React.useState(false);
    const handleOpen = () => setOpen(true);
    return (
        <div className='docs-main'>
            <h1>Docs Clone</h1>

            <button
                className='add-docs'
                onClick={handleOpen}
            >
                Add a Document
            </button>

            <Modal
                open={open}
                setOpen={setOpen}
            />
        </div>
    )
}

So, pass these functions and states as props into the modal component and receive them.

import * as React from 'react';
import Box from '@mui/material/Box';
import Button from '@mui/material/Button';
import Typography from '@mui/material/Typography';
import Modal from '@mui/material/Modal';

const style = {
    position: 'absolute',
    top: '50%',
    left: '50%',
    transform: 'translate(-50%, -50%)',
    width: 400,
    bgcolor: 'background.paper',
    border: '2px solid #000',
    boxShadow: 24,
    p: 4,
};

export default function ModalComponent({
    open,
    setOpen,
}) {
    const handleClose = () => setOpen(false);

    return (
        <div>
            <Modal
                open={open}
                onClose={handleClose}
                aria-labelledby="modal-modal-title"
                aria-describedby="modal-modal-description"
            >
                <Box sx={style}>
                    <Typography id="modal-modal-title" variant="h6" component="h2">
                        Text in a modal
                    </Typography>
                    <Typography id="modal-modal-description" sx={{ mt: 2 }}>
                        Duis mollis, est non commodo luctus, nisi erat porttitor ligula.
                    </Typography>
                </Box>
            </Modal>
        </div>
    );
}

Now, this is how our page looks with the modal:

Google docs clone page with model showing

Let's add an input in the Modal, for the filename.

<Modal
                open={open}
                onClose={handleClose}
                aria-labelledby="modal-modal-title"
                aria-describedby="modal-modal-description"
            >
                <Box sx={style}>
                    <input
                        placeholder='Add the Title'
                        className='add-input'
                    />
                </Box>
            </Modal>

Let's give it some styles with the following:

.add-input{
    width: 95%;
    height: 40px;
    outline: none;
    border: 1px solid #676767;
    border-radius: 0px;
    padding: 10px;
    font-family: 'Poppins', sans-serif;
}

And now, this is how our Modal looks:

Modal with styling added

Let's also add a Button. We can copy the Add a Document Button.

import * as React from 'react';
import Box from '@mui/material/Box';
import Button from '@mui/material/Button';
import Typography from '@mui/material/Typography';
import Modal from '@mui/material/Modal';

const style = {
    position: 'absolute',
    top: '50%',
    left: '50%',
    transform: 'translate(-50%, -50%)',
    width: 500,
    height: 150,
    bgcolor: 'background.paper',
    boxShadow: 24,
    p: 5,
};

export default function ModalComponent({
    open,
    setOpen,
}) {
    const handleClose = () => setOpen(false);

    return (
        <div>
            <Modal
                open={open}
                onClose={handleClose}
                aria-labelledby="modal-modal-title"
                aria-describedby="modal-modal-description"
            >
                <Box sx={style}>
                    <input
                        placeholder='Add the Title'
                        className='add-input'
                    />
                    <div className='button-container'>
                        <button
                            className='add-docs'
                        >
                            Add
                        </button>
                    </div>
                </Box>
            </Modal>
        </div>
    );
}

And the CSS looks like this:

.button-container{
    text-align: center;
    margin: 30px;
}

This is how it looks now:

Modal with styling and button added

How to Add Firebase to Our App

Now, let's install Firebase for the database. Simply install Firebase using the below command:

npm install firebase

Head over to https://firebase.google.com/ and click Go to console at the top right.

Then, click Add Project.

After creating the Project, click the code button to create a web app in Firebase. Give it a name and we are ready to go.

Now, we will add all these config data that we have to store in our React app. So, create a file called firebaseConfig.js and add them.

We are going to need the database, so let's initalize it. Also, export the const app and database like this:

import { initializeApp } from "firebase/app";
import { getFirestore } from 'firebase/firestore';

const firebaseConfig = {
  //Your Firebase Data
};

export const app = initializeApp(firebaseConfig);
export const database = getFirestore(app)

Import the app and database into App.js file. And pass the database as props to the Docs component. We'll use it later to add data to Firebase Firestore.

import './App.css';
import Docs from './components/docs';
import { app, database } from './firebaseConfig';

function App() {
  return (
    <Docs database={database}/>
  );
}

export default App;

And in the Docs component. Also, let's receive the database export from props.

import React, { useState } from 'react';
import Modal from './Modal';

export default function Docs({
    database
}) {
    const [open, setOpen] = React.useState(false);
    const handleOpen = () => setOpen(true);
    return (
        <div className='docs-main'>
            <h1>Docs Clone</h1>

            <button
                className='add-docs'
                onClick={handleOpen}
            >
                Add a Document
            </button>

            <Modal
                open={open}
                setOpen={setOpen}
            />
        </div>
    )
}

Now, let's configure our Firestore Database.

Go to Firestore database from the left sidebar, and click Create Database.

We will start our Database in Production Mode. So, click Next, and then Enable.

We have to make the security rules public, just for now. So, click Rules at the top tab and edit the following rules. This means that anyone can write data or read them, even without authentication.

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write;
    }
  }
}

How to Add Docs Data to the Firestore Database

Now, let's actually add our data. But before that, we need to get the data from the input field.

So in the Docs component, create one state that will hold this data.

const [title, setTitle] = useState('')

Pass the title and setTitle to the modal component.

<Modal
                open={open}
                setOpen={setOpen}
                title={title}
                setTitle={setTitle}
            />

Receive them both as props, and set them in the input field.

import * as React from 'react';
import Box from '@mui/material/Box';
import Button from '@mui/material/Button';
import Typography from '@mui/material/Typography';
import Modal from '@mui/material/Modal';

const style = {
    position: 'absolute',
    top: '50%',
    left: '50%',
    transform: 'translate(-50%, -50%)',
    width: 500,
    height: 150,
    bgcolor: 'background.paper',
    boxShadow: 24,
    p: 5,
};

export default function ModalComponent({
    open,
    setOpen,
    title, 
    setTitle
}) {
    const handleClose = () => setOpen(false);

    return (
        <div>
            <Modal
                open={open}
                onClose={handleClose}
                aria-labelledby="modal-modal-title"
                aria-describedby="modal-modal-description"
            >
                <Box sx={style}>
                    <input
                        placeholder='Add the Title'
                        className='add-input'
                        onChange={(event) => setTitle(event.target.value)}
                        value={title}
                    />
                    <div className='button-container'>
                        <button
                            className='add-docs'
                        >
                            Add
                        </button>
                    </div>
                </Box>
            </Modal>
        </div>
    );
}

Now, if we type something in the input, it will be stored inside the title state.

Next, we need a function that will trigger the add data functions, so let's create it.

In Docs.js, create a function and pass it to the modal component:

const addData = () => {

}

Receive it in the modal component and simply bind it to the Add button like this:

<div className='button-container'>
                        <button
                            className='add-docs'
                            onClick={addData}
                        >
                            Add
                        </button>
                    </div>

Now, the addData function will run when we click the Add button.

Now to send data from React to Firebase dynamically, let's import a few things from Firebase Firestore:

import { addDoc, collection } from 'firebase/firestore';

Here, we'll use collection to create a data collection in Firebase, and addDoc will add data to that collection.

Let's first create a collection reference. It will take the database that we got from the firebaseConfig.js and the name of the collection we want to use.

const collectionRef = collection(database, 'docsData')

Now, in the addData function, let's use addDoc. This addDoc function will take the collection reference, and the data itself.

const addData = () => {
        addDoc(collectionRef, {
            title: title
        })
        .then(() => {
            alert('Data Added')
        })
        .catch(() => {
            alert('Cannot add data')
        })
    }

Now, add something in the text input and click Add. It will be added into Firebase Firestore, with an alert that data has been added. But if it fails, we will get "Cannot add data."

If we refresh the database, we'll see this new entry:

And that's how we add data. Let's also close the modal after adding the data.

Create a function handleClose, and call this function right after the then block in the addData function.

const addData = () => {
        addDoc(collectionRef, {
            title: title
        })
        .then(() => {
            alert('Data Added');
            handleClose()
        })
        .catch(() => {
            alert('Cannot add data')
        })
    }

How to Read the Data from Firebase

Now, let's read the data that we added to Firebase. We will need the onSnapshot function for that. The onSnapshot function gets data in real time.

First, import it from Firebase like this:

import { addDoc, collection, onSnapshot } from 'firebase/firestore';

Then, create a function getData that will get triggered when our page loads. So, we will put this onSnapshot into the React useEffect Hook.

const getData = () => {
        onSnapshot(collectionRef, (data) => {
            console.log(data.docs.map((doc) => {
                return {...doc.data(), id: doc.id}
            }))
        })
    }

Then, call this function inside the useEffect Hook.

useEffect(() => {
        getData()
    }, [])

But as you can see, the we are getting the data twice. That's because we are using React version 18, which includes concurrent rendering. That's why the useEffect hook will run twice.

To solve this, we need to create a useRef reference.

const isMounted = useRef()

Then in the useEffect Hook, we have to check if isMounted.current is true. So, if it is true, we will return nothing. And then we will set isMounted.current to true, and we will then call our getData function.

useEffect(() => {
        if(isMounted.current){
            return 
        }

        isMounted.current = true;
        getData()
    }, [])

And if we now refresh the page, we will get the data only once.

Now, we have to include this data in an array state. So, let's do that.

Create a state of docsData.

 const [docsData, setDocsData] = useState([]);

And set the incoming data inside this state using setDocsData.

const getData = () => {
        onSnapshot(collectionRef, (data) => {
            setDocsData(data.docs.map((doc) => {
                return {...doc.data(), id: doc.id}
            }))
        })
    }

Now, let's map our array for the data to show up in the UI.

<div>
                {docsData.map((doc) => {
                    return (
                        <div>
                            <p>{doc.title}</p>
                        </div>
                    )
                })}
            </div>

This will display all the data in our React app.

We will see both documents on our page. But let's make them appear in a grid. Give the div containers classNames of grid-main and grid-child.

<div className='grid-main'>
                {docsData.map((doc) => {
                    return (
                        <div className='grid-child'>
                            <p>{doc.title}</p>
                        </div>
                    )
                })}
            </div>

And in the CSS, add the following classes:

.grid-main{
    display: grid;
    grid-template-columns: auto auto auto auto;
    color: whitesmoke;
    margin-top: 20px;
    gap: 20px;
    justify-content: center;
}

.grid-child{
    padding: 20px;
    background-color: rgb(98, 98, 98);
    width: 300px;
    cursor: pointer;
}

Now, our app will look like this:

How to Get the ID and Redirect to the Edit Docs Page

Now, each of these items above has an ID. We will use these IDs to redirect to another page where we can edit the items and write our main content.

For that, we need two packages. One is the React-Router to redirect us, and another is the React-Quill for our editor. Install them like this:

npm i react-quill react-router-dom@6

Now, let's configure routing to another page. But we need another page first. So, let's create it.

Create a component called EditDocs. Make it a functional component.

import React from 'react'

export default function EditDocs() {
  return (
    <div>EditDocs</div>
  )
}

To configure routing, come to index.js, the app's entry point. Wrap the inside BrowserRouter.

import React from 'react';
import ReactDOM from 'react-dom/client';
import './index.css';
import App from './App';
import reportWebVitals from './reportWebVitals';
import { BrowserRouter } from "react-router-dom";

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <React.StrictMode>
    <BrowserRouter>
      <App />
    </BrowserRouter>
  </React.StrictMode>
);

// If you want to start measuring performance in your app, pass a function
// to log results (for example: reportWebVitals(console.log))
// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
reportWebVitals();

Now, we can use routing anywhere because we are declaring BrowserRouter at the basic level.

Now, come to the App.js file. Import Routes and Route from React-Router. We are also appending the ID in the editDocs path, so that we can see the id in the address bar.

import { Routes, Route } from "react-router-dom";

import './App.css';
import Docs from './components/docs';
import EditDocs from './components/EditDocs';
import { Routes, Route } from "react-router-dom";
import { app, database } from './firebaseConfig';

function App() {
  return (
    <Routes>
      <Route path="/" element={<Docs database={database} />} />
      <Route path="/editDocs/:id" element={<EditDocs database={database}/>} />
    </Routes>
  );
}

export default App;

And add the following routes. If we go to '/editDocs/:id', we will see our editDocs page.

Now, we need to get the specific ID from the documents and send it to the editDocs page.

Create a function getID and assign the function to the documents.

const getID = () => {

}

<div className='grid-main'>
                {docsData.map((doc) => {
                    return (
                        <div className='grid-child' onClick={() => getID(doc.id)}>
                            <p>{doc.title}</p>
                        </div>
                    )
                })}
            </div>

Now, if we click the document, we will get its ID if we log it in the console.

const getID = (id) => {
        console.log(id)
    }

Now, let's send this ID to the editDocs page using useNavigate.

First, import useNavigate from react-router.

import { useNavigate } from 'react-router-dom';

Then, create an instance of useNavigate like this:

let navigate = useNavigate();

Then, to pass the ID, simply do this. We will send ourselves to the editDocs page, along with the ID.

const getID = (id) => {
        navigate(`/editDocs/${id}`)
}

Now, let's receive our ID at the other end. In the editDocs component, we need to useParams from react-router.

So, import it and create an instance:

import { useParams } from 'react-router-dom';

let params = useParams();

Also if we console it, we will see the ID.

import { useParams } from 'react-router-dom';

let params = useParams();
console.log(params)

We can see that we get the ID in the address bar as well as the console.

Now, let's add React Quill to our editDocs page.

import React from 'react';
import { useParams } from 'react-router-dom';
import ReactQuill from 'react-quill';
import 'react-quill/dist/quill.snow.css';
export default function EditDocs() {
    let params = useParams();
    return (
        <div>
            <h1>EditDocs</h1>

            <ReactQuill />
        </div>
    )
}

We have to import React-Quill and the CSS.

But we can see we have two toolbars here. To solve this, just remove React.StrictMode from index.js.

import React from 'react';
import ReactDOM from 'react-dom/client';
import './index.css';
import App from './App';
import reportWebVitals from './reportWebVitals';
import { BrowserRouter } from "react-router-dom";

const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(
  <BrowserRouter>
    <App />
  </BrowserRouter>
);

// If you want to start measuring performance in your app, pass a function
// to log results (for example: reportWebVitals(console.log))
// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
reportWebVitals();

And we will be fine.

Now, we need a state for this React Quill data. So, let's create it. Also, we'll create a function to trigger when we type.

const [docsDesc, setDocsDesc] = useState('');
    const getQuillData = () => {

    }

Now, let's bind the function and the state to React Quill.

<ReactQuill
   value={docsDesc}
   onChange={getQuillData}
/>

In the getQuillData function, let's bind the value to the docsDesc state, using the setDocsDesc function.

const getQuillData = (value) => {
        setDocsDesc(value)
    }

And we are done here. You can console this docsDesc state to check.

Now we have the ID, and the data that we can use to update the document. So, let's do that.

How to Update the Document

We need two things, updateDoc and the collection function. We will use a Debounce function to call the updateDoc function. This means that when we finish typing, after 5 or 10 seconds, our updateDoc function will run.

So, let's create a function:

const updateDocsData = () => {

}

We also need to specify the collection. For that, we need the database from App.js. So, let's get it using props.

<Route path="/editDocs/:id" element={<EditDocs database={database}/>} />

Now, let's create a collection reference.

const collectionRef = collection(database, 'docsData')

Now for debouncing, we need the updateDocsData in a useEffect hook.

useEffect(() => {
        const updateDocsData = () => {

        }
 }, [])

Now, let's add a setTimeout function with an interval. This means that function will run after that specified interval. Make the interval 1000 milliseconds, or 1 second.

useEffect(() => {
    const updateDocsData = setTimeout(() => {

    }, 1000)  
    return () => clearTimeout(updateDocsData)
  }, [])

Now, inside setTimeOut, let's add the updateDoc function. So inside the document variable, we are passing collectionRef and the ID from the params. And then, the updateDoc takes that variable document as first parameter.

const updateDocsData = setTimeout(() => {
            const document = doc(collectionRef, params.id)
            updateDoc(document, {

            })
        }, 1000)

Let's also import the doc function. It specifies which document to update using the ID as primary key.

import {
    updateDoc,
    collection,
    doc
} from 'firebase/firestore';

Now let's pass the data in the second parameter, in the updateDoc function.

useEffect(() => {
        const updateDocsData = setTimeout(() => {
            const document = doc(collectionRef, params.id)
            updateDoc(document, {
                docsDesc: docsDesc
            })
        }, 1000)
        return () => clearTimeout(updateDocsData)
    }, [])

In the dependency array, add the state of docsDesc. So after we type something, the updateDoc function will run after 1 seconds.

useEffect(() => {
        const updateDocsData = setTimeout(() => {
            const document = doc(collectionRef, params.id)
            updateDoc(document, {
                docsDesc: docsDesc
            })
            .then(() => {
                alert('Saved')
            })
            .catch(() => {
                alert('Cannot Save')
            })
        }, 1000)
        return () => clearTimeout(updateDocsData)
    }, [docsDesc])

So, type something in the editor, and it will be saved inside the database.

And the data here:

If we add something further, we will append the previous data:

How to Get the Data Back from the Database to the Editor

Now, if we go back and click any document, the data will be null, or erased. So, we have to get data from the database and set it to the editor.

We will use the onSnapshot function to do that.

import {
    updateDoc,
    collection,
    doc,
    onSnapshot
} from 'firebase/firestore';

const getData = () => {

    }

    useEffect(() => {
        if(isMounted.current){
            return 
        }

        isMounted.current = true;
        getData()
    }, [])

So, it's just like we did in the Docs component. We need to specify which data to get using the ID parameter. And then we pass this document to the onSnapshot function to get the data we need.

const getData = () => {
        const document = doc(collectionRef, params.id)
        onSnapshot(document, (docs) => {
            console.log(docs.data().docsDesc)
        })
    }

Let's set this docs.data().docsDesc in docsDesc state using setDocsDesc. So, if the document loads, it will be set there.

Add some data, then go back. And if you come back to the same component, the document description will be there.

Now in the home page where we are seeing all the data, we need to add the description too, if it exists.

 <div dangerouslySetInnerHTML={{__html: doc.docsDesc}} />

We are using dangerouslySetInnerHTML because data is added in the form of tags in React Quill. That makes it easier to render the formatting.

See, I have added some formatting like Bold and Italic texts.

Now, we need to make some slight modifications. In the App.js file (where we are adding the document title) let's also add the description, which will initially be empty.

const addData = () => {
        addDoc(collectionRef, {
            title: title,
            docsDesc: ''
        })
        .then(() => {
            alert('Data Added');
            handleClose()
        })
        .catch(() => {
            alert('Cannot add data')
        })
    }

So if we create a document, we will have the docsDesc in the Firestore Document. That will prevent our app from crashing when we go the EditDocs page.

Now, in the EditDocs page, let's add the document title so that it shows up on the top. Create a state called documentTitle and set it.

const [documentTitle, setDocumentTitle] = useState('')

const getData = () => {
        const document = doc(collectionRef, params.id)
        onSnapshot(document, (docs) => {
            setDocumentTitle(docs.data().title)
            setDocsDesc(docs.data().docsDesc);
        })
    }

And display this state on the top:

<h1>{documentTitle}</h1>

Here is the whole code for the EditDocs page till now:

import React, { useEffect, useState, useRef } from 'react';
import { useParams } from 'react-router-dom';
import ReactQuill from 'react-quill';
import 'react-quill/dist/quill.snow.css';
import {
    updateDoc,
    collection,
    doc,
    onSnapshot
} from 'firebase/firestore';
export default function EditDocs({
    database
}) {
    const isMounted = useRef()
    const collectionRef = collection(database, 'docsData')
    let params = useParams();
    const [documentTitle, setDocumentTitle] = useState('')
    const [docsDesc, setDocsDesc] = useState('');
    const getQuillData = (value) => {
        setDocsDesc(value)
    }
    useEffect(() => {
        const updateDocsData = setTimeout(() => {
            const document = doc(collectionRef, params.id)
            updateDoc(document, {
                docsDesc: docsDesc
            })
                .then(() => {
                    alert('Saved')
                })
                .catch(() => {
                    alert('Cannot Save')
                })
        }, 1000)
        return () => clearTimeout(updateDocsData)
    }, [docsDesc])

    const getData = () => {
        const document = doc(collectionRef, params.id)
        onSnapshot(document, (docs) => {
            setDocumentTitle(docs.data().title)
            setDocsDesc(docs.data().docsDesc);
        })
    }

    useEffect(() => {
        if (isMounted.current) {
            return
        }

        isMounted.current = true;
        getData()
    }, [])
    return (
        <div>
            <h1>{documentTitle}</h1>

            <ReactQuill
                value={docsDesc}
                onChange={getQuillData}
            />
        </div>
    )
}

How to Add Some Styling

Now let's add some styling in this EditDocs page:

<div className='editDocs-main'>
            <h1>{documentTitle}</h1>
            <div className='editDocs-inner'>
                <ReactQuill
                    className='react-quill'
                    value={docsDesc}
                    onChange={getQuillData}
                />
            </div>
        </div>

And in the CSS, add the following styling:

.editDocs-main {
    font-family: 'Poppins', sans-serif;
    padding: 20px;
    display: flex;
    justify-content: center;
    align-items: center;
    flex-direction: column;
}

.editDocs-inner {
    width: 800px;
    box-shadow: 0px -2px 5px 2px rgba(181, 181, 181, 0.75);
    -webkit-box-shadow: 0px -2px 5px 2px rgba(181, 181, 181, 0.75);
    -moz-box-shadow: 0px -2px 5px 2px rgba(181, 181, 181, 0.75);
    padding: 20px;
    height: 750px;
}

.ql-container.ql-snow {
    border: none !important;
}

We are adding a box shadow, we are removing the React Quill border, and we are centering everything.

This is how our edit document page looks now:

Now for our final thing: let's replace our alerts with toast messages. We need one more package called React Toastify. So, let's install it.

npm i react-toastify

Then we need to import these two things:

import { ToastContainer, toast } from 'react-toastify';
import 'react-toastify/dist/ReactToastify.css';

And then, the component.

Now, for the toast message, simply do this:

useEffect(() => {
        const updateDocsData = setTimeout(() => {
            const document = doc(collectionRef, params.id)
            updateDoc(document, {
                docsDesc: docsDesc
            })
                .then(() => {
                    toast.success('Document Saved', {
                        autoClose: 2000
                    })
                })
                .catch(() => {
                    toast.error('Cannot Save Document', {
                        autoClose: 2000
                    })
                })
        }, 1000)
        return () => clearTimeout(updateDocsData)
    }, [docsDesc])

We have toast.success for success alerts, and toast.error for error alerts.

Conclusion

And there you have it, you've built a Google Docs clone. You are free to experiment and make this better.

You can get the full code here: https://github.com/nishant-666/Google-Docs-Clone

Also, check out my channel Cybernatico for more amazing tutorials like these.

Happy Learning.

Gmail and Yahoo limit file size to 25MB, while outlook and iCloud limit files to 20MB.

So, if you decide to send, for example, a video file larger than 25MB, you might get an error that the message was rejected by the server because it’s too large.

Some email clients won’t show an error, but instead, suggest how you should send the large video file.

For example, Gmail will suggest that you upload the video to Google Drive:

And Outlook will suggest that you upload the video to Microsoft OneDrive:

How then do you send a large video file through email? That’s what I’m going to show you in this article.

How to Send Large Video Files through Email Using Google Drive

Google Drive is a cloud-based storage service provided by Google for sharing files.

As already shown in this article, Gmail prompts you to upload a video file larger than 25MB to Google Drive and then convert the video to an accessible link.

If you are using another email client like Outlook, or Yahoo, you can still send the large video using Google Drive.

Upload the video to your Google Drive and click the “Get link” button:

Change the access from restricted to “Anyone with the link”:

Click “Copy link”, and then “Done”:

Click “Compose” and paste the link to your email editor. Provide every other necessary detail and click the “Send” button:

How to Send Large Video Files through Email Using Dropbox

Dropbox is another cloud-based storage service that lets you back up and sync files on multiple devices. You can upload up to 50GB file size to your Dropbox account if you have one.

To send large video files through email by using Dropbox, upload the video to your Dropbox account and copy the link:

Compose your email and paste the link in to send the large video file:

How to Send Large Video Files through Email Using Video Sharing Services

You can send large video files through email by using video-sharing services like YouTube and Vimeo.

And yes, you can upload videos to YouTube without having a YouTube channel. As long as you have a Gmail account, you have access to Google services, including YouTube. So if you have a Google account, technically you can have a YouTube channel.

To upload videos to YouTube, click the Create button on the top-right corner and select “Upload video”:

Click on “SELECT FILES” to choose the file on your device:

Give the video a name and description, copy the link, and click “Next”:

Follow other prompts and choose whether you want to make the video public or private, then click “Save”:

Head over to your email client composer and paste in the link so you can send the large video file:

Final Thoughts

You can’t send a large video file directly through email clients, but you can take advantage of the methods discussed in this article to send large video files.

Another way you can send a large video file through email is to compress the video through your native compressor or third-party file compressors. As long as the file is less than 20-25MB, you can send it through email.

But if you compress the video and it is still not less than 20-25MB, then you should use any of the methods pointed out in this article.

Here is what it looks like: you are an awesome person.

These are various use cases for strikethroughs:

• To indicate that a piece or block of text that should be deleted.
• To indicate that a piece or block of text is outdated.
• To show task completion. This is usually seen in To-Do lists.
• To convey an unrelated or humorous message when writing, and so on.

In this article, we'll see how to strikethrough or cross out text when writing using Google Docs.

How to Strikethrough Text in Google Docs

There are two methods we can use when crossing out text in Google Docs – using a shortcut command or choosing the strikethrough option from the Format tab in the Google Docs header section.

How to Strikethrough Text in Google Docs Using a Shortcut Command

Here are the steps to follow when using a shortcut command to strikethrough text in Google Docs:

• Open Google Docs and create a blank document.
• Write some text in your document.
• Highlight the text you've written.

• On windows, press Alt + Shift + 5.
• On Mac, press ⌘ + Shift + X.

There you go, we have used a shortcut command to cross out text in Google Docs.

How to Strikethrough Text in Google Docs Using the Format Tab

In this section, we'll see how we can strikethrough text in Google Docs using the Format option. Here are the steps:

• Open Google Docs and create a blank document.
• Write some text in your document.
• Highlight the text you've written.
• Click on the Format tab in the header.
• Click on Text.
• Click on the Strikethrough option.

After you have done this, your text should be crossed out.

Conclusion

In this article, we talked about strikethroughs in writing, their use cases and how to strikethrough/cross out text in Google Docs.

Thank you for reading! But really, thank's for reading! :)

What is a Hanging Indent?

A hanging indent is a type of indentation where the first line of a paragraph is not indented, but subsequent lines in the same paragraph are indented.

Here is an example of what a Hanging Indent looks like:

In Google Docs, you can create a hanging indent by following these simple steps:

Step 1: Select the text you want to format. You can do this by triple-clicking the paragraph.

Step 2: Click the "Format" menu. Then choose "Align and Indent". Then choose "Indentation options."

Step 3: From this menu, you can choose "Hanging." If you want, you can specify by how much you want to indent. For this tutorial, I've left that value at the default value of 0.5.

And presto! You have a sophisticated-looking paragraph that uses hanging indentation.

I hope you've found this helpful. If you want to learn more about programming and technology, try freeCodeCamp's core coding curriculum. It's free.

Thanks and have a fantastic day.

It has many features available to help you visually enhance your writing and make specific parts stand out more.

One of the ways you can add more functionality to your documents is by adding a textbox.

A textbox helps make any topics you want to highlight and bring attention to more prominent.

Your readers and target audience will better understand the information you're trying to convey and the message you want to get across.

It's also a helpful method for note-taking. Text boxes help point out topics you want to pay extra attention to and not miss.

In this quick and easy guide, you'll learn how to insert a textbox into your Google Document with just a couple of simple steps.

Let's get started!

How to add a Textbox in Google Docs

First of all, make sure you're logged into your Google Account.

Then, navigate to Google Docs and create a new document by double-clicking on 'Blank'.

If you want to add a textbox to an existing document, choose the document you want from the options in 'Recent Documents' by double-clicking on it.

Once you've opened (or created) a Google Doc, click on 'Insert'. A drop-down menu will appear, and from there you navigate to 'Drawing'.

From there, click on 'Drawing' and select 'New'.

Once you click 'New', a new window will open up. This is the Drawing Tool and the place where you'll be able to insert a textbox.

In the toolbar, select the 'Text box' icon. It's the square with the letter 'T' inside it.

Once you've tapped that icon, you'll notice that your cursor has changed. It now looks like a little plus sign or a 'crosshair cursor' as it's known.

This now indicates that you can start drawing your textbox and give it a shape.

Drag and move the crosshair cursor to make a textbox. Then adjust the size you want it to have by clicking and dragging its corners.

To add some text, double click inside the textbox that you just created. You'll see a blinking cursor come up, indicating that you can start writing.

How to Customize a Textbox in Google Docs

To make further edits to the text you've added, such as aligning it in the center, changing the color, font-style, or font-family, adding lists, and so on, click on the three dots on the right hand side.

You can add a background-color if you want to make the textbox stand out more.

You do this by selecting the 'fill color' icon which is the paint bucket icon. A color picker will appear for you to select your desired background-color.

If you want, you can also add a color to the box's border. Select the 'Border color' icon and pick a color of your choice.

You can also change the thickness of the border. Select the 'Border weight' icon which is on the right of the 'Border color'.

You can even change the border style with the 'Border dash' icon, giving the border a dotted style.

To save your work, click 'Save and Close'.

And there you have it, the textbox now appears in your Google Document.

If you want to make further changes to the textbox, click on it and the contextual menu will appear.

From here, you'll be able to click 'Edit' and be taken back to the Drawing Tool, or you can adjust the text and margin in line, wrap or break the text inside the textbox, and more.

How to Insert Custom Shapes in Google Docs

Besides just adding a textbox, there are a variety of different available shapes to choose from and add to your documents.

You can combine these shapes (such as arrows, mathematical equation signs, and so on) with textboxes to make your document more interactive and stand out even more.

To create a custom shape, in the Drawing Tool (Insert -> Drawing -> New), navigate to the 'Shape' icon which is on the left of the 'Text box' icon.

After clicking on it, you'll see a dropdown menu with all the available categories – 'Shapes', 'Arrows', 'Callouts', 'Equation'.

To create a shape, choose one you like and then click on the drawing area so that it appears.

From there you can adjust the size of the shape and move it around by draggind and dropping its edges (via the little squares at the edges of the spape).

Similarly to the textbox, you can add a background-color and a border color to it and adjust any text you add in the shape. You do this by clicking on the three dots on the far right corner of the toolbox where there are more options for further customization.

When you've finished your work, click 'Save and Close'.

Your shape will then be added to your Google Document.

Thanks for reading! Have fun customizing your Google Docs.

This article will cover how to save a Google Doc as a PDF on the Desktop version of Google Docs.

What Is Google Docs Used For?

You can use Google Docs for many different tasks.

For example, you can jot down key concepts in a Doc while you're watching a coding tutorial or reading through an article.

Or you can use it to create an e-book or other learning material for your students.

Google Docs is also a staple in the workplace for sharing documents with your teammates.

You can also use it to craft your perfect résumé or cover letter.

And the list goes on.

When you're ready to save your Google Doc, you have the choice of saving it in various formats. Let's look at some of them now.

Why Save a Google Doc as a PDF?

A PDF, one of the most popular document types, is short for Portable Document Format and was created by Adobe in 1991.

Before then, files shared digitally were somewhat problematic as the formatting of documents could get seriously altered depending on what system you were using and so on.

Adobe created PDFs so that people could send electronic files in a straightforward way, without their formatting getting compromised.

Thanks to PDFs, your files look as you intended. The styles the receiver sees are the original ones you saved when creating the document.

Without a doubt, the styles in the document are going to be preserved.

How to Save a Google Doc as a PDF File

The method we'll discuss now is for downloading any Google Doc file in PDF format on your local computer system.

First, log into your Google Account.

Next, open your Google Drive Account.

You can view all your saved documents on the Google Drive home screen.

Go ahead and open the document of your choice by double-clicking on the document. You can also open it by holding down the control key and touchpad at the same time for MacOs or right-clicking for WindowsOS. Then select Open With > Google Docs.

If you don't have a document you want to save as a PDF already, you can create a new file altogether by selecting the New button and then Google Docs. Then either create a blank document or choose a template instead.

Once the file is opened, edited, and ready to save, choose File > Download > PDF Document(.pdf).

The PDF document will be downloaded on your computer and saved in your Downloads folder by default.

You will now have access to the Google Doc you created in Google Drive in a PDF format locally on your computer system.

How to Save a PDF Back to Google Drive

What if you want to save this PDF in Google Drive?

All you need to do is go to your Downloads folder (or wherever you saved your file), select the file, and drag it into Google Drive.

Now you have both the Google Doc and PDF version saved in your Google Drive.

And there you have it.

In this quick guide, you learned how to save Google Doc documents as PDFs on both your computer system and Google Drive.

Thanks for reading!

In this tutorial, I'll show you how to use speech-to-text in Google Docs. Do note, though, that this feature is available only if you're using Google's Chrome browser.

How to Activate the Speech-to-Text Tool

You can activate speech-to-text from the Tools menu – it is the fourth menu item from the bottom. Or you can use the Ctrl+Shift+S (on Windows) or Command+Shift+S (on Mac) shortcut to activate it.

The Tool menu. The Voice typing menu item is the tenth item from the top, or the fourth from the bottom.

This will open a little tab with a microphone and a dropdown menu.

The voice typing tab.

You can drag it around with the three horizontal dots at the top. Next to those dots you can click the X to close it. Just below you'll see the dropdown menu where you can change languages (and it shows what language is currently set). Then below that there's the big square button with a grey microphone in the middle.

If you want to change the language setting for the Voice Typing tool, you need to use the drop down menu. It will let you choose between many languages. Just select the language you prefer, and you are ready to start using it.

The drop down menu expanded. It has a lot of languages you can choose from.

How to Use Voice Typing in Google Docs

You can start voice typing by clicking on the microphone button. When it's activated, it will become red.

If you get an alert from Google Docs asking for permission to use your microphone, go ahead and grant permission or you will not be able to use voice typing.

The microphone icon when activated: all the other options disappear, and the microphone icon turns red and is now surrounded by a red circle.

Now, start speaking, and Google Docs will transcribe what you say. You need to speak clearly and not too quickly for better results.

While Google is interpreting what you have said there will be a pattern of little squares shown where the words will appear after it has finished elaborating.

While Google is elaborating, a pattern of squares similar to this will be shown. When elaboration is finished, it will be replaced with the words.

Voice Commands

Writing a document often includes editing and formatting. Voice commands allow you to do all the editing and formatting using only your voice.

Voice commands are available only for the English language. When you say certain words and phrases, like "move to the end of the line" or "select paragraph", those actions will be executed.

You can find the whole list of available commands by saying "voice commands list", or in the Google Docs guide article with the complete list of available voice commands.

Voice Typing and Voice Commands in action

Conclusion

Voice typing, or speech-to-text, is a useful accessibility tool. I hope this article has taught you how to use it, and you will be able to write with less typing!

Whether it's for a Google Doc or an imported Word file, it works the same way – and I'll show you how in this quick guide.

Where to find the word count tool in Google Docs

You can find the word count tool in the Tools menu – it's the second item in the menu at the top. Or you can use the Ctrl+Shift+C keyboard shortcut.

Tools menu and word count feature.

How word count works in Google Docs

The word count tool shows the statistics of your current document. So if you click on "Word count" in the Tools menu, or use that keyboard shortcut, it will display the stats for the document you're working on.

It first shows first the number of pages in your document, then the number of words, then the number of characters, and last the number of characters excluding spaces. You can see an example below:

Just click "Ok" or "Cancel" to close that window.

How to have the document's statistics always visible on the page

If you're aiming for a certain number of words in a document, you might want to monitor your word count constantly – without having to reopen the tool all the time.

You can set it up so the stats are always visible on your current page. In the word count tool, below everything else, there is a checkbox called "Display word count while typing". If you check that box, it will make the word count appear in the bottom right corner of the document window, like this:

The number of words is actually a drop down menu. You can click on it to see all statistics and change which statistic is visible when the dropdown menu is closed. It also gives you an option to hide the word count tool again.

Conclusion

Google Docs easily shows you the number of words, pages, and characters in your document using the Word count tool. And it's easy to open it from the Tools menu, or using the Ctrl+Shift+C keyboard shortcut.

In this article we'll go over how to change the orientation of a document on Google Docs to landscape, how to make that the default orientation, and more.

How to change a Google Doc to landscape on desktop

Before we start, an important note: It's not possible to change only part of a Google Doc to landscape orientation. At the time of writing, the whole Google Doc has to be in either landscape or portrait orientation.

With that out of the way, here's how to change the orientation of a Google Doc to landscape.

Step 1: Open the "Page setup" menu

First, click "File" in the upper-left corner, then click "Page Setup":

Step 2: Set the page orientation to landscape

In the "Page setup" menu, you'll see two options for the page orientation: "Portrait" and "Landscape".

Select "Landscape", then click the blue "OK" button on the bottom-right:

Once you do that, your entire document will be in landscape:

Because the entire document has changed orientation, there's a good chance that any existing tables, graphs, images, and other elements in your document will need to be adjusted.

So that's simple enough, but what if you're using Google Docs on a mobile device? Fortunately that's also pretty straightforward.

How to change a Google Doc to landscape on mobile

Like with Google Docs on desktop, it's not possible to change just part of a document to landscape orientation – it's all or nothing.

Also, I'll be using Google Docs on Android for this portion of the tutorial, though the process should be similar on iOS.

And with that, let's jump in.

Step 1: Open the "Page setup" menu

Open the document, then tap the pencil icon in the bottom-right:

Tap the three vertical dots in the upper-right corner:

Then tap "Page setup":

Step 2: Set the page orientation to landscape

In the "Page setup" menu, tap "Orientation":

Select "Landscape", then tap the arrow in the upper-left to go back to the "Page setup" menu:

Press the arrow in the upper-left to go back to the editor screen.

Even though your document is now in landscape orientation, it will look just like it did before:

I assure you, this is in landscape mode!

To see the new orientation, you'll need to view your Google Doc in "Print layout" mode.

Step 3: Toggle the print layout mode (optional)

To confirm your document is in landscape orientation, tap the three vertical dots in the upper-right and tap the "Print layout" toggle:

Now you can view your document in all its landscape glory:

Note: You may need to zoom out to see your entire document

That's it! Now you should have everything you need to change the page orientation of a Google Doc on both desktop and mobile devices.

This post is originally from www.jaredwolff.com

I got my hands on some of the mesh based Particle boards not too long ago. I’ve been itching to try them out but haven’t quite figured out the project.

One thing has been bothering me though: air quality. I spend a good amount of time in my office tinkering, soldering, coding and writing. I sneeze occasionally so I always wondered, how bad is it? The house is also prone to mold exposure during the hot months which had me concerned.

So why not cook something up?

What’s needed

The most important sensor is the Honeywell HPM series PM2.5/PM10 sensor. This tells you how many micrograms of material is floating around in a cubic volume of space. i.e. it counts the little particles flying around in your air.

Second to that, is the AMS CCS811. This sensor tells you the total amount of volatile organic compounds are in the air along with things like C02. It’s another datapoint which is interesting to see. I’ve previously placed this sensor in our basement only to be surprised and see huge spikes in VOC and C02 levels from our (oil burning) furnace turning on in the morning. Time for better ventilation!

Finally, the Silicon Labs Si7021 temperature and humidity sensor. These two bits of environmental data are useful. More importantly they’re used by the algorithm in the CCS811 to compute the TVOC and C02. Considering the cost of the CCS811, I’m surprised it doesn’t have these measurements on board but maybe in their next revision..

Wiring it all together

It’s time to wire everything together. At the very least you’ll need:

1. Solder-less breadboard hookup wire
2. A solder-less breadboard
3. A CCS811 breakout board from Adafruit (more details here)
4. A Si7021 breakout from Adafruit(more details here)
5. A Particle board of your choice.
6. A HPMA115 Particle sensor
7. Pre assembled Molex cable for the HPMA115 (Molex P/N 0151340803 or similar)
8. Some 0.1” pitch headers

I’ve included a Fritzing example with this project. There’s also a hookup image below:

Note: the original Fritzing diagram was incorrect. Both Vin of the CCS811 and Si7021 should be connected to the 3.3V on the Particle

An Adafruit Feather is used to represent the Particle Argon. Particle does not have Fritzing models quite yet.

As you can see everything is hooked up except for the PM2.5 sensor. The pinout is included below.

The most important pins are the 5V, GND, RX and TX pins. The other ones can stay disconnected if you choose. Here are the connections called out:

5V -> USB GND -> GND RX -> TX (on the Argon) TX -> RX (on the Argon).

Here’s a picture of everything assembled on a solder-less breadboard.

Another important note is that I modified the cable for the HPMA so they had male pins on the end. That made it easy to insert into the solder-less breadboard. Here’s a zoomed in shot:

When you purchase the cable for the PM2.5 sensor it came pre-populated with 8 wires. To make things simpler, you can remove 4 of the wires that are not used. The best way to do that is take a sharp tipped tool (dental pick, sewing needle, etc) and stick it under the clips I’ve pointed out in red below:

Then, once you have your sharp implement underneath, tug on the wire and it should slide out.

Now you have less wire and less headache. You can use this technique to modify any Molex-like connector.

Plumbing the firmware

For this project I decided to keep my code consistent with the Wiring/Arduino-like API. That means object oriented C++. It’s been a while where I’ve coded in C++ so when you’re looking at the codebase and wondering “why the hell did he do that!?” Sorry, not sorry. ?

The best way to get started is to use Visual Code with the Particle plugins for this project. Click here to get started if you're not already setup.

Si7021

The Si7021 is super simple. It only has 4 active pins out of the 6 on the chip.

(Copied directly from the Si7021 documentation)

The best say to read the temperature/humidity sensor is to issue a blocking read command. In an embedded world, this is not ideal. Unfortunately, there’s no way to know when the readings are ready because there is no interrupt pin.

As described in the data-sheet, you first write the command and then attempt to read directly from the device. The code looks something like this:

    // Si7021 Temperature
    Wire.beginTransmission(SI7021_ADDRESS);
    Wire.write(SI7021_TEMP_HOLD_CMD); // sends one byte
    Wire.endTransmission();           // stop transaction
    Wire.requestFrom(SI7021_ADDRESS, 2);

    // Get the raw temperature from the device
    uint16_t temp_code = (Wire.read() & 0x00ff) << 8 | (Wire.read() & 0x00ff);

Wire the address of the device, write the command and then subsequently read the number of bytes necessary (Two in this case) The Si7021 will then stretch the clock until the reading has completed.

I didn’t mess around with other settings. Depending on your environment you may have to tweak how much current to feed the heater. You’re mileage may vary so prepare accordingly!

Finally, these readings are read on a reoccurring timer. I originally was using the millis() call and calculating the different of the start and current time but this eventually breaks (in 50 or so days). Instead I decided to use a system timer (similar to if not the same as the APP_TIMER in the NRF SDK)

Timer timer(MEASUREMENT_DELAY_MS, timer_handler);

That way you get your interrupt always at MEASUREMENT_DELAY_MS no matter what! (In my case MEASUREMENT_DELAY_MS = 60000 ms == 60s)

The CCS811

The CCS811 gives you a bit more freedom to play but it comes with it’s own specialness.

In most cases the ADDR pin is set low. This pin modifies one bit of the address. This is useful if you have two of the same device or two devices with the same address on the same I2C bus.

The CCS811 also has a few handy input and output pins. The most important is the interrupt pin. Whenever a reading is complete, this open drain pin will be pulled low. It will only get reset once you read the status register. This is great for asynchronous reads that way you’re not locking up your MCU.

One important point is that the CCS811 does require you to issue a “start” command. This forces the internal MCU to start executing the TVOC/CO2 sensing algorithm. If you attempt to read the data registers before the application is started you will get bogus data. (The command is 0x90)

In the firmware, the CSS811 is processed in the same loop as the Si7021. The code pulls the available data from the CSS811 asynchronous readings. No blocking code!

The HPMA115

The particle sensor is a bit more tricky. When it is turned on, the device starts sending particulate data on a regular interval. i.e. it’s in auto-send mode every time it powers up.

I tried previously to configure the device but sometimes I wouldn’t get a response back. It was always hit and miss. It drove me crazy.

So, in order to turn the device off wen you’re not using it I highly suggest using a load switch of some kind. Not only will this save power but according to Honeywell, it will also increase the lifespan of the fan.

The flow of the readings:

• Every minute turn it on
• Wait for data to be sent
• Read the reading asynchronously via UART
• Turn it off
• Bundle that data into the JSON blob to be sent to the server

This way there’s no need to mess with any registers. All the more reason why I2C and even SPI are better data buses than UART. I just want it to work!

I originally chose this sensor a while back for it’s enclosed nature. In my option, it’s easier to integrate. My electrical engineer brain doesn’t want to deal with complex stuff. Give me a box and lets go.

Getting everything working

During the development phase of this project I happened to be traveling abroad. The crappy wifi was not cutting it and it was taking forever to iterate on the code. The Argon also had a hard time connected to my iPhone’s AP so I gave up on that idea early on.

So, in order to develop the code that didn’t require the internet I placed the device into manual mode. What does manual mode do? It allows the code to start execution despite not being connected to the Particle cloud. That way you can take readings all day but you don’t have to be connected to Wifi. You can put the device in manual mode by putting this define in your .ino file:

SYSTEM_MODE(MANUAL);

In battery powered applications, this is ideal. Wifi is expensive power-wise and you don’t need to be running it if you don’t have to!

In a previous experiment, I found that it took about 10-15 seconds from nothing to sending data to the Particle cloud. That’s a long time in the embedded world. That’s one of the main reasons I suspect Particle came out with their mesh system. This allows sleepy end nodes (or nodes that are taking data and periodically sending it to a central point) to run much longer than their Wifi based cousins.

Remember you will have to run the Particle.connect() function in order to connect to wifi in manual mode. Or if you’re ready for it to re-connect, remove SYSTEM_MODE(MANUAL); from your .ino file.

Changing Wifi Credentials

During my experiment in trying to get my wifi to work I did discover a few handy Particle tools to change wifi credentials etc. By holding the mode button during operation, the device eventually starts blinking blue. Once blinking blue, you can issue a particle serial wifi which will walk you through the process of changing the credentials.

The above process is light years faster than using the iPhone/Android app. I thought the app was cool at first but man does it take a long time to scan and get your devices connected.

More info on this procedure go here.

Recovering when things go awry

I had to recover my Argon during my development process. I did some digging and found that re-programming the OS, App and Bootloader seemed to do the trick.

Get the files here: Release 0.9.0 (Gen 3) · particle-iot/device-os · GitHub (As of this writing the latest is 0.9.0)

Then program these files in DFU mode by holding the mode button after tapping the reset button once.

particle flash --usb system-part1-0.9.0-argon.bin
particle flash --usb tinker-0.9.0-argon.bin

Program this one in Listening mode:

particle flash --serial bootloader-0.9.0-argon.bin

Note: the -argon suffix may be different depending on what you’re programming to. Other options are -boron and -xenon.

Monitoring on the command line

Finally, one of the most useful commands is this one:

particle serial monitor --follow

This allows you to use the USB Serial interface to receive debug messages from he device. This is akin to connecting an FTDI device to an Arduino.

For instance, I may be debugging part of the code so I want to see some data. In the Setup() function I’ll be sure to run Serial.begin(), then later on I’ll make a Serial.printf(“data: %d”,data.tvoc); in order for it to be sent over the USB Serial interface.

Serial UART for debugging, it’s a beautiful thing.

Publishing

One thing I did discover during the development process was the publishing limits of the Particle platform. For a single device, you cannot Particle.Publish more than 4 pieces of data in one second. Even though I was taking data every minute, I was sending 6 pieces of individual data to the server at the same time. After testing I soon started to wonder why the heck my C02 and TVOC readings disappeared.

I had found the culprit.

So, in order to make things work, I had to format it as a JSON blob. See how I did it exactly below:

String out = String::format("{\"temperature\":%.2f,\"humidity\":%.2f,\"pm25\":%d,\"pm10\":%d,\"tvoc\":%d,\"c02\":%d}",si7021_data.temperature,si7021_data.humidity,hpma115_data.pm25,hpma115_data.pm10,ccs811_data.tvoc,ccs811_data.c02);
Particle.publish("blob", out , PRIVATE, WITH_ACK);

I created a JSON structure and then used String::format to insert each piece where they needed to be. If you are running your device over LTE this will cause you to send more data than necessary. There are better options like Protocol Buffers or using MessagePack. If you’re dealing with complex data, I recommend the former because of its programatic nature. Plus, you can use it with just about any programming language. So web to embedded? No problem.

After every minute, I only send the data when all three sensors have been read. I use three separate boolean values to determine the state of the sensor readings. Once they have all been set to true do I invoke the Particle.Publishcall.

Then after publishing, I reset all variables like so:

ccs811_data_ready = false;
si7021_data_ready = false;
hpma115_data_ready = false;

Then, everything starts all over again. You can also create a status struct which has each of these flags neatly inside. Considering I only have three data points, I didn’t go the extra mile there.

Using Adafruit IO

One way to publish is by using Adafruits IO platform. Here's how to get started.

1. Create an account here: https://io.adafruit.com

2. Next is to create feeds for each of the data types. We’ll need 6 in total.

3. For each feed, add a Webhook.

4. Take each webhook address and create a new Webhook in the Particle console
5. Change the Request format to JSON
6. Then under Advanced Settings click on Custom for the JSON DATA

7. Replace what’s there using mustache templates. Adafruit IO is looking for a JSON key called value. So set it like this:

   {
    “value”:”{{{c02}}}”
   }
   

   You can replace c02 with any of the keys in your JSON blob. As a reminder the current JSON blob looks something like this:

   {
    “temperature”:21.2,
    “humidity”:30,
    “pm10”:2,
    “pm25”:1,
    “tvoc”:650,
    “c02”:1001
   }
   

8. Repeat this as necessary until all feeds have a corresponding Webhook configured.
9. Finally, you can create a dashboard to see them all in one place. This is straight forward just follow the on screen prompts. :)

You can check out my live dashboard here. It’s nifty and just another way to display your data.

Sidenote: My first impressions on Adafruit IO are good. It was easy to setup and start using. The main drawback that it’s tedious especially if you have more than a handful of data points. But maybe they’ll fix that in the future!

Update: If you have multiple pieces of data. You can point your Particle integration to a single endpoint. Just make sure the data is in the same group! Here's an example of multiple values sent to the same group:

{
  "feeds": [
    {
      "key": "tvoc",
      "value": "{{{tvoc}}}"
    },
    {
      "key": "c02",
      "value": "{{{c02}}}"
    },
    {
      "key": "temperature",
      "value": "{{{temperature}}}"
    },
    {
      "key": "humidity",
      "value": "{{{humidity}}}"
    },
    {
      "key": "pm2-dot-5",
      "value": "{{{pm25}}}"
    },
    {
      "key": "pm10",
      "value": "{{{pm10}}}"
    }
  ]
}

Where your URL should look something like:

https://io.adafruit.com/api/v2/<USERNAME>/groups/<GROUPNAME>/data

That should keep your Particle integration page a little more sane!

Making sense of the readings

The readings can be confusing. Here’s the breakdown of how they work:

1. Humidity is showing in relative percentage points. This is the relative humidity we know and love. Remember it may differ with what’s outside. This depends on if your house is air conditioned or if you’re running a heater etc.
2. Temperature is in degrees C (can be modified in firmware if you so choose)
3. TVOC is in ppb (parts per billion). VOCs can be in the form of harmful chemicals you have around the house. More information about VOCs check out thislink from the EPA.
4. C02 is in ppm (parts per million). We breathe in oxygen and exhale carbon dioxide. You may find your VOC and C02 levels rising when you’re in the room. C02 does correlate to VOCs as well. More info in the data sheet.
5. PM10. Is in µg/m3 (micrograms per meter cubed). The particle sensor uses a scattered laser when then shines across the air chamber to a sensor on the other side. The more the rays are blocked, the more particles in the air. The particle sensor then does some calculations to determine the amount of particles in a certain volume and thus your µg/m3.
6. PM2.5 is the same as above but it tracks much smaller particles. (Less than or equal to 2.5µm in size!) More information on the EPA’s website here.

Don't care for something you have no control over?

Check out my tutorial on creating your own amazing looking IoT dashboard.

You did it!

Congrats. You've made it this far. You deserve a day at the spa. Or maybe some chocolate ice cream. Or if you're really feeling adventurous, both, at the same time?? ?

After building one of these you may feel like your time is worth investing elsewhere. Maybe you want to build a cool web backend with fancier charts and algorithms. Maybe even use some machine learning (why not!)

If you want something already assembled and available you should check out the Particle^2 (Pronounced Particle Squared). It has everything here including the ability to switch on and off the HPM particle sensor. You can even run it on batteries! So put that sucker anywhere you want. Check it out here.

Here's the full video on the Particle Squared.

Code and Source

This whole project is released under the Creative Commons Share-Alike license. Get the source code and hardware files here.

Get Ready for the Ultimate Guide

This post is an excerpt from my upcoming Ultimate Guide on Particle Mesh. Early subscribers get a discount when it becomes available! Click here to get signed up.