Great start

I absolutely love this walk through for getting set up for Rust on ESP32

https://blog.billvanleeuwen.ca/crafting-a-hello-world-in-rust-for-the-esp-32-a-step-by-step-guide

Con

Using Docker like that is going to create non-reusable container. That Docker command will create a new container every time you run it.

This means you’re gonna fill your hard drive up with a lot of builds if you compile as often as I do. Also, every new container means cargo is going to download all the libraries every time. So you’re using up space and bandwidth.

Pro-Tactics

Many thanks to SocketWench for coaching in Docker basics a few years ago. I remembered I could setup reusable containers using Docker Compose.

My recall was rough and I would describe the experience as someone trying a bicycle for the first time in years in falling over a few times before finally making their way down the road.

However, I got up and running with some help from composerize which you can paste someone’s docker run command into and get back the start of a docker compose file.

composer.yml

name: lilygo-tdeck-pro-rs
services:
    idf-rust:
        stdin_open: true
        tty: true
        volumes:
            - $PWD:/home/esp/project
        image: espressif/idf-rust:esp32s3_1.90.0.0
        command: /bin/bash

With this file you can run docker compose up -d to start the container. The -d flag is to say run it detached, running it in the background. The to connect to the container you can run docker-compose exec idf-rust /bin/bash which will drop you into /home/esp and you can cd into your project directory to compile.

Front and Back

There are parts of this project that will not have anything to do with the hardware it's running on. I'm calling that part the application and the front-end of the project.

Anything involving the hardware the project is running is going to be denoted as firmware and the back-end of the project.

Learning to Test

I have not had the opportunity to work on any projects professional that have a formal testing process set-up. A staggering amount of web projects have not testing what so ever.

I learn best by doing. Show me working examples that I can run myself and tease apart and play with. Peach Pit Press has a set of books branded “Visual QuickStart Guides” and I adore those. They are perfect for how I learn best.

I understand at a high level why you want to test but I’ve no idea how to start it myself on my own project.

Always be noobin’!

A mutual on fedi, @federicomena@mstdn.mx, looked through what code I’ve published so far and gave me some great ideas on how to start adding in testing.

“You can start by deciding what would benefit the most from adding tests – code that breaks often during changes, or code that you want to refactor but not break, that sort of thing.” – Frederico

Where I am

I do not have too much to show for February because I am in the process of setting the up firmware code as a separate sections from the application code. I can run the firmware test from onboard the device(s) and test the application behavior and logic from my desktop because it will not depend on hardware specifics.

Where I’m Going

When it’s done have it set up to run in a test framework, then I will post the code and tests up on the repo. Hopefully the March update will be longer and have more to show. I’m moving in a couple of weeks so let’s see how much of next month gets eaten by that. Bye!

Here's my summary write up and I made a small demo video at the bottom of this page. Thank you for checking out my project.

A Palm Pilot Shaped Hole In My Heart

Who Am I?

You can call me c0debabe.

I'm a developer, maker, and artist who needs assistive technology to counter their ADHD, whether that's pencil and paper or digital tools. I grew up using PDA style technology and I want to return to that style of digital assistance.

Prior Art

I am attempting to make a personal digital assistant (PDA) device. Before smartphones, they were the go-to type of device for personal information management (PIM). Popular devices in this category included:

Palm Pilot style devices

Palm Treo style devices

Sony CLIÉ

Window Mobile on Pocket PC devices

And then the fire nation attacked. I mean the iPhone happened.

Hardware I am using

M5Stack Paper

M5Stack CardKB

LilyGo T-Deck Pro

Paper Links: shop link and docs link

CardKB Links: shop link and docs link

T-Deck Pro Links: shop link and repo link

But Why?

PDA devices were digital, but wireless networking was no where nearly as omnipresent as it is now. These devices were offline-first software (this used to be the default) that would sync to your personal computer over specialty USB connectors.

It has not been a full technology detox, but the last several years I've been using less of the latest and greatest. I've put my mental health first. Speaking of mental health, I got diagnosed with ADHD recently and having that additional context has helped me immensely.

I need that extra bit of help with remembering stuff. It can be a paper notebook or smart phone, but I want the PDA experience back. (see my first PDA post for more ranting)

Challenges

As of FluCon 2026, I'm three months into this project. I have learned so much and cursed just as much.

Challenges in the project for me have been:

• this is my first embedded project
• Megabytes and kilobytes only; you get giga-nothing
• I have not used C/C++ since college in the 2000's
• e-ink screens do not let you use usual UI tactics
• it's surprisingly easily to end up in a crash and reboot loop
• mergers and acquisitions are bad for documentation
• Just because a library is popular doesn't mean it's easy to get it to work in your project

So there has been a lot of f.a.f.o.

Solutions and Lessons

• Thinking of it as a paper flip-book has made working with the UI easier
• Starting over fine, but don't delete past attempts
• If something is smooth and pretty it's because of iteration from clunky
• Catching exceptions is important
• Typography matters on e-ink
• When working with just text you don't need much space
• Learned how to setup callback functions

Where I am and What's Next

Working

• boots, yay
• keeps running, double yay
• can sync time with SNTP
• read and write to SD card
• data files are plain text and JSON
• command line style interface

The device "runs" now. So next is the PIM stuff.

To-Do

• Open and edit notes
• Calendaring
• Contacts
• Tagging

Nice to Have

Probably much futher down the road

• Advanced productivity activities like
  • setting routines
  • reminder to keep in touch
  • habit tracking
• GPS logging
• On the LilyGo, which is a LORA device, add in LORA messaging

DIY

Project Status: Under active development.

Future versions of this talk (and the content on my website) will have better instructions, eventually.

• Buy hardware
• Find manufacturer examples
• Clobber examples in working hello world
• Iterate

No, really though my repo is on codeberg.org:

https://codeberg.org/c0debabe/pawb-pda

This is mostly for transparency. I am not ready to accept patches or requests.

I did want to share my base working code so others can have their own adventures.

Video

It's been one of those projects.

Focus

I spent some time braining storming more about how I want to use this daily. I realized I wanted to be able quickly record something for my inbox. The first thing that came to mind was a command prompt. So I took that and ran with it. I decided between that and supporting multiple devices, I figured a command-line style UI would work just fine.

Less

Moving to a text-based UI also solves some of the limitations I was bumping into. Every time I would try to make the GUI look pretty, I would run out of memory and crash. I'm sure there are things I could do better to make the pretty UI work, however, I'm kicking that down the project roadmap for now.

Almost every time I've had to back track on something, I've had to tell myself "No, no. Less."

Working with E-Paper

With e-paper display, you are drawing on to a screen in grayscale. You draw on top of what you just drew. The effect is similar to a flip-book animation. To make this look smoother, you can build out what you want to draw in memory using the canvas-sprite in M5GFX. That way in a single smooth motion everything can drawn onto the screen in one go.

So if you're accepting user input from the keyboard and they hit the backspace, how do you erase the last character? You draw on top of what you just drew.

input_buffer.back().pop_back();   // from the last character from the input being collected
MoveCursor(-1,0);                 // Move the cursor backwards 1 character width
PanelPrint( " " );                // Draw a blank space over that character (think whiteout on paper)
MoveCursor(-1,0);                 // Bring the cursor back and then keep going

Fonts

I was so excited to use my favorite font, MonoLisa, but I discovered that the utilities that convert TTF and OTF fonts into VLW (the embedded format supported by the device's graphics library) does not preserve kerning (whitespace around characters). This breaks the easy-math method for handling those backspaces I was just talking about. A fixed-width font means the distance for any move the cursor makes is goign to be a fixed number. If I was using a variable width font, I'd have to pay more attention and I have ADHD.

Here is how I'm sizing the interface based on the device's screen and the font that is loaded.

// Test Sprite to Measure Font Size
panel.createSprite(100,100);    // create a test sprite to draw on 
panel.setFont( AppFont );       // change the default font
panel.setCursor(0,0);           // for sanity's sake, let's put the cursor at 0,0
panel.print( "P" );             // Draw a letter
panel.print( "\nW");            // Carriage return and then a second letter
char_w = panel.getCursorX();    // Get the cursor's x and y position now
char_h = panel.getCursorY();    // based on that we know character width and line/character height
panel.deleteSprite();           // trash the sprite, we'll make the real one next

Pointers

I have used pointers before, but I had not used a function pointer before this project. Not overtly and on purpose at least, because clearly by this point I have used a callback before. I just have never built a callback.

I'm using a function pointer to chain together functions as they get called from the main loop.

Application Structure

Arduino projects all have two key parts: setup and loop. First everything you put in setup runs to initialize hardware and software components. Then loop runs until there's a reason to not run anymore. If you exit the loop, the device will soft restart and take you back to setup again and then loop again.

What calls a function from loop for something to happen is up to you. It could be a touch screen event, keyboard in put, checking a sensor for a value, or a call out to another API. Right now because I'm focusing on command-line style interaction, I'm mostly concerned with checking for keyboard input and processing that.

Let's walk through a small example program.

Includes and Definitions

This project is a combination of the ESP32 libraries, Arduino framework, and the M5Stack frameworks.

// From Arduino
#include <SD.h>
#include <sd_defines.h>
#include <sd_diskio.h>
#include <Wire.h>

// From M5STack
#include <M5GFX.h>
#include <M5Unified.h>

// A library I found to enable python-like string manipulation
#include <pystring.h>

static const int CARDKB_ADDR = 0x5F; // I'm using the CardKB

Setup

This is a basic setup function. I initialize the frameworks and the hardware.

void setup()
{
  // put your setup code here, to run once:
  M5.begin(); // M5Unified init function
  Serial.begin(115200); // Start the serial connection for debugging
  Wire.begin(25, 32); // Init connection to M5 CardKB
  // init the SD card
  while( !SD.begin(4, SPI, 25000000) )
  {
    Serial.println( "SD Card not found." );
    // depending how much info you have on the card
    // this could be a big issue
  }
  // Init whatever you are going to use
  Serial.println( "=== setup complete ===" ); // some helpful debugging info
}

Loop

How many times per second loop runs depends on the processor. Fun experiment, create a variable called loop index and incriment it every loop. Watch how quickly is grows.

Here's the example loop:

void loop() {
  // put your main code here, to run repeatedly:
  M5.update(); // M5 Unified function to update stuff in the background
  if( M5.Touch.getCount() == 1 ) // check if there is a single tap event
  {
    // how you want to handle it here
  }
  Wire.requestFrom(CARDKB_ADDR, 1);
  while (Wire.available())
  {
    char c = Wire.read();
    if( c > 0  ) // Characters are also number
    {
      // Handle C  :: input_buffer.back() += c;
      if( c > 0 )
      {
        HandleNewCharacter( c ); // figure out how you want to hand that new character
      }
    }
  }
  // continues until it crashes or something
}

Getting commands from the user is collecting each letter typed in until "enter" and then running what was requested. If information was requested, I can print that out and then return right back the prompt. If the command is a multi-step process though, I need a way to chain everything together. That's where the function pointer comes in.

NextAction is the function pointer that I use. If it's null, I assume what has been submitted is a new command from the prompt that needs to be interpreted. If it's set to something, I call what NextAction is pointing at to continue the multiple process. At each step, I declare what the next one should be.

A great snippet to show this would be the clause for the "collect" command.

else if ( command == "collect" )
{
  PanelPrintLn("input: ");   // Prompt the user to type in what's on their mind
  input_on = true;           // this is a flag I'm using to denote not to interrupt the user
  multiline = true;          // This prompt will allow for multi-line input
  NextAction = SaveNewItem;  // Set the NextAction pointer: save input to file
}

Where that pointer gets used is when the user hits the submit key. I've chosen the keyboard combination of function key plus the enter key for "submit."

else if ( letter == 0xA3 ) // fn+enter: is always the submit input command
{
  Serial.println("fn+enter");
  string joined = pystring::join( "\n", input_buffer ); // join in the input with line returns
  input_history.push_back(joined); // I'm keeping track of recent input to later enable undo
  input_buffer.clear(); // clear the buffer
  input_buffer.push_back( "" ); // set up the buffer to use again
  PanelPrintLn(" <- "); // this is the symbol I use to denote end of input 
  if( NextAction == NULL ) // If there is no next action:
  {
    ReadCommand(); // treat the submitted input as a prompt command
  }
  else
  {
    NextAction(); // If there is callback action, do that now
  }
}

The menu command shows the list of available actions. For collect I input the word cheese and it gets save to a file. Then I ask for a device status report which tells me I have 3 inbox items, 3 note items, and the battery is at 100%; here's a photo of that:

Bye

Thank you for reading. I'm just noob hoping to share my adventures with other potential noobs.

In other exciting news, I am getting new hardware. I'm sure this will involve a lot of cursing. However, I'm very grateful to my fellow hackers.town townie for shipping me a LilyGo T-Deck Pro. I should have in the next few days. I will be writing about that in the update post for February.

Back to PDA Blog

This project is beating all the bad memory usage habits out of me.

Training Wheels

I initially started this project using M5’s UIFlow 2 development tool. It’s a Blockly interface that helps you build software for your devices using the MicroPython libraries. The MicroPython is just wrappers around their C/C++ SDK. The thought was that I had not touched C or C++ since college so I should start out with something easier like Python.

I was wrong. I know way more than I did in college about software development and quickly ran into limitations of in both Blockly programming and using MicroPython. Both of these are set up really well for entry level programmers to tinker. However, I found the documentation and lack of parity with the C libraries to be frustrating. I think the Python around the C is doable but if you have a robust project idea, you need to be using C/C++.

Aside: There is developer making their take on a PDA with an M5 Paper S3. The S3 is a the slightly beefier model with more features. This reddit user has not posted in a bit but you catch their videos on their profile.

The order I learned my languages* is: HTML, CSS, JavaScript, C, PHP, C, Java, Bash, Python, Rust. Going back to C/C has been easier than I expected. My university grades may have been mediocre because of health issues but I definitely learned the material.

*No, I do not want to debate what constitutes a language.

Lessons

Setup and Loop

M5Stack extends existing Arduino and Espressif libraries. If you’re familiar with either of those, getting started is pretty easy. setup() gets called first and then loop() runs until told otherwise, or an unrecoverable exception.

Canvases

One of the big challenges was learning how to use the canvases. The canvas class helps you pre-render a set of graphics in memory and then quickly push them to the display all at once. The naming is a little confusing and how it works is minimally demonstrated.

The canvas is an object that spawns sprites: buttons, and whatever else from the M5GFX library you want to render. It handles one sprite creation at a time but onto the same canvas. So build the entire scene you want to create and then display it when you’re ready.

There is not stack or queue with the canvases in the sense that when you’re done with what’s on screen you request canvas.hide(). You can keep drawing over yourself. Here’s an example Arduino sketch and the output it generates:

#include <M5GFX.h> #include <M5Unified.h> void setup() { M5.begin(); M5Canvas fancyStuff = M5Canvas(&M5.Display); fancyStuff.createSprite( 480, 100 ); fancyStuff.fillSprite( 0xfcfcfc ); fancyStuff.setTextColor( TFT_BLACK ); fancyStuff.setFont( &fonts::FreeMonoBold24pt7b ); fancyStuff.drawString("Hello World",30,30); fancyStuff.pushSprite(30,30); } void loop() { M5.update(); delay(500); }

You don’t have to make a new canvas for everything you want to display. The canvas is reusable. However, please note that you can queue up a bunch of sprites and push them together. If you do them in series, they will draw in series.

... M5Canvas fancyStuff = M5Canvas(&M5.Display); fancyStuff.createSprite( 480, 100 ); fancyStuff.fillSprite( 0xfcfcfc ); fancyStuff.setTextColor( TFT_BLACK ); fancyStuff.setFont( &fonts::FreeMonoBold24pt7b ); fancyStuff.drawString("Hello World",30,30); fancyStuff.pushSprite(30,30); fancyStuff.createSprite(64,64); fancyStuff.fillSprite( TFT_BLACK ); fancyStuff.setTextColor( TFT_WHITE ); fancyStuff.setFont( &fonts::FreeMonoBold18pt7b ); fancyStuff.drawString("?!",13,16); fancyStuff.pushSprite(430,50); ...

E-ink Mechanics

Another thing that find important to note is that screen degrades with each partial redraw. Part of the way the M5 Paper draws is with lines that run the length of the screen. If you do a lot of partial redraws its becomes more clear where these are over time. Depending on your use case, this might not matter that much because you’re doing full draws of the screen often enough.

Here is a comparison of just the hello world header drawn versus the hello world header and overlapping boxes. I drew sequentially 100 black boxes down the side of the screen. The only editing on this images is cropping.

A lot of the color defaults for the SDK are white foreground on a black background and I wonder if that is to hide some of this.

16 colors? Yeah, that's just each number 0-15 in hex.

Arduino, JetBrains, and Platform.io

The IDE from Arduino is a great entry level IDE. It’s enough to get things done and makes board and device support relatively easy. That said, I did also try JetBrains’ C-Lion with Platform.io and that is really slick. I’ve always been of fan of JetBrains’ different IDEs and that combo is no exception. That’s the full featured IDE experience I’m used to as a professional developer.

Platform.io does not have full support for the M5 Paper and I had to use the profile of a board with similar specs, the LilyGo T-Display. That device does not have an SD card slot so I was blocked from getting too far.

I open a ticket requesting device support though, which you can read on GitHub. If you would also like to see support for the M5 Paper, please star or comment on my ticket. Depending how they impliment it there may need to be a separate request for the M5 Paper S3.

Fun with M5GFX

A lot of the documentation is the example code. So unless you go through all the examples and click through all the API pages, you might not catch it all.

• Fonts: There are more fonts than UI Flow 2 lets on. You can find the full font list available on the library’s appendix page.

• Colors: There are defined constants for common colors you can use but these are not all the colors. Depending on the capabilities of your display, you can also just enter the hex code for the color.

• Bookmark this page: M5GFX API Catalog, which lists all the canvas/display related functionality. Pay attention as a lot of function have multiple definitions.

• Gotcha: If you rotate the screen from UI Flow 2, it will rotate only display. You have to rotate your canvases separately. It also does not rotate the coordinates for touch events.

• Gotcha: UI Flow 2 does not have any buttons, but the C/C++ SDK does. In C/C++, you can write (this psuedo code) button.contains( touch.x, touch.y ) and it will let you know if hit the button.

Where am I?

During my Python adventures, I wrote a class to handle data in hashmaps. I realized that I won’t be making up my mind anytime soon on what data to store so I may as well just have entries be different types of maps. I have started porting it to C/C++.

Currently I am working on a class to help me do time related functionality. I have the device, when it’s starting up, join my wifi network and sync with an NTP server. Now I’m trying to get the current date and time in my preferred formats. If I don’t bored with the time library, I’ll also try to get some time math working. I’d like to be able to questions like when is one week from now or when was 4 days ago.

Right now, on boot, the app pauses at a splash screen and doesn’t continue until you hit start. I made some mistakes that would cause a crash and reboot cycle. So the pour thing wouldn’t get stuck doing that, I added the splash screen. Plus, it looks rad as fuck with this artwork from RevengeDay.

Memory Limits

I knew going in that memory limitations were going to be a thing. However it has been an amusing challenge do less. No less than that. Keep going. Ha! Also, I have a tendency to take things literally so the process of over thought code being reduce down to "if it looks right that's enough."

Where am I going?

Another power related quality of life item I would like is to be able to know when the device puts itself to sleep. However, the M5 Paper does not have a PMIC (Power Management Integrated Circuit), so I think I just need to specify the interval myself, and then right before that time, display a “I’m sleeping” splash screen. Also, I need something similar for shutting down.

Speaking of the sleep/power screens, one idea a friend gave me was to leave notes for yourself on the screen. That might be a feature out of the notebook, where you could pin a page to the sleep screen for reference.

Bye!

Thank you reading my post. If it felt like it was all over the place, it’s because I’m still bouncing all over trying to get my footing on the platform. I’m hoping now that I have some traction, I can make more purposeful strides forward.

I want that feeling back.

I am going to build an e-ink PDA from an M5 Paper to bring back that feeling. This is my first project using a development board or embedded class device. Wish me luck!

Early Devices

My first PDA was a sky blue electronic diary from Radio Shack. It had the date, time, telephone directory, a calculator, a dice roller, a fortune telling game, and matchmaker. This was my best friend in middle school.

In high school, I used a Royal digital organizer. It had a calendar, a clock, alarms, phone directories, a memo notebook, and a calculator. The calculator could do current conversions. The clock could tell you all the timezones.

I went through Palm PDA's in college. I remember the Palm T|X most fondly as it was the first pocket device I could connect to the campus Wifi. It was the first PDA I had that had color instead of a gray-scale display. As I was finishing my degree, I got a Palm Treo and then a Palm Pre.

Focus and Purpose

I loved PDAs because they helped me stay organized and on task. Sure, you could play games on them but they weren't super involved games. Usually it would be something to kill time while in the supermarket checkout line.

Smartphones were pandora's box for us. With the ability to write powerful software and have it in our pocket, we both increased and decreased productivity. We’ve improved banking and ruined personal free time.

Looking Back and Moving Forward

When I saw the M5 Paper the first time my brain immediately thought, “e-ink PDA.” At the time, I was heavily focused on maintaining my web development career post-divorce. I did not have the time or energy to dive into device development.

This year my career came to a halt when I was laid off from my job. The job market has been tough and I have not landed a new job yet. I decided I need to use this time to expand and sharpen my skills. Now is the time for the PDA project.

Device Overview

The M5 Paper is an ESP32 embedded development board. If you’re not familiar with electronics, this means that it the hardware shipped with minimal software. There is no operating system. I am using MicroPython (Python specifically for tiny computers) to write a PDA system for the Paper.

Paper Specifications

It has a ESP32-D0WDQ6-V3 board inside a plastic shell. If you’re looking on Espressif’s website it is listed as NRND, not recommended for new designs. This phase comes before end-of-life and the manufacturer recommending you use the newer models. The e-ink display is built into the shell with the board (model number is ED047TC1 and it will show up as a LilyGo display depending on the tools you're using) and is 540 pixels by 960 pixels in 16 shades of gray. It weighs only 81.9g or 2.89 ounces. Smaller and lighter than most iPhones, the Paper is about the size of an index card or fieldnotes notebook: 118.6 x 67.0 x 10.0 mm or 4.67 x 2.63 x 0.39 inches. It has Wifi and Bluetooth, as well as three I2C grove ports and a microSD card slot. Like most embedded boards, the on-board storage is measly compared to smartphones, but the SD card slot can support up to 16GB. You can catch the full details at: https://docs.m5stack.com/en/core/m5paper_v1.1

Software Development

The python SDK M5 provides is called UI Flow 2. It’s a Blockly based web IDE for their MicroPython library. The core framework is written in C. Applications can be written in C but Python is more my style. It’s a personal preference more than anything else. Set up involved flashing their UI Flow 2 developer image to the device. Then you can load software and manage the device in Google Chrome over USB. It makes me sad that Chrome is the only browser supporting serial device management but that’s another blog post.

File Management

The firmware they have you flash to work with UI Flow 2 sets up a /system partition, a /flash partition, and you can also access a /sd partition if you have a microSD card in the device. UI Flow lets you manage the files in the /flash partition to files like additional python libraries, fonts, and image files.

Warning! Adding files via the web IDE and then removing them from your project does not actually remove the files from your device. Make sure to manually remove them from the device or you'll run out of storage.

You can access the /system partition on the device with more robust developer tools. I was able to poke around by installing PyCharm and getting the MicroPython Tools plugin. Connecting to the device over serial with those tools shows the /flash and /system partitions.

I did the obvious thing and changed the image shown on boot:

Software Goals

The device can be set to boot into main.py immediately. So my idea is to develop a python application to act as the launcher and bring in various other libraries to act as the features of the PDA. We will see how far I can get, but my dream line-up would include:

• calendar and schedule functionality
• to-list functionality
• journaling
• habit tracking
• weather forecast
• contacts directory
• keep-in-touch functionality that helps remind you who you haven’t talked to in a while
• a calculator pad akin to Soulver for iPad, see https://soulver.app/
• notepad / notebook
• password vault
• e-book and document reader
• web-page cacher (maybe something like Wallabag)

Old school Palm fans will remember that caching web pages to read while on the go was a common workflow.

These are productivity tools we’ve all come to know and love, sans the ability lose oneself in pocket gaming or doomscrolling.

My initial focus is on the core PIM (personal information management) functionality of calendaring and contact management. I am currently reading up on the ability of the vcard and iCalendar file standards. I’m writing basic classes for handling these because I do not need the full feature set of the standards, which would be more of a “use an existing library” situation. I plan for data syncing to be file transfers on/off the SD card initially with the eventual goal of also backing up over wifi to a personal server.

Scope

The scope of the project is “personal.” I do not intend to make and sell any devices nor do I plan on supporting the software an open source project. I will eventually share the code, but that’s it.

Bye!

Thanks for reading my project introduction. I hope to have an update for everyone either over the winter holidays or shortly after with information on how the calendaring and contact management are progressing.

Back to PDA Blog