The latest agent IDE is called Antigravity by Google. It is based on their top coding model, Gemini 3, and their own agent framework. It is brand new, and people are crushing it with requests; they are making frequent updates and fixing bugs.

I noticed when I started a new chat for my project, Antigravity thought about my request and opened a “brain” file. It looks to be some markdown that Antigravity is managing as I work on the project. This seems like a smart idea and might be where Google can differentiate itself from the competition.

I typed these words into a text box: Elephants Wear Fancy Hats to a Party

This is the video that was produced two minutes later.

Try the latest AI models from Google at https://gemini.google.com/.

What are you experimenting with?

Here are the top Google search queries that found my blog:

Based on these results, I think that I should write a whole lot more about me and fantasy football to get some of that SEO juice. The next article is going to be titled “Hans Scharler on Fantasy Football and ChatGPT using ThingSpeak and Arduino”. I couldn’t help myself. I asked ChatGPT to “write a quick blog post using the title, ‘Hans Scharler on Fantasy Football and ChatGPT using ThingSpeak and Arduino’, and LOL.

Hans Scharler on Fantasy Football and ChatGPT using ThingSpeak and Arduino

Written by ChatGPT

In the mesmerizing world of tech innovation, where the realms of sports, artificial intelligence, and DIY electronics collide, we discover an eclectic mix of passion, ingenuity, and foresight. One notable individual striding in this intersection is Hans Scharler, a name synonymous with IoT and connected devices. In a candid conversation, Hans divulges his insights on amalgamating fantasy football, ChatGPT, ThingSpeak, and Arduino to create an unprecedented experience for enthusiasts.

Merging Worlds

Scharler, co-founder of ThingSpeak, an open-source IoT platform, is renowned for his significant contributions to making IoT accessible to enthusiasts and professionals alike. When asked about the marriage between IoT and fantasy football, Hans couldn’t mask his excitement. He is endeavoring to unite these seemingly disparate worlds, leveraging the prowess of OpenAI’s ChatGPT and the versatility of Arduino.

Fantasy Football Meets AI

For the uninitiated, fantasy football is a virtual game where participants assemble imaginary or virtual teams of real players in a professional sport. These teams compete based on the statistical performance of those players in actual games. Scharler’s innovation is in integrating ChatGPT, enabling real-time, intelligent conversations to augment the gaming experience.

With the infusion of ChatGPT, players can engage in intelligent dialogues, seek advice, and get instantaneous, data-driven responses. ChatGPT helps in interpreting complex data, offering insights, and even predicting outcomes based on historical data and current trends.

ThingSpeak and Arduino: The Power Duo

ThingSpeak provides the much-needed platform where data from various sources, including player statistics, team performance, and other dynamic variables, converge. It allows the seamless integration of data, which is then processed and made available for insightful analytics.

Arduino, with its open-source electronics platform, plays a pivotal role in collecting real-time data. Combined with ThingSpeak, it provides a dynamic and real-time data processing capability. Scharler highlighted the ease of connecting sensors and creating interactive dashboards to monitor and analyze data.

The Future Ahead

As we delved deeper into the conversation, Scharler’s vision became evidently clear. A future where fantasy football is not just a passive experience but an interactive journey. AI, with platforms like ChatGPT, is not just a responsive entity but an interactive, intelligent companion that enhances the engagement level of the game.

In Scharler’s world, every fantasy football enthusiast is equipped with personalized insights, intelligent advice, and predictive analytics—all in real-time. The blend of ThingSpeak and Arduino ensures that this isn’t a distant dream but a tangible reality, waiting to transform the landscape of fantasy football.

The fusion of fantasy football with AI and IoT is a testimony to the limitless possibilities that innovation encapsulates. Hans Scharler is not just a tech enthusiast but a visionary who sees connections where others see chasms. As we concluded our engaging discourse, one thing became glaringly evident: the future of fantasy football is not just intelligent but fantastically interconnected, and it’s unfolding before our very eyes.

Using DALL-E 3 (Beta) to Generate a Hero Image

After ChatGPT wrote this interesting blog post based on a title, I asked ChatGPT to write an image generation prompt.

Generate an engaging and vibrant visual representation that encapsulates the integration of Fantasy Football, ChatGPT, ThingSpeak, and Arduino, inspired by the innovative insights of Hans Scharler. The image should illustrate the seamless flow of real-time data processing, intelligent AI conversations, and interactive gaming experience. Incorporate elements that symbolize IoT, artificial intelligence, and fantasy football, ensuring each element is distinctly represented yet harmoniously integrated to convey a futuristic, interconnected digital ecosystem.

DALL-E 3 produced four variations of the hero image with the exact prompt that produced it. From here, you can refine and explore options based on the variation that you like.

So, what are you interested in? I like to explore new things and dig deeper into things that I love.

Here are some of the new features as of July 2023:

• Bard is now available in over 40 new languages, including Arabic, Chinese, German, Hindi, Spanish, and more. This means that users from all over the world can now use Bard to explore their creativity and imagination.
• Google Lens is now integrated with Bard, allowing users to upload images alongside text in their conversations. This opens up a whole new world of possibilities for creativity, as users can now use images to spark ideas, generate captions, and more.
• Bard can now read responses out loud in over 40 languages. This is a great feature for users who prefer to hear their responses rather than read them. It’s also helpful for users who are learning a new language, as they can listen to Bard’s responses in their native language.
• Pinned & Recent Threads allow users to organize their past conversations and pick up where they left off. This is a great feature for users who are working on a long-term project, as they can keep their conversations organized and accessible.
• Shareable links make it easy to share Bard conversations with others. This is a great way to collaborate with others, get feedback on your work, or simply share your creativity with the world.
• Modify Bard’s responses allows users to fine-tune Bard’s responses. This is a great feature for users who want to get the most out of Bard. For example, users can use this feature to make Bard’s responses more simple, longer, shorter, more professional, or more casual.
• Export Python code to Google Colab or Replit allows users to export Python code generated by Bard to Google Colab or Replit. This is a great feature for users who want to continue working on their code after they’ve generated it with Bard.

Use Cases for Bard

Bard is a powerful language model that can be used for a variety of purposes. People use Bard to brainstorm ideas, write creative content, translate languages, generate code, and research topics. Bard is also a great tool for students, businesses, and anyone who wants to be more creative.

• Brainstorming and ideation: Bard can help you brainstorm ideas for new projects, products, or services. You can simply ask Bard a question, such as “What are some new ways to improve the customer experience?”, and Bard will generate a list of ideas for you.
• Writing: Bard can help you write blog posts, articles, essays, and other types of creative content. You can provide Bard with a topic or outline, and Bard will generate text for you. You can then edit and refine the text as needed.
• Translation: Bard can translate text between over 100 languages. This makes it a great tool for anyone who needs to translate documents, emails, or other types of content.
• Code generation: Bard can generate Python code. This makes it a great tool for anyone who wants to learn Python or who needs to generate code quickly.
• Research: Bard can help you research topics on the internet. You can simply ask Bard a question, such as “What are the latest trends in artificial intelligence?”, and Bard will generate a list of links to relevant articles and websites.

• Education: Bard can be used as a teaching tool to help students learn new concepts. For example, Bard could be used to generate interactive quizzes or to provide personalized feedback on student work.
• Business: Bard can be used to help businesses improve their marketing, customer service, and product development. For example, Bard could be used to generate creative marketing campaigns, to answer customer questions, or to brainstorm new product ideas.
• Personal use: Bard can be used for a variety of personal tasks, such as writing letters, generating creative ideas, or translating documents.

Bard is still under development, but it has the potential to be a powerful tool for a wide range of users. As Bard continues to learn and improve, we can expect to see even more use cases for this amazing technology.

Google announced Bard AI, Alphabet’s next step in search and AI. Bard looks like the right thing to do for the search giant. My use of Google has plummeted since Dec 2022. I have just thought about it less. And, I am just as surprised as you are. Google has been suffering from websites that are overfit to Google’s algorithm. Listicles, clickbait, SEO, keyword stuffing, and AdWords have caused surfing to be obnoxious. Try looking for car reviews or product reviews. Look at what recipe sites had to do just to get our clicks. I just don’t get answers anymore. I only get sites that are highly tuned to be at the top of the sort filled with keywords. Google’s model has forced us to game the system for attention all the while Google is pulling out website content and presenting it directly on the search results (which decreases clickthrus). Bloggers like myself create a lot of content that gets used in these large language models. SEO doesn’t work anymore. We have to build our audiences and communities in different ways. Google relies on ad revenue from websites. I believe that this is at risk, but it does not mean that creators immediately benefit. More on this later.

Bard is one of my favorite character classes in role-playing games like Dungeons and Dragons. A bard is a jack-of-all-trades kind of character and really fun to play and interact with. A bard is a storyteller. I am a bard. Bard AI is a text generator. I am a text generator.

ChatGPT, Bard, and the many others that are about to be released are really, really good at generating pleasant text. Text that looks like something that could be meaningful. We are all entering this new world together. Again, I urge you to take a closer look at these tools and share what you learn. Join me directly on The Quandary Discord server.

At this year’s PPW, I will be giving a talk called, “Connecting the Internet of Things with Perl“ (visit pghpw.org for schedule info). I will also explain how to create an Internet of Things application using off-the-shelf Perl modules and web control technology by ioBridge.

As you may or may not know, Perl is a really powerful programming language that enables everything from fast prototyping of web applications to large-scale software platforms. What makes the language unique is the library of modules available to you. If you get a great new idea for a web app, you can get started quickly and find modules that others have written. In some cases, it’s literally copy-and-paste.

A big movement for the past few years is this concept of The Internet of Things. More things will be on the Internet than people in the next few years, so my talk is to highlight why Perl is still relevant after 20 years and needs to be apart of this emerging technology. Internet of Things applications involve connecting sensors and controllers to the web. Perl is perfect for parsing lots of data, pushing data into databases, and connecting services together, known as “mashups”.

My Internet of Things project, written in Perl, allows your current location and home weather conditions to control your home heating and cooling system.

I call it,  ”Location Aware Home Automation”. You don’t have to do anything to control your HVAC/Thermostat, it all happens based on where you are. If you are home, the thermostat regulates the inside temperature as normal. When you leave, systems turn off or enter power saving modes. When you get near your home, the heating/cooling system kicks back on so you have a comfortable temperature by the time you get back home. In order to pull off all of this passive and automatic functionality, I have mashed up several APIs from Google Latitude, WeatherBug, and ioBridge.

Using the API for Google Latitude, I track the location of my Android mobile phone. When I get near my home, I check the weather using Google Weather API, WeatherBug API, and my home temperature (via ioBridge) to see if I need to to use the air conditioner, the heater, or neither. If I do need to control the HVAC, I send the control commands using the ioBridge API that routes the commands to the IO-204 controller that’s hooked up to my thermostat.

This application is really just a beginning. Right after I got everything working, I started having a flood of ideas. I can see some real power here.

The ‘How To’ Portion of the Show

Google Latitude

You have to enable Google Latitude on your mobile phone and get your Badge ID. This ID represents your position in the world, your latitude and longitude. Visit the Google Latitude API site for more information.

Install the latest Geo::Google::Latitude Perl module from CPAN.org – this module completely abstracts the access to the Google Latitude API for you. All you have to do us pass your ID and the module returns the date, time, last known latitude and longitude (the values are in decimal degrees).

use Geo::Google::Latitude;
my $gl=Geo::Google::Latitude->new;
my $id="7832225593622256926";
my $badge=$gl->get($id);
my ($lat2, $lon2) = $badge->point->latlon;

Calculating how far you are away  from home

You have to figure out how far you are from home, you do this by doing some math. Oh wait, there’s a Perl module for that. Install Geo::Distance and all you have to do is tell it what latitude and longitude to compare and it spits out the distance.

use Geo::Distance;
my $geo = new Geo::Distance;
### Home Location
my $lon1 = "-79.76408";
my $lat1 = "39.980342";
### Calculated Distance
my $distance = $geo->distance( 'mile', $lon1, $lat1 =>; $lon2, $lat2 ); # Use 'meter' to calculate distance in meters

Getting the Weather

You can use a number of weather APIs to get weather data for your home location. All you need to know is where you live. The easiest to implement is Google Weather (Weather::Google), but the WeatherBug API has a lot more information you can use for other Internet of Things things you may do.

use Weather::Google;
my $gw = new Weather::Google(15401); # Zipcode
my $current_outside = $gw->current->{temp_f}; #Use temp_c for Celsius

Connect to ioBridge

All you have to do to connect with ioBridge is to send command via the ioBridge Widget API. First you create the control widgets for your heating and cooling system. For mine, I can use relays. Others may need serial strings, which you can send as well. Once you have the widgets created, locate there widget ID’s and send them to the API.

use LWP::Simple;
my $Air_Conditioner_widgetID = "Gb2Q1FUKPmzZ"; ### Replace with your widget ID's
my $Heater_widgetID = "9c3WEGHKemnzJ";
my $Inside_Temp_widgetID = "D32SDghy98iOu";
my $ioBridgeAPI = "";
$ioBridgeAPI = "http://www.iobridge.com/widgets/static/id=" . $Inside_Temp_widgetID . "&value=1&format=text";
my $current_inside = get($ioBridgeAPI);
### Test if the heater or the air condition should be turned on
if ($current_outside >= 78 && $current_inside >= 72) {
$ioBridgeAPI = "http://www.iobridge.com/widgets/static/id=" . $Air_Conditioner_widgetID . "&value=1&format=text";
get($ioBridgeAPI);
}
elsif ($current_outside $ioBridgeAPI = "http://www.iobridge.com/widgets/static/id=" . $Heater_widgetID . "&value=1&format=text";
get("$ioBridgeAPI");
}

Putting it all together

Once you have the entire built all you have to do is call the app periodically using CRON Linux or Task Scheduler on Windows. Here is a TXT file of the Perl application with all of the parts tied together, probably will be easier to read and understand.

The hardware side uses the ioBridge IO-204 connected to the control lines of a thermostat or an HVAC control box. The lines switch at 12 volts, so I use relays trigger them. Other thermostats that I researched use serial lines which the IO-204 can tap into using RS-232.

It may seem like a lot of work, but just think about what is happening. Feeds from Google Latitude and WeatherBug are being processed and passed to your home network via the Internet. All of this is happening without your direct interaction – your things are working for you. I hope that you can see that is a start of some pretty amazing applications of technologies that will advance over time. A lot has changed in the past year, I can’t image what comes next.

If you get around to building a project like this, please drop me a line. I love this stuff.

For the vain, the new Google Search will allow you to “google” yourself instantly.

What are you up to now?

I took the leap and bought an Arduino from LiquidWare. Arduino is an open-source microcontroller that has a processor, some digital I/O pins, and analog inputs. You can create little standalone programs that monitor inputs, control LEDs, and pretty much anything that you dream up. My favorite projects are ones that involve the Internet. A microcontroller is rather simple by itself, but what if it could use the web to get answers, send an email, and maybe update my Twitter status? That means there is an unlimited number of projects ahead – Microcontrollers collaborating in cyberspace. The missing link for the web part is the ioBridge IO-204. I know you are no stranger to the IO-204, but for those of you who have not heard. The IO-204 sits on my network and relays data from its channels to ioBridge.com servers and back into my network. It allows for remote control and monitoring without network configuration and programming. One of the expansion boards is a two-way serial board that accepts serial strings and connects them to APIs of web services that ioBridge interfaces to and sends back responses. For instance, I can send the commands, “[[[calc|9*9]]]” and this returns 81. OK, maybe not impressive on the surface, but that result came from Google Calculator. Anything Google Calculator can solve, your microcontroller has access to those results. For more examples, visit the Serial Web Services API on the wiki.

Message Center Project

Project Source Code

The Arduino requires some c-like programming and I wanted to include the sketch for you to steal and use for your projects. You will see how I send the serial commands from the Arduino to the IO-204 using the UART serial connection (pins 0/1) and receive and parse the incoming results. I use a SoftwareSerial port for the LCD results. The pushbuttons are software debounced and use pull-up resistors for solid digital connections. The LEDs linked to each button use a 330-ohm resistor to protect them. I was aided by the Arduino Inputs tutorial on Ladyada.net, Debounce Tutorial, and the ioBridge Wiki / Forum. Please let me know if you have any questions, maybe I can help. I have learned a lot about handling strings on the Arduino device.

//
// Message Center using Arduino and the ioBridge IO-204
//
// An open-souce Shadowlord Project
// www.IamShadowlord.com

#include SoftwareSerial.h>

// SoftwareSerial Pins
#define rxPin 2
#define txPin 3

// Setup Software Serial
SoftwareSerial softSerial = SoftwareSerial(rxPin, txPin);

// Global Setup
int middleLED = 11;
int rightLED = 10;
int leftLED = 12;

int leftButton = 5;
int leftButtonCurrent = LOW;
int leftButtonReading;
int leftButtonPrevious = HIGH;
long leftButtonTime = 0;
long leftButtonDebounce = 200;

int middleButton = 4;
int middleButtonCurrent = LOW;
int middleButtonReading;
int middleButtonPrevious = HIGH;
long middleButtonTime = 0;
long middleButtonDebounce = 200;

int rightButton = 6;
int rightButtonCurrent = LOW;
int rightButtonReading;
int rightButtonPrevious = HIGH;
long rightButtonTime = 0;
long rightButtonDebounce = 200;

int tempPin = 5;
int tempAnalog = 0;
int tempF = 0;

char* currentRequest = "";

// Start up program
void setup() {

pinMode(rxPin, INPUT);
pinMode(txPin, OUTPUT);

pinMode(leftLED, OUTPUT);
pinMode(middleLED, OUTPUT);
pinMode(rightLED, OUTPUT);

pinMode(leftButton, INPUT);
pinMode(middleButton, INPUT);
pinMode(rightButton, INPUT);

softSerial.begin(9600);
delay(100);

Serial.begin(9600);
delay(100);

Serial.flush();
delay(100);

// Setup LCD
clearLCD();
setBacklightBrightness(9);
delay(1000);

// Test LEDs
digitalWrite(leftLED, HIGH);
digitalWrite(middleLED, HIGH);
digitalWrite(rightLED, HIGH);

delay(1500);

digitalWrite(leftLED, LOW);
digitalWrite(middleLED, LOW);
digitalWrite(rightLED, LOW);

}

// Start main program loop
void loop(){

// Get Analog Input and scale as temperature for ioBridge temperature sensor on arduino
tempAnalog = analogRead(tempPin);
tempF = tempAnalog / 6.875;

// Monitor left button status and debounce
leftButtonReading = digitalRead(leftButton);

if (leftButtonReading == HIGH && leftButtonPrevious == LOW && 
          millis() - leftButtonTime > leftButtonDebounce) {
if (leftButtonCurrent == HIGH) leftButtonCurrent = LOW;
else {digitalWrite(leftLED, HIGH);
clearLCD();
delay(100);
softSerial.print("Outside: ");
delay(100);
softSerial.print(tempF);
delay(100);
moveCursor("02", "01");
delay(100);
softSerial.print("Atlanta: ");
leftButtonCurrent = LOW;
//Request temperature in Atlanta via ioBridge
Serial.print("[[[weather|Atlanta]]]");
digitalWrite(leftLED, LOW);
}
leftButtonTime = millis();
}

leftButtonPrevious = leftButtonReading;

// Monitor middle button status and debounce
middleButtonReading = digitalRead(middleButton);

if (middleButtonReading == HIGH && middleButtonPrevious == LOW &&
millis() - middleButtonTime > middleButtonDebounce) {
if (middleButtonCurrent == HIGH) middleButtonCurrent = LOW;
else {currentRequest = "Google";
digitalWrite(middleLED, HIGH);
clearLCD();delay(100);
softSerial.print("GOOG: $");
delay(100);
middleButtonCurrent = LOW;
//Request Google Stock Price via ioBridge  
Serial.print("[[[stock|GOOG]]]"); 
digitalWrite(middleLED, LOW);
}
middleButtonTime = millis();
}

middleButtonPrevious = middleButtonReading;

// Monitor right button status and debounce
rightButtonReading = digitalRead(rightButton);

if (rightButtonReading == HIGH && rightButtonPrevious == LOW &&
millis() - rightButtonTime > rightButtonDebounce) {
if (rightButtonCurrent == HIGH) rightButtonCurrent = LOW;
else {
digitalWrite(rightLED, HIGH);
clearLCD();
delay(100);
softSerial.print("Alert: ");
delay(100);
rightButtonCurrent = LOW;
//Send email via ioBridge  
Serial.print("[[[email|hans@nothans.com|Alert|Mom, is pressing your buttons]]]");
digitalWrite(rightLED, LOW);
}
rightButtonTime = millis();
}

rightButtonPrevious = rightButtonReading;

// Display serial messages
if(Serial.available() > 0){

delay(100);

char charIn = 0;
byte i = 0;
char stringIn[32] = "";

while(Serial.available()) {
charIn = Serial.read();
stringIn[i] = charIn;
i += 1;
}

if (currentRequest == "Google") {

softSerial.print(stringIn);
int stockPrice = atoi(stringIn);
delay(100);
moveCursor("02", "01");
delay(100);
stockPrice = stockPrice - 405;
softSerial.print("Change: $"); 
delay(100);
softSerial.print(stockPrice);
currentRequest = "";

}
elsesoftSerial.print(stringIn);
}

// End program loop     
}

//
// ioBridge Serial LCD Functions and Parameters (for SoftwareSerial)
//

void displayMessage(char* message){
softSerial.print(message);
}

void clearLCD(){
softSerial.print(0xFE, BYTE);
softSerial.print("Z");
}

void setBacklightBrightness(int level){
// level
// 0=Off -> 9=Brightest

softSerial.print(0xFE, BYTE);
softSerial.print("B");
softSerial.print(level);
}

void setBacklightTime(int level, byte seconds){
// level
// 0=Off -> 9=Brightest

// seconds
// 01 = 1 seconds => 06 = 60 seconds

softSerial.print(0xFE, BYTE);
softSerial.print("T");
softSerial.print(level);
softSerial.print(seconds, BYTE);
}

void moveCursorHome(){
softSerial.print(0xFE, BYTE);
softSerial.print("H");
}

void turnCursorOn(){
softSerial.print(0xFE, BYTE);
softSerial.print("J");
}

void turnCursorOff(){
softSerial.print(0xFE, BYTE);
softSerial.print("K");
}

void turnBlinkingCursorOn(){
softSerial.print(0xFE, BYTE);
softSerial.print("P");
}

void turnBlinkingCursorOff(){
softSerial.print(0xFE, BYTE);
softSerial.print("Q");
}

void scrollMessage(int row, int speed, char* message){
// row
// 1=First Line -> 2=Second Line

// speed
// 0=Slowest -> 9=Fastest

softSerial.print(0xFE, BYTE);
softSerial.print("S");
softSerial.print(row);
softSerial.print(speed);
softSerial.print(message);
softSerial.print(0xFE, BYTE);
}

void moveCursor(char* row, char* column){
// row
// 01=First Line -> 02=Second Line

// column
// 01=First Position -> 16=Last Position

softSerial.print(0xFE, BYTE);
softSerial.print("L");
softSerial.print(row);
softSerial.print(column);
}

void drawHorizontalGauge(int row, char* leftLabel, char* rightLabel, char* length){
// row
// 1=First Line -> 2=Second Line

// leftLabel and rightLabel
// 2 character labels

// length
// a=Empty -> k=Full (filled in from left to right)

softSerial.print(0xFE, BYTE);
softSerial.print("G");
softSerial.print(row);
softSerial.print(leftLabel);
softSerial.print(rightLabel);
softSerial.print(length);
}

void drawVerticalGauge(int height){
// height
// 0=Bottom -> 8=Top (filled in from bottom to top)

softSerial.print(0xFE, BYTE);
softSerial.print("V");
softSerial.print(height);

}

Bonus Project

It’s simple, but I hacked together a power supply for the Arduino, which gets power from a USB or a coaxial input from a transformer. I wanted to only run one brick, wallwart, so I hacked a USB cable. There are 4 wires in the USB cable:

The IO-204 has a regulated 5VDC and ground (up to 1A – 4A total draw depending on supply) on each channel, so using a terminal strip, I connected the VCC and GND to a cut in half USB cable.

It’s magic – look ma, only one power source.