The DevKit board is similar to other DevKitM boards, with two USB C ports, one for the CPU’s native USB, one for a USB/UART chip, and an RGB LED. Adafruit lists it for $10. Adafruit also has a preliminary datasheet for the H2 up, the first one I’ve seen.
No sign of it yet on the official Espressif AliExpress store or DigiKey. Mouser has listings for it but it’s currently “non-stocked” with a minimum order of 392 for the DevKitM-1.
Expect the first boards and modules to be “engineering samples” - they may still have bugs and problems which will be corrected in the final silicon that ships for use in products. These are good for initial development and prototyping, but you shouldn’t expect to go into production with these exact devices.
The current version of ESP-IDF 5 contains preliminary software support for the ESP32-H2. To build projects for it you’ll need to use the “--preview” option when you set the target:
1
idf.py --preview set-target esp32h2
While I’m sure that these platforms eventually support the ESP32-H2, they’re all currently built with versions of ESP-IDF older than the current 5.x releases. The 5.x releases had substantial breaking changes, so it will be more effort to support them (or back-port changes) than it would be to simply update between patch releases. I wouldn’t expect to see support for some time.
The ESP32-H2 is clearly targeted for building low cost, low power Thread and Zigbee sensors. Given Bluetooth support, you’ll be able to run Matter over Thread and commission the device. Or you could bring up a Zigbee device with it. You could even use the same hardware and just a different software stack for both Thread and Zigbee versions of the same device.
Note that without WiFi this CPU won’t be suitable as a standalone Thread Border Router - it would need an external WiFi or ethernet module to work as one.
You could also use the ESP32-H2 as a Zigbee or Thread modem for other processors. Unfortunately, Espressif has stated that they will not be supporting the ESP32-H series with their “AT firmware” that simplifies using their CPUs to add connectivity to other devices, so you’re on your own if you want to do this.
Once Arduino and Python support is available, the ESP32-H2 should provide an easy way for hobbyists to build Zigbee and Thread devices.
The first CPUs available will work properly but may have glitches and are likely to not be supported at the level of Espressif’s mature products (for instance, the initial ESP32-C6 CPUs don’t have the ADC calibrated). It will take some time before ESP-IDF has complete support for them, and longer before easier to use programming environments like Arduino, MicroPython and CircuitPython will support them.
]]>The ESP32-C6 is Espressif’s first CPU with WiFi 6 support and first available CPU with an 802.15.4 radio, supporting Zigbee and Thread as well as Bluetooth. It’s a single core, 32 bit 160MHz RISC-V CPU with the usual complement of I2C, SPI, UART and other GPIO functions. Think of it as an ESP32-C3 with updated radio support that allows Zigbee and Thread.
The ESP32-C6’s datasheet is available from Espressif.
I was able to buy two of the ESP32-C6 DevKitC-1 samples. These are slightly different from the expected final product. The biggest difference is a jumper on the board - J5 - which provides access to measure current draw by the hardware.
The DevKitC-1 board includes both native USB support (CDC/serial mode only), and a CP2102N USB/UART chip, both with USB-C connectors and both able to power the board.
I’ve seen folks confused by WiFi 6 support: the C6 supports WiFI 6 - 802.11ax - but only in the 2.4GHz band, so don’t expect 5GHz (or 6GHz) radio support or performance. The main thing you’ll get from 802.11ax is improved power usage and low power modes, which should help battery operated projects.
ESP-IDF 5.1 will include “initial support for the ESP32-C6 chip”. Unfortunately, it’s not available yet. At the time that I wrote this, ESP-IDF was still on version 5.0.
The master branch of ESP-IDF does have preliminary ESP32-C6 support in it. You can build C6 firmware today by using an up-to-date copy of the master branch and running
1
idf.py --preview set-target esp32c6
According to Espressif’s notes, ESP-IDF 5.1 will not support radio “coexistence”. On other ESP32 models, coexistence allows you to use Bluetooth, Wifi and ESP-NOW at the same time by parceling out time on the radio to each service. This isn’t currently supported on the ESP32-C6.
This means that although the C6 supports Thread and Zigbee, you won’t be using it to build a Thread Border Router or to act as a WiFi Zigbee hub at this time.
A Thread Border Router is a very limited IPv6 router that routes traffic between a Thread network and another Internet (IPv6) network. In order for it to operate, the border router must be able to use its Thread radio and another network interface simultaneously. ESP-IDF 5.1 does not currently support this. While it does include support for SPI ethernet devices, which potentially could allow an ethernet/Thread Border Router, it explicitly does not include Border Router support.
I’m sure that a future release of ESP-IDF will support coexistence; just don’t expect it to be working now.
Don’t expect Arduino support anytime soon. Arduino updates usually lag ESP-IDF releases by quite a bit. The latest Arduino core release, 2.0.6, is still based on ESP-IDF 4.4.3; moving to 5.x might be a larger undertaking than usual.
Add to that the fact that there are currently no Arduino-style software interfaces for Zigbee or Thread support, so when the Arduino core does initially support that ESP32-C6, it may yet include support for its new radio protocols.
From Espressif’s notes:
I was able to build and run the blink example in ESP-IDF.
I was also able to build and run the OpenThread CLI example, which was very encouraging. Although its README didn’t mention the C6, it built and ran without modification.
I was able to scan for Thread networks and see Nest Protect’s Thread network and the Thread network used by our Apple gear. Now if I could find a way to provision Thread devices to the Apple network I’d be even happier.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| PAN | MAC Address | Ch | dBm | LQI |
+------+------------------+----+-----+-----+
| 6152 | 18b43000002cXXXX | 23 | -53 | 0 | Nest Protect
| 6152 | 18b43000002cXXXX | 23 | -55 | 0 |
| 6152 | 18b43000002cXXXX | 23 | -69 | 0 |
| 6152 | 18b43000002cXXXX | 23 | -76 | 0 |
| 6152 | 18b43000002cXXXX | 23 | -53 | 0 |
| 6152 | 18b43000002bXXXX | 23 | -73 | 0 |
| 6152 | 18b43000002fXXXX | 23 | -56 | 0 |
| 6152 | 18b43000002cXXXX | 23 | -38 | 0 |
| a8f1 | 964a0d2c1a85YYYY | 25 | -47 | 0 |
| a8f1 | c67a880f96a7YYYY | 25 | -41 | 0 |
| a8f1 | 86efff4254ceYYYY | 25 | -60 | 0 |
| a8f1 | 76670b06a333YYYY | 25 | -45 | 0 |
| a8f1 | b6dce50debcbYYYY | 25 | -47 | 0 | Eve Energy
I was also able to build the Zigbee light example.
If you’re not prepared to build software using ESP-IDF without a lot of handholding and tutorials, you should not get an ESP32-C6 board at this time.
If you need to use the Arduino core, get ready to wait for a while for initial support, then wait longer for it to be stable, then wait longer for Arduino-style interfaces to Thread and Zigbee.
You should also not get them if you need radio coexistence, deep or light sleep, or calibrated ADC to work at this time. I’m sure these are all coming but there’s not an established timeframe for them yet.
If you need to get a leg up on Thread or Zigbee development in an ESP32 context, then you can do that today with these chips and the live version of ESP-IDF.
Be sure to use Espressif’s official store if you order through AliExpress. You may also be able to find samples at Adafruit.
]]>If you’re starting out, Adafruit and Sparkfun are good choices for finding sensors, microcontrollers, LEDs and other parts. They both invest in extensive tutorials, libraries and other software, and both make most of their hardware open source. Both also have excellent customer service. All this comes at a cost, and they may not be the best choices for customers who are very cost sensitive. They’re a good source for components like microcontrollers and breakout boards, and not as good for discrete parts like transistors, resistors and chips although they do carry some.
If you need less support, Digikey and Mouser are both high quality providers. Adafruit works closely with Digikey, and you can find some Adafruit and Sparkfun products on both sites. Both also offer a vast array of discrete parts, too.
Be careful when ordering from them that you’re getting the parts you need in the packages you need - it’s easy to accidentally order surface mount resistors when you need through hole resistors, or a bare CPU or sensor chip when you need a breakout or development board with the chip already soldered on it.
Finally, both businesses do a good job of maintaining accurate information in their listings but sometimes the photos or information may not exactly match the product - I’ve accidentally bought ESP32 breakout boards with external antenna connectors because I the photo didn’t show the connector and I forgot to double check the part. Always review the part number and data sheet before you order.
Digikey and Mouser offer quantity discounts on most of their stock.
Sometimes you don’t want to check several different companies for a component, or you want to find the best price for it. That’s a job for Octopart! Octopart is a search engine that reports on inventories of several different companies that specialize in selling electronics components.
If you need something soon, Amazon carries many Adafruit and Sparkfun boards, often at a sizable markup, as well as many clone boards and discrete components. Most are sold by 3rd party sellers.
Some sellers ship from China, which can take weeks, so be sure to double check where the shipment is coming from and how long it will take. And be extra careful to check reviews.
Very cost sensitive buyers may want to check out AliExpress. AliExpress is a marketplace - you’re not buying from AliExpress, you’re buying through it. They provide a directory of sellers and products, brokering sales and guaranteeing delivery and very basic quality.
There are many reputable vendors on AliExpress and I’ve had mostly good experiences, but occasionally you’ll find a vendor selling untested, broken parts. I had one order of BME680 temperature/humidity/pressure/VOC sensors which had the sensor chip soldered 180 degrees off from its correct orientation. Of course it didn’t work at all, but the seller hadn’t done even the most basic testing .
Many AliExpress vendors sell clone boards with cheaper or missing parts, as well. For instance, they may sell a clone breakout board with a sensor but skip the voltage regulator that makes it safe to use with 5V, or skip diodes or pull-up resistors. They may also sell microcontroller boards with different or cheaper serial chips than you expect. This is part of how you can get very low prices, but of course there’s still a cost for the low price.
You’ll also find vendors spamming keywords in product listings, like “nodemcu esp32 esp8266 raspberry pi Arduino” - what even is this product? This happens on Amazon and eBay as well. Just be careful to double and triple check what you’re actually ordering.
You’ll likely be fine if you order from AliExpress but if you’re just starting out and aren’t able to debug hardware or reflow a surface mount chip or figure out if a sensor works, they may not be the best source for you.
If you do order from AliExpress, try to stick with vendors that have made lots of sales and are well reviewed. This is a good plan for any vendor, but particularly in this case. Be prepared for it to take several weeks to a couple of months to receive your order. And when you receive your order, check it immediately to make sure you received the right things, and if you can, test them to make sure they actually work.
Good luck and happy component hunting!
]]>It has also, like much mature popular software, become complex and large and a magnet for security problems. The attack surface for Wordpress plus plugins is very large and keeping a site secure and operational requires ongoing attention and effort.
A static site, on the other hand, has no backend other than whatever is serving the files. Its attack surface is very small compared to that of a full fledged dynamic content management system like Wordpress. It’s also fast - all it has to do is serve pre-computed files. No database lookups, no plugins to run, no pages to process and assemble. And less machinery to maintain and monitor.
I decided to switch from Wordpress to Jekyll, a static site generator. Many Github-hosted websites use Jekyll. It’s well-supported, under active development, and is easy to maintain.
The first thing when moving to Jekyll is to choose a Jekyll theme. I browsed quite a few themes and landed on Minimal Mistakes. It looks nice, works well with a variety of screen sizes, and doesn’t feel overly heavy. I hope it will provide a good experience for readers as well as for me.
The next thing is to move content over from Wordpress. While Jekyll has a Wordpress importer, it doesn’t bring import images from Wordpress! I ended up using a Wordpress plugin, Jekyll Exporter. The downside is that the new site has a lot of orphaned image files wasting space. Not a big problem but it feels untidy.
After doing minimal design with Minimal Mistakes, I needed to clean up content a little, and then publish. And here we are.
While Jekyll and Minimal Mistakes support 3rd party comment systems like Discus, I’ve chosen not to enable comments for the updated site.
Comments, frankly, do not spark joy.
If you want to discuss something I posted, you can find me on social media.
I enjoy writing text in Ulysses on macOS.
While Ulysses and Jekyll both use Markdown for mark-up, the publishing process is not quite as one-click-slick as it was with Wordpress. When I have the time I’m going to try Ryan Daigle’s shortcut for iOS. Ulysses will automatically sync work to iOS so it will be easy to publish from there. If it works I’ll see about adapting it to macOS.
I still have some work to do on the site. I’d really rather focus on new content but these things will bug me until I deal with them:
Ultimately some older articles and photos are just going to stay as they are.
]]>tl;dr
Many listings on Amazon, AliExpress, eBay and in other places incorrectly state that the CCS811 is a Carbon Monoxide (CO) sensor. It is not. It reports eTVOC (equivalent Total Volatile Organic Compounds) and eCO2 (equivalent Carbon Dioxide). The CCS811 is not capable of measuring Carbon Monoxide and any listing or description of it that says it does is simply incorrect. It also doesn’t truly measure CO2, but that’s a story for another day.
I’ve been playing with the CCS811 in a project and have noticed that many places incorrectly call it a Carbon Monoxide - CO - sensor. It does not measure Carbon Monoxide and is not a Carbon Monoxide sensor. You can confirm this by reading its datasheet - which doesn’t mention carbon monoxide or CO even once.
It’s not even truly a carbon dioxide sensor, though it’s sold as one. Calling it a CO2 sensor is at least somewhat defensible (at least the datasheet describes it this way) but calling it a CO sensor is completely wrong. But that’s an issue for another time.
If you want to measure carbon monoxide, it’s important that you use something that actually measures real carbon monoxide, like an MQ-7. And if you find an interesting part in a product listing, always read its datasheet before ordering it or using it in a project, because product listings can be misleading to outright incorrect.
]]>I left sensor that I’d built for reporting my gas grill’s temperature sitting out, unprotected, by the grill. The board was a “butterball”, a
That might not be so bad except that the sensor was naked, not in a case.
Oops.
The next morning when I realized I’d done this, I retrieved the sensor. It wasn’t operating anymore - an LED on the CPU was still blinking, but its OLED display didn’t show anything, and it had stopped logging data. The board showed some corrosion and discoloration around some of the pins. (Spoiler: after it dried out - no rice required - the board ran okay although I imagine its lifespan will be shorter now than it would have been if it had stayed dry)
When I build boards like this the case is almost always an afterthought. I’m best at software, okay at hardware and I have little skill or patience for CAD software and case design. And usually it’s fine having some naked circuit boards sitting around doing things. Until they get rained on. Or short out against something metal. Or the cats find them.
The fun thing is, I can see a few details about how it failed.
First, the last data point it logged was at 2:40AM. It was quiet after that. I can’t say exactly what failed at 2:40AM. Could have been power, the CPU, the wifi module… could have been a software failure in a driver that crashed because a sensor it was talking to behaved in a weird, unexpected way.
At 2:37AM the ambient temperature sensor went haywire and started reporting -227 degrees. It was reading a mild 57°F prior to that. That was when the humidity sensor (on the same chip) jumped from 86% to 100%. I can’t tell whether that was because the chip failed or because the board was getting rained on.
Cases have some definite drawbacks:
On the other hand, they’re vital for protectingcircuitry from the environment around it (and potentially for protecting the environment from the board - we don’t need cats licking high voltage terminals).
At the least, going forward, I’ll make sure that projects are in some kind of temporary case, like a repurposed plastic food containers. If the container’s big enough, some holes poked in one side might work for airflow. It’s definitely worth experimenting with and learning about case design.
]]>tl;dr
The Plantower PMS3003/PMS5003 particle sensors usually come with an 8 wire cable with male plugs on each end. The cable needs a Molex 053261-0871 female connector, which has a 1.25mm pitch “PicoBlade” header. You can find it at Digikey, Mouser, eBay (but don’t, the prices on eBay were ridiculous last time I looked) and even Amazon.
The toughest thing about using it isn’t the software or hardware, it’s mechanical - I had a very difficult time finding a compatible connector. The sensor ships with a short 8 wire cable with two male ends. I ended up just cutting the wires in two and soldering them to a perfboard, but this is a less flexible and more permanent solution than I was happy with.
After reading many specs sheets and product listings I still couldn’t find the name of or specifications for the connector (thanks in advance to the folks who’ll read this and let me know that they found this info on the first try!). I finally found an Eagle project for a breakout board for the connector: Molex part number 053261-0871, a 1.25mm pitch, 8 pin “PicoBlade” header. Thank you, Akram Ali for designing the breakout boards and sharing them on Github!
https://github.com/AKstudios/PMSX003-Breakout
Adafruit offers the PMS5003 with a breadboard-compatible breakout board. If you’re looking to buy one or two PMS5003s, save yourself the hassle and just get them directly from Adafruit.
I did a small run of these OSH Park at $3.20 for 6 boards, shipped. I had them in about 2 weeks. I ordered the connector from Digikey at $1.56 each. Soldering was a bit tedious but with a magnifying lens, a fine soldering tip, 0.6mm solder and a steady hand, bright lighting and some patience, I was able to assemble them reliably.
]]>When I lived in New England, roasting my own coffee meant we could have delicious coffee at home (really good because it was freshly roasted, not because I have any magical coffee powers beyond being lucky enough to have a small coffee roaster). When I started roasting, freshly roasted coffee was a rarity.
Now that I live in Portland, good coffee is never more than a couple of blocks away. Coffee roasting is now a big yawn, but I enjoy roasting my own and still do it as much as I can. I roast outside because my roaster throws off a lot of smoke, so once the weather gets too wet or too cold I stop, but Portland’s winter is mild enough that there are usually still a few good days when I can get a few roasts in, even in January.
My formula for blending coffee is simple: 50% Sumatra and 50% other coffees, with a preference towards chocolate, caramel and malt flavors, and including some fruit, berry or citrus flavors.
I’m a lazy blender. I just mix the beans together and roast the blend. A better roaster would roast each type of bean separately, carefully paying attention to the roaster to listen for the beans cracking, to decide when to remove heat. If I did this the result would be a little bit better than it is now, but the extra work would leave me less interested in roasting.
I used to blend a few pounds of beans as needed, in a spare ten-pound bag. This time around I’m also getting lazier with the blending - I dug up a plastic tub I used to use for sous viding and just dumped all the beans in it and mixed them there. Now I’ll never not roast because I don’t feel like mixing the beans up.
I like Sumatra because it usually has a deep, dark, chocolate-ish flavor and frankly doesn’t have any notes of cat piss. Sumatra can be a little one-note, though; that’s why I blend. And while I love a cup of coffee that tastes like chocolate milk, I like a little complexity in the roast as well. Hence the blend.
This month my local green coffee shop, Mr. Green Beans, had a great sounding Timor next to the Sumatra.
“A surprisingly clean coffee from a very unique origin. Rich and thick with chocolate, carob and malt building a backdrop for cinnamon, black currant and peanut flavors in the finish. A smooth, no-bite coffee that will shine at medium to dark roasts and pair well with milk.”
That sounds fantastic! I usually buy 20 pounds of coffee to blend and gradually roast as needed, since green coffee beans store very well. So I picked up 10 pounds of this great-sounding coffee I’d never tried, reserved a little to roast on its own (spoiler warning: it’s as good as it sounds, almost like barely sweetened cocoa) and blended the rest.
So this month I’m doing my first non-Sumatra-based roast in ages, with the Timor as the foundation and five other coffees as contributors. I usually do a light to medium roast, so the overall flavors are:
Works for me.
The blend is 10% of each of the following coffees and 50% of the Timor.
“Classic Colombian coffee, and prime example of why they are so popular. Lighter roasts present flavors of caramel, sweet cacao and brown sugar with a graham nutiness and a touch fresh citrus. Darker roasts increase the smooth body and highlight dark chocolate and tamarind flavors.”
“A subtle twist on a classic Costa Rican flavor profile. Lighter roasts will highlight cane sugar, sweet grapefruit, butterscotch, almond and maple flavors. Darker roasts will transition to molasses and bakers chocolate flavors.”
“A delicious coffee that is as rich and interesting as the country that produced it. Lighter roasts present flavors of dark chocolate, hazelnuts, fresh tobacco and crisp juniper. Darker roasts will draw out the classic rich earthy and baker chocolate flavors.”
“A crowd favorite, especially for those that love the rich earthy coffees of Indonesia. Flavors of dark chocolate, fresh savory herbs, sweet oats and peat are present in lighter roasts. As the roast develops the earthy bakers chocolate flavors take over.”
“A deliciously chocolatey crowd pleaser. Lighter roasts present flavors of sweet milk chocolate, mild roasted nuts, caramel and cane sugar with a touch of sweet citrus. Flavors transition to dark chocolate and dark roasted nuts as roasts progress towards second crack.”
]]>This does nothing beyond build and run.
The setup()
function is used for one time, well, setup. This is where you initialize a sensor or connect to Wifi or set the speed of your serial port.
The loop()
function is where you do the work. This is intended for repetitive tasks, like reading from a sensor or uploading some information or blinking lights.
The Arduino SDK (including when it’s used on a non-Arduino chips like the ESP8266 and ESP32) is designed expecting loop()
to do a little work and then return. The loop()
function itself is called from an infinite loop.
Sometimes Arduino coders write things like:
This will completely fail on some processors. Notably the ESP8266 and the ESP32 both have “watchdog timers” which are used to help with stability. Watchdog timers are intended to catch when the software has gone into an infinite loop or otherwise failed. If they’re not reset periodically, they’ll restart the processor and your program will run over again from the beginning.
The watchdog timer is automatically reset when loop()
returns. When loop()
returns the underlying software also gets to perform certain housekeeping tasks, like handle serial I/O, perform any interrupt service it couldn’t do in the interrupt handler, and handle network protocol interactions if it has a networking stack and interface. You can also give up control from inside loop()
temporarily by calling yield()
or delay()
, and some other calls may also give the underlying software a chance to run.
So it’s vital that you don’t loop indefinitely inside loop()
. Instead, structure your code to be aware of the fact that loop will be called over and over again for you.
So instead of:
write:
People also often write:
This is fine as long as you’re not doing much inside loop()
. If you have a very simple application that only does one thing inside loop()
then calling delay()
this way is harmless.
Let’s suppose we’re doing something more. Imagine that we’re running on a wifi-enabled platform and we have a small web server. We’ll avoid details of how the web server works - there are plenty of tutorials out there and the details would be a distraction.
Now our loop()
looks something like this:
So we take a sensor reading, print it to the serial port, check if there’s a web request available and process it if there is, and then delay for ten seconds because we don’t want to output sensor readings too often.
See the problem?
This delays handling web requests for ten seconds as well.
That means you may wait ten seconds before the page can load. And if the page tries to load any other resources from your server (Javascript, CSS, data) they may each be delayed by 10 seconds as well.
Instead we can write loop()
like this:
Now we’re checking on web requests every run through loop()
but only handling sensor readings every second.
We can generalize this to let us handle several things with different timing needs all in the same loop just by keeping track of the time for each of them separately.
Using this structure instead of calling delay()
inside loop()
will let the handlers inside loop()
remain responsive while still reading the sensor only as often as it’s supposed to be read.
I ran across your public repository of Arduino code on Github today. It’s nicely written and does almost exactly what I need. I would like to have used it in a project. I would have forked it, added a little functionality and contributed that back in case you’d like to integrate the changes. I might also have called it “George”. This would have saved me some time and let me add a bit of functionality to it that others might find useful.
Unfortunately it had no license - none at all. And you don’t have any links to social media or list any contact info in your profile so I can’t easily reach you to ask about it.
No license is equivalent to “All Rights Reserved”. It turns out that about half of public repositories on Github have no license.
Without a license I don’t know if it’s okay for me to use the library in my open (or closed) source project. I don’t know if it’s okay for me to modify it and distribute my modifications. Without a license I have to assume that you intended that no one else use it for anything, despite the fact that you left it out in the open for everyone to see.
I totally get it if you’d rather that I didn’t try to contribute changes. I write a lot of code which I just want to use for a while and not be responsible for forever. If your code had a license permitting me to do so, I’d be happy to evolve it and share my changes with other people myself. Unfortunately it doesn’t have a license at all.
I like the MIT license, and I publish almost all of my code under it. It’s short and sweet:
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
This license says:
And that’s about it.
If that doesn’t suit you, there are many other licenses to choose from. Choose A License can help you find the license that works best for you.
And if you don’t want to license your code - or just choose a license - that’s certainly your right. It’s your code, your say. But if you’re thinking that just popping it up on Github without a license makes it open source and usable but the rest of the world, sadly, the defaults don’t work that way.
So please - choose a license - even if it’s “All Rights Reserved” - so that we can know whether it’s okay for us to use or improve your code.
Thanks Lupo!
]]>