This GitHub repo contains the code, raw data and methodology for an NPR investigation that aired March 9, 2022, on All Things Considered.

• NPR.org: “Nurses are waiting months for licenses as hospital staffing shortages spread”

Two member station reporters produced localized versions and participated in a reporter roundtable on Morning Edition on March 10, 2022:

• Jayme Lozano – Texas Tech Public Media (Lubbock, Texas)

• Brett Sholtis – WITF (Harrisburg, Pa.)

• GitHub Page displaying code & data visualization: https://austinfast.github.io/nursing-licenses/

On Sept. 23, 2021, NPR requested records for all licensed practical nurses and registered nurses who applied for licensure from 2019 to 2021 from 54 nursing boards, including every state and the District of Columbia. (California, Louisiana and West Virginia have separate RN and LPN boards.)

We asked for each nurse’s:

• name
• city
• state
• license type (RN or LPN)
• license duration (temporary or permanent)
• application type (by exam, exam-retest, endorsement, renewal, reinstatement, etc.)
• application status
• relevant dates (application submission, date when all required documents received, license issuance date and license expiration date).

California and Virginia provided anonymized records, citing the nurses’ privacy, and Connecticut and Virginia couldn’t provide details on application type.

States responded as follows:

Thirty-three boards granted NPR’s request:

• Arkansas
• California (provided anonymized records – charged $60.17)
• Colorado
• Connecticut
• Hawaii (only Feb. 2021 onward because of system migration)
• Illinois
• Indiana
• Iowa
• Kentucky
• Louisiana (LPN board only)
• Maine
• Massachusetts
• Michigan
• Minnesota
• Mississippi
• Montana
• Nebraska
• New Hampshire (redacted city/state)
• New Jersey
• New Mexico
• North Carolina (charged $875)
• Ohio
• Oklahoma
• Oregon
• Pennsylvania
• South Carolina
• Texas (only June 2020 onward because of system migration)
• Tennessee (charged $554)
• Vermont
• Virginia (provided anonymized records – charged $134)
• West Virginia (RN board only)
• Wyoming (RN board only)

Five boards provided partial data:

• Alabama provided unusable records
• Four boards provided processing time summaries that NPR could not independently verify:
  • Arizona
  • Idaho
  • Missouri
  • Nevada

Two boards did not respond to repeated requests for records:

• Kansas
• West Virginia (LPN board only)

Ten boards denied NPR’s request:

• Alaska: Told NPR they have no way to export application dates from their database.
• Delaware: “A public body in Delaware is not required to construct a record that does not previously exist for the purpose of fulfilling a FOIA request.”
• District of Columbia: Told NPR they have no way to export application dates from their database.
• Florida: Initially claimed no responsive records exist. When NPR pointed out annual reports advertise license processing times, the Florida Department of Health charged NPR $150, but has not provided any records to NPR as of March 10, 2022.
• New York: Withheld application dates as invasion of nurses’ privacy. NPR’s appeal was denied Jan. 10, 2022.
• Maryland: Quoted $213 to provide the records, but a recent system hack prevented the board from providing them.
• Rhode Island: “There are no currently existing records that are responsive to the request.”
• South Dakota: Told NPR they have no way to export application dates from their database.
• Utah: The board “is not required to compile, format, manipulate, package, summarize, or tailor information in order to fulfill a request.”
• Washington: “Per WAC 44-14-04003 (6) No duty to create records, we do not have anything containing the above highlighted information.”

Four boards wanted fees that NPR did not pay:

• Georgia ($434,178)
• Louisiana (RN board only-$1,754)
• North Dakota ($25)
• Wisconsin ($600)

Some boards use different terms for the same idea. For example, licensed practical nurses can also be called licensed vocational nurses, and states refer to licensed nurses applying in a new state as “endorsement” or “reciprocity.” NPR standardized these terms among the 32 states’ records and combined them into one dataset.

This is the primary R script used in this investigation.

The first states to respond to NPR’s request provided records through Sept. 23, 2021, so NPR removed all records after that date from subsequent states to standardize the timeframe. This resulted in a final dataset containing over 226,000 nurses issued new, permanent licenses in 2021.

NPR subtracted the application date from the license issue date to calculate each nurse’s processing time in days. We removed 77 nurses’ records showing an issue date earlier than their application date, apparently in error. NPR then grouped by state, license type and application type to find median processing times for each of the four major types and to count how many of the nurses’ processing times stretched longer than three months, six months, etc.

This Python code scrapes daily updates from the U.S. Department of Health and Human Services showing the number of hospitals reporting that they expect a critical staffing shortage within a week. Hospitals define critical staffing shortages based on their own needs and internal policies.

This R script charts the number of hospitals reporting that they expect a critical staffing shortage within a week.

Image and video processing from human perspectives are quite popular for artificial intelligence services like traffic inspection. Flask-ML grants any type of user (not only data scientist) an easy and compact UI Tool that supports BentoML to process images based on state-of-the-art machine learning approaches. It hides hardcore algorithm design and data preprocessing procedure into backend service which even annoys researchers a lot.

• Python 3.7
• pipenv install: pip3 install pipenv

# Clone the project
$ git clone https://github.com/MLH-Fellowship/Flask-ML.git

# Install
$ pipenv install

# Run Application
$ pipenv run python app.py

Open Localhost and try it out http://127.0.0.1:5000/

Many real-world applications like traffic inspection depend on instance-level segmentation and identification using our offline video processing model of Mask-RCNN.

As the backbone of instance-level object detection, image segmentation plays an important role to judge whether an algorithm works well for both accuracy and efficiency. It’s the process of dividing an image into different regions based on the characteristics of pixels to identify objects or boundaries to simplify an image and more efficiently analyze it. Segmentation impacts a number of domains, from the filmmaking industry to the field of medicine. For instance, the software behind green screens implements image segmentation to crop out the foreground and place it on a background for scenes that cannot be shot or would be dangerous to shoot in real life. Image segmentation is also used to track objects in a sequence of images and to classify terrains, like petroleum reserves, in satellite images. Some medical applications of segmentation include the identification of injured muscle, the measurement of bone and tissue, and the detection of suspicious structures to aid radiologists (Computer-Aided Diagnosis, or CAD).

BentoML is a framework for serving, managing, and deploying machine learning models, but it can only be used via Postman or CLI, and quite complicated for many users or developers. Hence, we want to solve this problem by implementing the abstract web application with the help of open-sourced projects like Python/ Flask and Jinja.

We’re a team of 3, who come in with different backgrounds and technical expertise. Hence, we picked 3 open-source projects to explore individually, and then, learn how to integrate them to solve the stated problem.

The project is built as a 2-tier architecture using Python/Flask, flask-caching, and Multi-threading for the backend and Bootstrap, Jinja, and Javascript for the client. Finally, we use BentoML as a core service to analyze the uploading images

Besides, after each completed our own individual task, we use Github Issue, PR, rebase, and squash to reduce merge conflict. We did a really good job as there are no merge conflicts at all.

• At first, we made a POST request to BentoML API, we encounter a similar problem in Javascript that BentoML’s analysis takes quite long to return the result and it causes an event blocking on the client-side. So we had to switch strategy and use Popen and multi-threadings to run multiple BentoML CLIs in Python, and it works.

• Another challenge was to implement flask caching because Flask caching does not have very good documentation like Redis Cache, so it took us a while to implement that feature, and display the result on the client with Jinja. Adding Flask Cache has reduced the number of API calls to our server and provide a faster result time.

Calvin Nguyen: Born and raised in Vietnam, move to San Jose State University, San Jose, California to pursue B.S. in Software Engineer

Noah Cardoza: Born in San Jose and raised between Egypt, Thailand, and Athens, graduated with an A.A. in Enterprise Security from De Anza College in Cupertino.

Yida Wang: Born in China and pursuing a Ph.D. degree in Technical University of Munich, Germany, focusing on computer vision and machine learning R&D

Calvin Nguyen:

• Built the backend APIs using Flask, and worked together on the integration among BentoML service, and the client-side.
• Implemented Flask-caching so when the user uploads the same image, it will return the result right away.
• He learns to build the backend services using Flask, to open/read a file using the filesystem.
• He also learns about BentoML, and how to use it. Especially, because Bento ML takes sometimes to analyze the data, he and Noah did pair programming to come up with a solution to integrate bentoML services with our main backend API using multi-threading.

Noah Cardoza:

• Did the initial project setup, configuring Pipenv with the base modules we’d need to get a start on the project.
• Built the UI using Bootstrap 4 with Jinja to template the pages required for the front end.
• Pair programmed with Calvin to integrate Flask with BentoML in a non-blocking event.
• Prototyped the results template using Jinja which Calvin later enhanced with a loading animation.

Yida Wang:

• Configured the BentoML
• Trained the segmentation model
• Saved the resulting output of the segmentation model into a folder from which we could display it to the user.

The vision of this project is for the user can upload many files or folders, but we didn’t have enough time to complete upload many files. Hence, we’re uploading and analyzing one file as a proof of concept.

There are many more things we want to add:

1. Allow user to upload a folder and return image segmentation for all uploaded images
2. Allow user to share images with others
3. Provide a textual explanation of what exactly is going on for users less versed in ML.

微信小程序开发助手 for VSCode，代码提示 + 语法高亮

• 打开 VSCode
• 拓展中心搜索 “小程序开发助手”
• 点击安装

• 支持 js，json，wxml 文件的代码提示
• wxml 文件语法高亮

Many thanks to Jetbrains for kindly providing a license for me to work on this and other open-source projects.

MIT

代码提示部分内容参考自拓展：ChandZhang/wechat-snippet-vscode

Enjoy!

A full featured Color picker Library for Android! Just like the one in Photoshop!

• Hue bar – Adjust hue using a slider
• Saturation & Value Box – Select the color from the Saturation & Value Box (like in Photoshop)
• Alpha bar – Adjust the alpha using a slider
• Preview – You can see the current selected and previously picked colors side-by-side
• Edit each component individually – You can edit Hue, Saturation, Value, Red, Green and Blue components individually
• Fully customizable – By default, there are two themes(Light and Dark). But you can define your own theme to customize the whole ColorPicker
• Easy to use – All the hardwork is done by us. Just a few lines of code is all you have to do

Tested with APIv11, but will most probably work with earlier versions as well.

The library is posted on jcenter. So, just the following code should be enough to get you started:

Place this in your app module’s build.gradle file:

    dependencies {
      compile 'com.azeesoft.lib.colorpicker:colorpicker:1.0.8@aar'
    }

If there is any error while building the project using the above mentioned step, add the following code in that build.gradle file and build again:

    repositories {
        maven {
            url 'https://dl.bintray.com/azeesoft/maven'
        }
    }

After successful build, you can use ColorPickerDialog as a part of your project.

1. Create a new ColorPickerDialog object using the static method createColorPickerDialog()

To create a default ColorPickerDialog with Light theme, use

        ColorPickerDialog colorPickerDialog= ColorPickerDialog.createColorPickerDialog(this);

To create a ColorPickerDialog with Dark theme, use

        ColorPickerDialog colorPickerDialog= ColorPickerDialog.createColorPickerDialog(this,ColorPickerDialog.DARK_THEME);

2. Set an OnColorPickedListener to call when the color is picked:

        colorPickerDialog.setOnColorPickedListener(new ColorPickerDialog.OnColorPickedListener() {
            @Override
            public void onColorPicked(int color, String hexVal) {
                //Your code here
            }
        });

3. Customize the colorPickerDialog if needed using appropriate methods and show the dialog:

        colorPickerDialog.setHexaDecimalTextColor(Color.parse("#ffffff")); //There are many functions like this
        colorPickerDialog.show();

4. To create a ColorPickerDialog with Custom theme, create a new style with any of the ColorPicker themes as parent and use the following attributes:

• cp_showOpacityBar (boolean) : Show/Hide Opacity Bar
• cp_showHexaDecimalValue (boolean) : Show/Hide Hexadecimal Value
• cp_showColorComponentsInfo (boolean) : Show/Hide Color components information(HSV, RGB, Alpha)
• cp_backgroundColor (color) : Background color for the dialog
• cp_hexaDecimalTextColor (color) : Text color for the Hexadecimal value
• cp_colorComponentsTextColor (color) : Text color for the Color components information(HSV, RGB, Alpha)
• cp_positiveActionTextColor (color) : Text color for the Positive Action
• cp_negativeActionTextColor (color) : Text color for the Negative Action
• cp_sliderThumbColor (color) : Color for the thumb of the slider of Hue bar and Opacity bar

Use any of the following as parent:

• ColorPicker
• ColorPicker.Dark
• ColorPicker.Light

For eg:

styles.xml:

    <style name="CustomColorPicker" parent="ColorPicker">
        <item name="cp_backgroundColor">#4745e5</item>
        <item name="cp_hexaDecimalTextColor">#000046</item>
        <item name="cp_colorComponentsTextColor">#fff</item>
        <item name="cp_positiveActionTextColor">@color/colorAccent</item>
        <item name="cp_negativeActionTextColor">@color/colorPrimaryDark</item>
        <item name="cp_sliderThumbColor">#accc</item>
    </style>

In Java:

    ColorPickerDialog colorPickerDialog = ColorPickerDialog.createColorPickerDialog(this,R.style.CustomColorPicker);
    colorPickerDialog.setOnColorPickedListener(new ColorPickerDialog.OnColorPickedListener() {
        @Override
        public void onColorPicked(int color, String hexVal) {
            System.out.println("Got color: " + color);
            System.out.println("Got color in hex form: " + hexVal);
            
            // Make use of the picked color here
        }
    });
    colorPickerDialog.show();

© 2017 Łukasz Lach

Bootstrap Magento 1.9 or 2.1 from scratch using Docker. Starts up 22 containers, all integrated together with Magento and supporting logging, monitoring, alerting and graphing.

This repository is meant to be a start for a fresh Magento project. After bootstrap is done, you can initialize git repository under www/ directory and proceed with your project.

Magento is installed using files from install/ directory that contains compressed source code for both versions, replace it with your file to use other.

Magento is pre-configured with following settings:

• session storage is using Memcached server
• cache and page-cache is using Redis server
• mail settings are pointing MailCatcher

Magento is installed on magento.local hostname for both versions supported. To access this hostname locally you will need to modify your /etc/hosts file so that localhost line looks like this:

127.0.0.1 localhost magento.local

Other containers are available on localhost, replace it with domain you will be running project on, if needed.

• http://localhost:6009/ – MailCatcher

• http://localhost:6008/ – Kibana

• http://localhost:6001/ – NodeExporter
• http://localhost:6002/ – cAdvisor
• http://localhost:6003/ – Prometheus
• http://localhost:6004/ – Grafana
• http://localhost:6005/ – AlertManager
• http://localhost:6006/ – Portainer
• http://localhost:6007/ – Sphinx Search webproc

• http://localhost:7070/ – GitLab

• http://magento.local:80/ – Magento frontend (Varnish -> nginx -> php7-fpm)
• http://magento.local:80/Magento/ – Magento 2.1 admin
• http://magento.local:80/admin/ – Magento 1.9 admin

To start a new project based on Magento 2.1 run:

git clone https://github.com/lukaszlach/magento-docker.git
cd magento-docker/
VERSION=2.1 make rebuild

To use the old 1.9 branch run:

git clone https://github.com/lukaszlach/magento-docker.git
cd magento-docker/
VERSION=1.9 make rebuild

These commands will install and pre-configure Magento instance. After all steps are done you should be able to access http://magento.local in your web browser, as well as all other containers listening on HTTP ports listed above.

Keep in mind to run rebuild once only when starting new project, otherwise all your data will be lost.

To stop all containers run:

make stop

To start existing project and all dependent containers run:

make start

• make php_cli – Bash for PHP container
• make varnish_cli
• make nginx_cli
• make sphinx_cli
• make mysql_cmd – MySQL command-line interface
• make sphinx_cmd – Sphinx command-line interface

There are several tools available inside php container, including:

• n98-magerun – for Magento 1.9
• n98-magerun2 – for Magento 2.1
• phpcpd – PHP Copy/Paste Detector
• pdepend – PHP Depend
• phpmd – PHP Mess Detector
• phpunit – PHPUnit
• phpcs – PHP_CodeSniffer
• composer
• modman
• phpdoc – phpDocumentor
• phploc – measure the size of a PHP project

To use tools, after running containers, execute either:

make php_cli
phploc /srv/www
n98-magerun2 sys:info # for Magento 2.1
n98-magerun sys:info # for Magento 1.9

or

docker exec php phploc /srv/www
docker exec php n98-magerun2 sys:info

• Magento admin

  • username: root
  • password: 1234abcd

• Grafana

  • username: admin
  • password: admin

• locale and currency must be set by editing proper assets/ script, this will be moved to variables when calling make rebuild

Copyright (c) 2017, Łukasz Lach
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

• https://github.com/kojiromike/docker-magento/tree/master/tools

The Mastering Backend Infrastructure pathway is a comprehensive learning journey designed to cultivate expertise in building robust backend systems. Spanning through databases, system design, web servers, and reverse proxies, this pathway caters to individuals aiming to transition from intermediate to advanced levels in web development and infrastructure design.

• Basic Programming Skills: Familiarity with Python, web frameworks (e.g., Django, FastAPI), and understanding of basic web development concepts (HTTP, RESTful APIs).

• Fundamental Database Knowledge: Basic understanding of SQL and NoSQL databases, including CRUD operations.

• Comprehensive Database Mastery: Delve into SQL and NoSQL databases, honing skills in data modeling, querying, and management with tools like PostgreSQL, MongoDB, and Redis.

• System Design Excellence: Understand the intricacies of scalable, distributed systems by studying load balancing, caching mechanisms, and asynchronous processing.

• Web Server Proficiency: Master the setup and configuration of web servers like Apache, Nginx, or Caddy, learning about handling HTTP requests, load balancing, and securing connections.

• Advanced Reverse Proxy Implementation: Explore the role of reverse proxies in routing, load balancing, and security, implementing advanced configurations for optimization and enhanced security.

• Strengthen your understanding of SQL and NoSQL databases, covering advanced querying, indexing, optimization techniques, and data modeling.

• Learn about designing scalable, distributed systems, focusing on load balancing, caching, and database scaling strategies.

• Understand the workings of web servers, HTTP handling, and configuration of load balancers and SSL/TLS setup.

• Explore advanced configurations for reverse proxies, implementing caching, rate limiting, and web application firewall setups.

• Online Platforms: Coursera, Youtube
• Documentation: PostgreSQL, MongoDB, Redis, Nginx, HAProxy, etc.

This pathway emphasizes practical application, encouraging learners to implement acquired knowledge in real-world scenarios, ultimately enabling them to design scalable, resilient, and secure backend infrastructures.

This module has been archived, it’s no longer maintained but you still can fork it if you need it for your shop.

Protect your business, get help to make it grow peacefully and keep an eye on risky orders.

You can report issues with this module in the main PrestaShop repository. Click here to report an issue.

PrestaShop modules are open source extensions to the PrestaShop e-commerce solution. Everyone is welcome and even encouraged to contribute with their own improvements.

Contributors must follow the following rules:

• Make your Pull Request on the “dev” branch, NOT the “master” branch.
• Do not update the module’s version number.
• Follow the coding standards.

Contributors wishing to edit a module’s files should follow the following process:

1. Create your GitHub account, if you do not have one already.
2. Fork this project to your GitHub account.
3. Clone your fork to your local machine in the /modules directory of your PrestaShop installation.
4. Create a branch in your local clone of the module for your changes.
5. Change the files in your branch. Be sure to follow the coding standards!
6. Push your changed branch to your fork in your GitHub account.
7. Create a pull request for your changes on the ‘dev’ branch of the module’s project. Be sure to follow the contribution guidelines in your pull request. If you need help to make a pull request, read the GitHub help page about creating pull requests.
8. Wait for one of the core developers either to include your change in the codebase, or to comment on possible improvements you should make to your code.

That’s it: you have contributed to this open source project! Congratulations!

This module is released under the Academic Free License 3.0

Max6675 is an Arduino library for MAX6675 chip with a K type thermocouple.

The library is based upon (stripped and adapted version of) the https://github.com/RobTillaart/MAX31855_RT library.

Currently the library is experimental, so use with care.

Hardware has finally arrived (April 2022) and I had time to do my first round of tests with an UNO at 16 MHz. The library works and it reads temperatures well, both with HW SPI and SW SPI.

The MAX6675 is a chip to convert the reading of a K-type thermocouple to a temperature. The MAX6675 only supports positive degrees Celsius.

The values are read with an precision of 0.25°C. Typical noise seen during usage are ± 0.5°C, so using a low pass filter on the temperature might be a good idea.

The working of thermocouples (TC) is based upon Seebeck effect. Different TC’s have a different Seebeck Coefficient (SC) expressed in µV/°C. See http://www.analog.com/library/analogDialogue/archives/44-10/thermocouple.html

The library is tested with a breakout board with following pins:

             +---------------------+
             |          signal out |  -->  MISO
             | -       chip select |  <--  SELECT
    TC here  |               clock |  <--  CLOCK    processor side
             | +               VCC |  ---  VCC
             |                 GND |  ---  GND
             +---------------------+

Version 0.3.0 introduced a breaking change to improve handling the SPI dependency. The user has to call SPI.begin() or equivalent before calling AD.begin(). Optionally the user can provide parameters to the SPI.begin(…)

The version 0.2.0 has breaking changes in the interface. The essence is removal of ESP32 specific code from the library. This makes it possible to support the ESP32-S3 and other processors in the future. Also it makes the library a bit simpler to maintain.

Note the order of the parameters of the software SPI constructor has changed in 0.2.0.

• https://github.com/RobTillaart/MAX6675
• https://github.com/RobTillaart/MAX31850
• https://github.com/RobTillaart/MAX31855_RT
• https://github.com/RobTillaart/Temperature conversion to (exotic) temperature scales.

Default pin connections.

Performance read() function, timing in us.

• UNO @ 16 MHz
• TODO ESP32 @ 240 MHz

Note the UNO micros() has a 4 us precision, but it is clear that 4 Mb is not even twice the speed of 0.5 Mb.
Tested with MAX6675_test_HWSPI.ino

#include "MAX6675.h"

• MAX6675(uint8_t select, SPIClassRP2040 * mySPI) hardware SPI R2040
• MAX6675(uint8_t select, SPIClass * mySPI) hardware SPI other
• MAX6675(uint8_t select, uint8_t miso, uint8_t clock) software SPI
• void begin() initialize internals

To be used only if one needs a specific speed.

• void setSPIspeed(uint32_t speed) set SPI transfer rate.
• uint32_t getSPIspeed() returns SPI transfer rate.
• void setSWSPIdelay(uint16_t del = 0) for tuning SW SPI signal quality. Del is the time in micros added per bit. Even numbers keep the duty cycle of the clock around 50%.
• uint16_t getSWSPIdelay() get set value in micros.

• uint8_t read() makes a temperature measurement. It returns the status of the read (0, 4 or 129)
• uint8_t getStatus() returns the last status value of read(). Will stay the same until a new read() call.
• float getTemperature() returns last temperature in Celsius. (will be obsolete in future).
• float getCelsius() returns last temperature in Celsius. (more explicit scale). Will stay the same until a new read() call.
• float getFahrenheit() wrapper around getCelsius(). Returns last temperature in Fahrenheit. Will stay the same until a new read() call.

Table: values returned from uint8_t read() and uint8_t getStatus()

Note: this list is a subset of MAX31855 errors.

After uint8_t read() returns STATUS_OK you can get the temperature with getCelsius() or getFahrenheit().

Repeated calls to getCelsius() or getFahrenheit() will give the same value until a new measurement is made by calling read().

Note: if the read() fails the value of getCelsius() can become incorrect. So it is important to check the return value of read().

The library supports a fixed offset to calibrate the thermocouple. For this the functions float getOffset() and void setOffset(float offset) are available. This offset is “added” in the getCelsius() function.

Note:

• the offset is a constant in degrees Celsius (for Fahrenheit offset multiply by 1.8)
• the offset used is a float, so decimals can be used. A typical usage is to call setOffset(273.15) to get degrees ° Kelvin.
• the offset can be positive or negative.
• the offset can cause negative temperatures to pop up at the lower end.

As the tc object holds its last known temperature it is easy to determine the delta with the last known temperature, e.g. for trend analysis.

  float last = tc.getCelsius();
  int state  = tc.read();
  if (state == STATUS_OK)
  {
    float new  = tc.getCelsius();
    float delta = new - last;
    // process data
  }

The tc object keeps track of the last time read() is called in the function uint32_t lastRead(). The time is tracked in millis(). This makes it easy to read the sensor at certain intervals.

if (millis() - tc.lastRead() >= interval)
{
  int state = tc.read();
  if (state == STATUS_OK)
  {
    float new = tc.getCelsius();
    // process read value.
  }
  else
  {
    // handle error
  }
}

The function uint32_t getRawData() allows you to get all the 32 bits raw data from the board, after the standard uint8_t tc.read() call.

Example code can be found in the examples folder.

  int state = thermocouple.read();              
  uint32_t value = thermocouple.getRawData();  // Read the raw Data value from the module

This allows one to compact the measurement e.g. for storage or sending over a network.

To have proper working of the MAX6675 board, you need to add a pull-up resistor (e.g. 4K7 – 1K depending on wire length) between the MISO pin (from constructor call) and the VCC (5 Volt). This improves the signal quality and will allow you to detect if there is proper communication with the board. Without pull-up one might get random noise that could look like real data.

Note: the MISO pin can be different from each board, please refer to your board datasheet.

If the MAX6675 board is not connected tc.read() will return STATUS_NO_COMMUNICATION.

You can verify this by tc.getRawData() which will give 16 HIGH bits or 0xFFFF).

You can use a simple code to detect connection error board:

  uint8_t status = thermocouple.read();
  if (status == STATUS_NO_COMMUNICATION)
  {
    Serial.println("NO COMMUNICATION");
  }

or

  uint8_t status = thermocouple.read();
  if (thermocouple.getRawData() == 0xFFFF)
  {
    Serial.println("NO COMMUNICATION");
  }

See examples

• update and verify documentation (as it is copied from MAX31855 lib)

• keep interface in sync with MAX31855 if possible.

• create example to distinguish between MAX6675 and MAX31855
  • #5

If you appreciate my libraries, you can support the development and maintenance. Improve the quality of the libraries by providing issues and Pull Requests, or donate through PayPal or GitHub sponsors.

Thank you,

Max6675 is an Arduino library for MAX6675 chip with a K type thermocouple.

The library is based upon (stripped and adapted version of) the https://github.com/RobTillaart/MAX31855_RT library.

Currently the library is experimental, so use with care.

Hardware has finally arrived (April 2022) and I had time to do my first round of tests with an UNO at 16 MHz. The library works and it reads temperatures well, both with HW SPI and SW SPI.

The MAX6675 is a chip to convert the reading of a K-type thermocouple to a temperature. The MAX6675 only supports positive degrees Celsius.

The values are read with an precision of 0.25°C. Typical noise seen during usage are ± 0.5°C, so using a low pass filter on the temperature might be a good idea.

The working of thermocouples (TC) is based upon Seebeck effect. Different TC’s have a different Seebeck Coefficient (SC) expressed in µV/°C. See http://www.analog.com/library/analogDialogue/archives/44-10/thermocouple.html

The library is tested with a breakout board with following pins:

             +---------------------+
             |          signal out |  -->  MISO
             | -       chip select |  <--  SELECT
    TC here  |               clock |  <--  CLOCK    processor side
             | +               VCC |  ---  VCC
             |                 GND |  ---  GND
             +---------------------+

Version 0.3.0 introduced a breaking change to improve handling the SPI dependency. The user has to call SPI.begin() or equivalent before calling AD.begin(). Optionally the user can provide parameters to the SPI.begin(…)

The version 0.2.0 has breaking changes in the interface. The essence is removal of ESP32 specific code from the library. This makes it possible to support the ESP32-S3 and other processors in the future. Also it makes the library a bit simpler to maintain.

Note the order of the parameters of the software SPI constructor has changed in 0.2.0.

• https://github.com/RobTillaart/MAX6675
• https://github.com/RobTillaart/MAX31850
• https://github.com/RobTillaart/MAX31855_RT
• https://github.com/RobTillaart/Temperature conversion to (exotic) temperature scales.

Default pin connections.

Performance read() function, timing in us.

• UNO @ 16 MHz
• TODO ESP32 @ 240 MHz

Note the UNO micros() has a 4 us precision, but it is clear that 4 Mb is not even twice the speed of 0.5 Mb.
Tested with MAX6675_test_HWSPI.ino

#include "MAX6675.h"

• MAX6675(uint8_t select, SPIClassRP2040 * mySPI) hardware SPI R2040
• MAX6675(uint8_t select, SPIClass * mySPI) hardware SPI other
• MAX6675(uint8_t select, uint8_t miso, uint8_t clock) software SPI
• void begin() initialize internals

To be used only if one needs a specific speed.

• void setSPIspeed(uint32_t speed) set SPI transfer rate.
• uint32_t getSPIspeed() returns SPI transfer rate.
• void setSWSPIdelay(uint16_t del = 0) for tuning SW SPI signal quality. Del is the time in micros added per bit. Even numbers keep the duty cycle of the clock around 50%.
• uint16_t getSWSPIdelay() get set value in micros.

• uint8_t read() makes a temperature measurement. It returns the status of the read (0, 4 or 129)
• uint8_t getStatus() returns the last status value of read(). Will stay the same until a new read() call.
• float getTemperature() returns last temperature in Celsius. (will be obsolete in future).
• float getCelsius() returns last temperature in Celsius. (more explicit scale). Will stay the same until a new read() call.
• float getFahrenheit() wrapper around getCelsius(). Returns last temperature in Fahrenheit. Will stay the same until a new read() call.

Table: values returned from uint8_t read() and uint8_t getStatus()

Note: this list is a subset of MAX31855 errors.

After uint8_t read() returns STATUS_OK you can get the temperature with getCelsius() or getFahrenheit().

Repeated calls to getCelsius() or getFahrenheit() will give the same value until a new measurement is made by calling read().

Note: if the read() fails the value of getCelsius() can become incorrect. So it is important to check the return value of read().

The library supports a fixed offset to calibrate the thermocouple. For this the functions float getOffset() and void setOffset(float offset) are available. This offset is “added” in the getCelsius() function.

Note:

• the offset is a constant in degrees Celsius (for Fahrenheit offset multiply by 1.8)
• the offset used is a float, so decimals can be used. A typical usage is to call setOffset(273.15) to get degrees ° Kelvin.
• the offset can be positive or negative.
• the offset can cause negative temperatures to pop up at the lower end.

As the tc object holds its last known temperature it is easy to determine the delta with the last known temperature, e.g. for trend analysis.

  float last = tc.getCelsius();
  int state  = tc.read();
  if (state == STATUS_OK)
  {
    float new  = tc.getCelsius();
    float delta = new - last;
    // process data
  }

The tc object keeps track of the last time read() is called in the function uint32_t lastRead(). The time is tracked in millis(). This makes it easy to read the sensor at certain intervals.

if (millis() - tc.lastRead() >= interval)
{
  int state = tc.read();
  if (state == STATUS_OK)
  {
    float new = tc.getCelsius();
    // process read value.
  }
  else
  {
    // handle error
  }
}

The function uint32_t getRawData() allows you to get all the 32 bits raw data from the board, after the standard uint8_t tc.read() call.

Example code can be found in the examples folder.

  int state = thermocouple.read();              
  uint32_t value = thermocouple.getRawData();  // Read the raw Data value from the module

This allows one to compact the measurement e.g. for storage or sending over a network.

To have proper working of the MAX6675 board, you need to add a pull-up resistor (e.g. 4K7 – 1K depending on wire length) between the MISO pin (from constructor call) and the VCC (5 Volt). This improves the signal quality and will allow you to detect if there is proper communication with the board. Without pull-up one might get random noise that could look like real data.

Note: the MISO pin can be different from each board, please refer to your board datasheet.

If the MAX6675 board is not connected tc.read() will return STATUS_NO_COMMUNICATION.

You can verify this by tc.getRawData() which will give 16 HIGH bits or 0xFFFF).

You can use a simple code to detect connection error board:

  uint8_t status = thermocouple.read();
  if (status == STATUS_NO_COMMUNICATION)
  {
    Serial.println("NO COMMUNICATION");
  }

or

  uint8_t status = thermocouple.read();
  if (thermocouple.getRawData() == 0xFFFF)
  {
    Serial.println("NO COMMUNICATION");
  }

See examples

• update and verify documentation (as it is copied from MAX31855 lib)

• keep interface in sync with MAX31855 if possible.

• create example to distinguish between MAX6675 and MAX31855
  • #5

If you appreciate my libraries, you can support the development and maintenance. Improve the quality of the libraries by providing issues and Pull Requests, or donate through PayPal or GitHub sponsors.

Thank you,

In Perspective Transformation, we can change the perspective of a given image or video for getting better insights about the required information. In Perspective Transformation, we need provide the points on the image from which want to gather information by changing the perspective. We also need to provide the points inside which we want to display our image. Then, we get the perspective transform from the two given set of points and wrap it with the original image.

For perspective transformation, you need a 3×3 transformation matrix. Straight lines will remain straight even after the transformation. To find this transformation matrix, you need 4 points on the input image and corresponding points on the output image. Among these 4 points, 3 of them should not be collinear. Then transformation matrix can be found by the function cv2.getPerspectiveTransform. Then apply cv2.warpPerspective with this 3×3 transformation matrix.

Install requirements

pip install -r requirements.txt

Run this command and select four points on the image. In the order (TopLeft, TopRight, BottomLeft, BottomRight)

python calliberate.py --image calliberation_image.jpg 

The output will be a numpy .npy transformation matrix file. Which you can use for further development.

In this case i have used the above created matrix file to change the side tilted view of the camera into top(Birds eye) view. I used a person detection model to detect the person in the frame. The detections are in the form of rectangle co-ordinates (xmin,ymin, xmax, ymax). I selected the bottom coordinate of rectangle and transformed its view to top view to get a point representation of the person using the transformation matrix.

To run the example :

cd examples/movements/
python person_birds_eye.py 

In the above example the dots on black screen are the top view of people walking in the video. The flickering is because of the accuracy of the model that is used. This experiment was done using an ssd_mobilenet model. To use a model with higher accuracy in person detection task change this line.