Parallax Learn

https://learn.parallax.com/
Admin
Parallax Learn is an educational platform providing tutorials and resources for robotics,...
Tokens:3,680,046
Snippets:16,866
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install BlocklyProp Launcher

Source: https://learn.parallax.com/courses/getting-started-with-blocklyprop-solo/lessons/blocklyprop-launcher

Instructions for downloading and installing the BlocklyProp Launcher for Windows, Mac, or Chromebook. This involves copying a link address, pasting it into a new tab, and following the on-screen prompts for installation.

```General
RIGHT-CLICK the installer link for your operating system and choose Copy Link Address.

OPEN A NEW BROWSER TAB and paste the link address into it.

Follow the prompts to save the Launcher file to your Windows or Mac computer, or if on a Chromebook, follow the prompts to install.

If you downloaded an .exe file for Windows, click on the file to start installation.
If you downloaded a .zip file for Mac or Windows, extract the file first.

A Setup Wizard will open. Click the Next buttons to follow the prompts through installation.

Accept default installation with FTDI drivers. Click Finish when complete.
```

--------------------------------

### Install BlocklyProp Launcher

Source: https://learn.parallax.com/courses/getting-started-blocklyprop-s3/lessons/setting-up-blocklyprop-for-the-s3

Instructions for downloading and installing the BlocklyProp Launcher on Windows, Mac, or Chromebook. This tool is necessary for using BlocklyProp Solo.

```General
Download and install the BlocklyProp Launcher for Windows or Mac, or get the extesion for Chromebook, from the Parallax store site, and then run it.
If you downloaded an .exe file for Windows, click on the file to start installation.
If you downloaded a .zip file for Mac or Windows, extract the file first.
A Setup Wizard will open. Click the **Next** buttons to follow the prompts through installation.
Accept default installation with FTDI drivers. Click **Finish** when complete.
```

--------------------------------

### BlocklyProp Getting Started with Badge WX

Source: https://learn.parallax.com/tutorials-menu/badge-wx

This section guides users through the initial setup and basic usage of the Badge WX with BlocklyProp. It covers essential steps to begin programming the device.

```BlocklyProp
// Example code for getting started with Badge WX and BlocklyProp
// This is a placeholder and would contain actual BlocklyProp code blocks.
```

--------------------------------

### BlocklyProp Getting Started with BlocklyProp for S3

Source: https://learn.parallax.com/tutorials/robot/scribbler-robot/scribbler-3

An introductory tutorial for new users on how to get started with BlocklyProp specifically for the Scribbler 3 (S3) robot. It likely covers setup, basic block usage, and uploading code.

```BlocklyProp
<!-- BlocklyProp introductory code for S3 -->
<xml>
  <block type="robot_print"></block>
  <block type="robot_wait"></block>
</xml>
```

--------------------------------

### Install BlocklyProp Client/Launcher

Source: https://learn.parallax.com/courses/getting-started-with-the-badge-wx-and-blocklyprop/lessons/register-on-blocklyprop

Instructions for downloading and installing the BlocklyProp client software for Windows, Mac, Linux, or the launcher for Chromebooks. This software is essential for interacting with the Badge WX hardware.

```General
BlocklyProp Client (Win/Mac/Linux) v 0.7.5 or higher
BlocklyProp Launcher (Chromebook) v 0.9.0 or higher
```

--------------------------------

### Propeller C Programming Setup and Practice

Source: https://learn.parallax.com/activitybot/software-and-programming

This section guides users on setting up the SimpleIDE software for Propeller C programming and practicing basic programming concepts. It emphasizes using the latest versions of the software and the Learn folder, and directs users to prerequisite tutorials for installation and initial programming examples.

```text
If you have not done so already, go to the Set Up SimpleIDE tutorial and follow the instructions, then come back here when you are done.

Now it’s time to try a little Propeller C programming. This will help you get familiar with the SimpleIDE software and the Propeller C language and Simple Libraries.
If you have not done so already, go to the Start Simple tutorial and try the programming examples, then come back here when you are done.
```

--------------------------------

### Propeller C: Set Up SimpleIDE

Source: https://learn.parallax.com/propeller-c

This guide explains how to set up the SimpleIDE development environment for Propeller C programming. It covers the necessary steps to get started with writing and compiling code for Propeller microcontrollers.

```Propeller C
Guide Propeller C – Start Simple
```

--------------------------------

### Running Setup Script with sudo

Source: https://learn.parallax.com/courses/propeller-c-set-up-simpleide/lessons/raspberry-pi

This command executes a setup script with superuser privileges. The 'install' argument specifies the installation action. 'sudo' is required for operations that modify system files or install software.

```Shell
sudo ./setup.sh install
```

--------------------------------

### Running Setup Script with sudo

Source: https://learn.parallax.com/lessons/propeller-c-set-up-simpleide/raspberry-pi

This command executes a setup script with superuser privileges. The 'install' argument specifies the installation action. 'sudo' is required for operations that modify system files or install software.

```Shell
sudo ./setup.sh install
```

--------------------------------

### Python: Get Started with micro:bit and Python

Source: https://learn.parallax.com/tutorials-menu/cyberbot/page/2_paged=3

This tutorial guides users on getting started with the micro:bit using Python. It covers basic setup and programming concepts for beginners.

```Python
print("Hello, micro:bit!")
```

--------------------------------

### ColorPal Wiring and Code Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/system

Details the wiring setup and provides example code for the ColorPal device. This snippet shows how to use the ColorPal to detect and output color information.

```C
// Example code for ColorPal
// Include necessary libraries
#include "simpletools.h"

// Main function
int main() {
  // Initialize ColorPal
  // Read color data
  // Output color information
  return 0;
}
```

--------------------------------

### MakeCode Get Started with micro:bit and MakeCode

Source: https://learn.parallax.com/tutorials/page/2

A beginner-friendly tutorial to help users get started with the micro:bit and the MakeCode programming environment. Covers basic setup and first program.

```MakeCode
This is a placeholder for MakeCode code for getting started with micro:bit.
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/system

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Create a New BlocklyProp Project

Source: https://learn.parallax.com/courses/getting-started-blocklyprop-s3/lessons/setting-up-blocklyprop-for-the-s3

Steps to create a new project in BlocklyProp Solo. This involves opening the launcher, starting a new project, naming it, and selecting the Propeller board type.

```General
Open the Launcher from the desktop icon or from your Start menu, if it is not already running.
Under Open Browser, click the **BlocklyProp** Solo button.
Click on **New project**.
In the window that opens, type in a **Project Name**.
From the dropdown menu, select your Propeller board type.
Click **Continue**.
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/serial-lcd

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Propeller C: Run Test Program

Source: https://learn.parallax.com/lessons/propeller-c-set-up-simpleide/mac

This snippet demonstrates how to run a basic test program using SimpleIDE to verify the Propeller board connection and software setup. It expects a 'Hello!' output.

```Propeller C
// Example code to run in SimpleIDE
// This is a placeholder, actual code would be provided by the user.
// For demonstration, imagine a simple 'Hello World' program.

#include "simpletools.h"

int main()
{
  print("Hello!\n");
  return 0;
}
```

--------------------------------

### Install SimpleIDE on Raspberry Pi using GitHub

Source: https://learn.parallax.com/courses/propeller-c-set-up-simpleide/lessons/raspberry-pi

Instructions for installing SimpleIDE on a Raspberry Pi by compiling from the repository source code on GitHub. Users should follow the installation instructions provided in the Linux INSTALL.txt file.

```bash
git clone https://github.com/SimpleIDE/SimpleIDE.git
cd SimpleIDE
./install.sh
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/gps

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Install SimpleIDE on Raspberry Pi using GitHub

Source: https://learn.parallax.com/lessons/propeller-c-set-up-simpleide/raspberry-pi

Instructions for installing SimpleIDE on a Raspberry Pi by compiling from the repository source code on GitHub. Users should follow the installation instructions provided in the Linux INSTALL.txt file within the repository.

```bash
git clone https://github.com/SimpleIDE/SimpleIDE.git
cd SimpleIDE
# Follow instructions in Linux INSTALL.txt
```

--------------------------------

### MakeCode: Get Started with micro:bit and MakeCode

Source: https://learn.parallax.com/book_collection/cyberbot-makecode-tutorial-series

This tutorial introduces users to the MakeCode environment and how to get started with programming the micro:bit. It covers basic setup and the initial steps for creating programs.

```MakeCode
## MakeCode Get Started with micro:bit and MakeCode
```

--------------------------------

### Propeller C: Setup

Source: https://learn.parallax.com/courses/propeller-tilt-tones-project

This snippet provides guidance on setting up the development environment for the Propeller Tilt Tones Project using Propeller C. It may include instructions for SimpleIDE and basic project configuration.

```Propeller C
// Placeholder for Propeller C setup instructions
// This might include setting up SimpleIDE, project files, and necessary libraries
```

--------------------------------

### Get Started with Prop BOE Tutorial

Source: https://learn.parallax.com/public_downloads/spin-tutorials-and-projects

Beginning tutorials for the Propeller Board of Education (BOE). This resource provides foundational knowledge for using the Propeller microcontroller.

```SPIN
Get-Started-with-Prop-BOE.zip
```

--------------------------------

### Propeller C: Adding Simple Libraries

Source: https://learn.parallax.com/courses/propeller-c-start-simple

Demonstrates the process of including and utilizing Simple Libraries in Propeller C projects. Libraries provide pre-written code to simplify common tasks and extend functionality.

```c
#include <simpletools.h>
#include <lib_name.h> // Include a specific library

int main()
{
  // Use functions from the included library
  // library_function();
  return 0;
}
```

--------------------------------

### Install SimpleIDE from GitHub Repository (Linux)

Source: https://learn.parallax.com/courses/propeller-c-set-up-simpleide/lessons/linux

This snippet outlines the process of compiling SimpleIDE from its GitHub repository for Linux users. It requires specific dependencies to be installed first.

```Shell
# Clone the SimpleIDE repository
git clone <repository_url>

# Navigate to the repository directory
cd SimpleIDE

# Follow instructions in the Linux INSTALL.txt file for installation
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/support/reference/activity-board-wx-block-reference/sensor/rfid/rfid-wiring-example-code

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/support/reference/activity-board-wx-block-reference/sensor/ping-distance/ping-wiring-example-code

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/memsic-2125-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/servo

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/xbee

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp: Print 'Hello, World!' to Terminal

Source: https://learn.parallax.com/courses/getting-started-with-blocklyprop-legacy-version/lessons/create-a-program

This snippet demonstrates how to use the 'terminal print text' block in BlocklyProp to display 'Hello, World!' in the output terminal. It requires the BlocklyProp client to be running and the correct COM port selected.

```BlocklyProp
terminal print text("Hello, World!")
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/temperature-humidity-sensor-wiring-example-code

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Load and Run BlocklyProp Project to EEPROM

Source: https://learn.parallax.com/courses/getting-started-with-blocklyprop-solo/lessons/saving-projects

This snippet explains how to load and run a BlocklyProp project onto the Propeller board's EEPROM. It involves clicking the 'Load and run' button, which briefly displays 'Load into EEPROM' before opening the terminal. Pressing the Reset button on the board then executes the project from EEPROM.

```BlocklyProp
Run your Terminal print text project again by clicking the **Load and run** button.
Notice the message now says **Load into EEPROM** briefly before the terminal opens.
Press the Reset button on your Propeller board (above the switch on the Propeller Activity Board, or on the edge opposite the USB connector on the FLiP). This interrupts power and resets the Propeller microcontroller.
Each time you press the button, the message will reprint in the Terminal.
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/fingerprint-scanner-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/robot

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/simple-wx

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Getting Started with Badge WX

Source: https://learn.parallax.com/book_collection/badge-wx-tutorial-series

This tutorial covers the initial steps for using BlocklyProp with the Badge WX. It is a prerequisite for understanding the main lessons and developing foundational programming skills for the device.

```BlocklyProp
// This section is intended to guide users through the initial setup and basic functionalities of the Badge WX using BlocklyProp.
// It covers foundational skills necessary for subsequent tutorials.
// Example: Setting up a basic LED blink or button input.
console.log("Getting Started with Badge WX and BlocklyProp");
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/voltage

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/temperature-humidity-sensor-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/terminal

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/rfid

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Propeller C Setup and Basics

Source: https://learn.parallax.com/book_collection/activitybot-with-c-tutorials

This section covers the foundational aspects of Propeller C programming for the ActivityBot. It includes setting up the SimpleIDE environment, understanding basic programming concepts, and working with simple circuits and functions.

```C
// Propeller C - Set Up SimpleIDE
// This section would contain code or instructions for setting up SimpleIDE.

```

```C
// Propeller C - Start Simple
// This section would contain basic Propeller C code examples.

```

```C
// Propeller C - Simple Circuits
// This section would contain code related to controlling simple circuits.

```

```C
// Propeller C - Functions
// This section would contain examples of using functions in Propeller C.

```

```C
// Propeller C - Multicore Approaches
// This section would cover multicore programming concepts in Propeller C.

```

--------------------------------

### Run Test Program in SimpleIDE

Source: https://learn.parallax.com/courses/propeller-c-set-up-simpleide/lessons/windows

This snippet demonstrates how to run a test program within SimpleIDE to verify the setup. It involves clicking the 'Run with Terminal' button and checking for a 'Hello!' message, confirming successful communication with the Propeller board.

```Propeller C
// Example of running a test program in SimpleIDE
// This is a conceptual representation as the actual code is executed via the IDE button.
// The IDE handles the compilation and upload process.

// To verify, click the 'Run with Terminal' button in SimpleIDE.
// Expected output in the terminal: "Hello!"

```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/wx-wifi

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Run Test Program in SimpleIDE

Source: https://learn.parallax.com/courses/propeller-c-set-up-simpleide/lessons/mac

This snippet demonstrates how to run a test program within SimpleIDE to verify the setup. It involves clicking the 'Run with Terminal' button and checking for a 'Hello!' message, confirming successful communication with the Propeller board.

```Propeller C
// Example code to be run in SimpleIDE
// This is a placeholder as the actual code is not provided in the text.
// The user is instructed to click 'Run with Terminal' and verify output.

// void main() {
//   print("Hello!\n");
// }
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/rc-time

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/temperature-humidity-sensor-wiring-example-code

Information and potential code examples related to the BlocklyProp Bulk Project Download feature. This might involve scripts or configurations for managing multiple projects.

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/pwm

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/pir-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/pin-states

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/joystick-wiring-example-code

Information and potential code examples related to the BlocklyProp Bulk Project Download feature. This might involve scripts or configurations for managing multiple projects.

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/lsm9ds1-9-axis-imu

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/support/reference/activity-board-wx-block-reference/sensor/rfid/rfid-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/ping-distance

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/support/reference/activity-board-wx-block-reference/sensor/ping-distance/ping-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/memsic-2125-wiring-example-code

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/pir-wiring-example-code

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/ir-remote-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/pir

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/joystick-wiring-example-code

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/functions

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Recommended Browser for Development

Source: https://learn.parallax.com/courses/parallax-wx-wi-fi-module-for-prop-c/lessons/wi-fi-module-firmware

Recommends Google Chrome as the preferred browser for the Module + Propeller C tutorial activities and provides a link for download.

```N/A
NOTE: Google’s Chrome web browser is recommended for these Module + Propeller C tutorial activities. It can be downloaded and installed from https://www.google.com/chrome/browser/.
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/lis3dh-accelerometer

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Install BlocklyProp Launcher

Source: https://learn.parallax.com/courses/blocklyprop-for-your-sumobot-wx

Instructions and resources for installing the BlocklyProp Launcher, a necessary software component for programming the SumoBot WX. This includes links for schools and IT teams.

```N/A
BlocklyProp Solo, Launcher, and FAQ for Schools
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/graph

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/joystick-wiring-example-code

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### Propeller C: Create Simple Library Example

Source: https://learn.parallax.com/courses/propeller-c-library-studies/lessons/how-to-create-a-simple-library

This C code demonstrates a basic application with two functions, 'awesome' and 'epic', which print messages to the console. This serves as the starting point for creating a reusable library.

```C
/*
 Awesome Messages.c
*/

#include "simpletools.h"                      // Include simple tools

void awesome(void);                           // Forward declarations
void epic(void);

int main()                                    // main function
{
  print("Nick");                              // Print a name
  awesome();                                  // Append with "is awesome!\n"

  print("Jessica");                           // Print another name
  epic();                                     // Append with "is epic!\n"
}

void awesome(void)                            // awesome function
{
  print(" is awesome!\n");
}

void epic(void)                               // epic function
{
  print(" is epic!\n");
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/memsic-2-axis

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### XBee Communication Setup & Example

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/hmc5883l

Guides on setting up and using XBee modules for wireless communication in Parallax projects. Includes basic communication examples.

```C
#include "simpletools.h"

int main()
{
  // Initialize serial communication for XBee (e.g., on UART pins)
  serial_open(9600);

  while(1)
  {
    // Check if data is available from XBee
    if (serial_available()) {
      char received_char = serial_read();
      print("Received: %c\n", received_char);
    }

    // Example: Send a character wirelessly
    // serial_write('H');
    // print("Sent: H\n");

    pause(50);
  }
}
```

--------------------------------

### BlocklyProp Bulk Project Download

Source: https://learn.parallax.com/reference/propeller-blocklyprop-block-reference/simple-wx

Instructions and code examples for downloading multiple BlocklyProp projects in bulk. This is useful for managing and deploying numerous projects efficiently.

```BASIC
' Example for BlocklyProp Bulk Project Download
PRINT "Downloading projects..."
```
Tokens:
Raw