├── .github ├── ISSUE_TEMPLATE │ ├── bug_report.md │ ├── custom.md │ └── feature_request.md └── workflows │ ├── stale.yml │ └── sync_issues.yml ├── .gitignore ├── CODE_OF_CONDUCT.md ├── CONTRIBUTING.md ├── LICENSE ├── README.md ├── examples ├── BasicReadings.py └── MaxRefreshRate.py ├── requirements.txt ├── seeed_mlx9064x.py └── setup.py /.github/ISSUE_TEMPLATE/bug_report.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Bug report 3 | about: Create a report to help us improve 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Describe the bug** 11 | A clear and concise description of what the bug is. 12 | 13 | **To Reproduce** 14 | Steps to reproduce the behavior: 15 | 1. Go to '...' 16 | 2. Click on '....' 17 | 3. Scroll down to '....' 18 | 4. See error 19 | 20 | **Expected behavior** 21 | A clear and concise description of what you expected to happen. 22 | 23 | **Screenshots** 24 | If applicable, add screenshots to help explain your problem. 25 | 26 | **Desktop (please complete the following information):** 27 | - OS: [e.g. iOS] 28 | - Browser [e.g. chrome, safari] 29 | - Version [e.g. 22] 30 | 31 | **Smartphone (please complete the following information):** 32 | - Device: [e.g. iPhone6] 33 | - OS: [e.g. iOS8.1] 34 | - Browser [e.g. stock browser, safari] 35 | - Version [e.g. 22] 36 | 37 | **Additional context** 38 | Add any other context about the problem here. 39 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/custom.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Custom issue template 3 | about: Describe this issue template's purpose here. 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | 11 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/feature_request.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Feature request 3 | about: Suggest an idea for this project 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | **Is your feature request related to a problem? Please describe.** 11 | A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] 12 | 13 | **Describe the solution you'd like** 14 | A clear and concise description of what you want to happen. 15 | 16 | **Describe alternatives you've considered** 17 | A clear and concise description of any alternative solutions or features you've considered. 18 | 19 | **Additional context** 20 | Add any other context or screenshots about the feature request here. 21 | -------------------------------------------------------------------------------- /.github/workflows/stale.yml: -------------------------------------------------------------------------------- 1 | name: 'Close stale issues and PRs' 2 | 3 | on: 4 | workflow_dispatch: 5 | schedule: 6 | - cron: '0 4 * * *' 7 | 8 | jobs: 9 | stale: 10 | runs-on: ubuntu-latest 11 | 12 | steps: 13 | - name: Checkout repository 14 | uses: actions/checkout@v4 15 | 16 | - name: Checkout script repository 17 | uses: actions/checkout@v4 18 | with: 19 | repository: Seeed-Studio/sync-github-all-issues 20 | path: ci 21 | 22 | - name: Run script 23 | run: ./ci/tools/stale.sh 24 | env: 25 | GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} 26 | -------------------------------------------------------------------------------- /.github/workflows/sync_issues.yml: -------------------------------------------------------------------------------- 1 | name: Automate Issue Management 2 | 3 | on: 4 | issues: 5 | types: 6 | - opened 7 | - edited 8 | - assigned 9 | - unassigned 10 | - labeled 11 | - unlabeled 12 | - reopened 13 | 14 | jobs: 15 | add_issue_to_project: 16 | runs-on: ubuntu-latest 17 | steps: 18 | - name: Add issue to GitHub Project 19 | uses: actions/add-to-project@v1.0.2 20 | with: 21 | project-url: https://github.com/orgs/Seeed-Studio/projects/17 22 | github-token: ${{ secrets.ISSUE_ASSEMBLE }} 23 | labeled: bug 24 | label-operator: NOT -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | ################# 2 | ## Eclipse 3 | ################# 4 | 5 | *.pydevproject 6 | .project 7 | .metadata 8 | bin/ 9 | tmp/ 10 | *.tmp 11 | *.bak 12 | *.swp 13 | *~.nib 14 | local.properties 15 | .classpath 16 | .settings/ 17 | .loadpath 18 | 19 | # External tool builders 20 | .externalToolBuilders/ 21 | 22 | # Locally stored "Eclipse launch configurations" 23 | *.launch 24 | 25 | # CDT-specific 26 | .cproject 27 | 28 | # PDT-specific 29 | .buildpath 30 | 31 | 32 | ################# 33 | ## Visual Studio 34 | ################# 35 | 36 | ## Ignore Visual Studio temporary files, build results, and 37 | ## files generated by popular Visual Studio add-ons. 38 | 39 | # User-specific files 40 | *.suo 41 | *.user 42 | *.sln.docstates 43 | 44 | # Build results 45 | 46 | [Dd]ebug/ 47 | [Rr]elease/ 48 | x64/ 49 | build/ 50 | [Bb]in/ 51 | [Oo]bj/ 52 | 53 | # MSTest test Results 54 | [Tt]est[Rr]esult*/ 55 | [Bb]uild[Ll]og.* 56 | 57 | *_i.c 58 | *_p.c 59 | *.ilk 60 | *.meta 61 | *.obj 62 | *.pch 63 | *.pdb 64 | *.pgc 65 | *.pgd 66 | *.rsp 67 | *.sbr 68 | *.tlb 69 | *.tli 70 | *.tlh 71 | *.tmp 72 | *.tmp_proj 73 | *.log 74 | *.vspscc 75 | *.vssscc 76 | .builds 77 | *.pidb 78 | *.log 79 | *.scc 80 | 81 | # Visual C++ cache files 82 | ipch/ 83 | *.aps 84 | *.ncb 85 | *.opensdf 86 | *.sdf 87 | *.cachefile 88 | 89 | # Visual Studio profiler 90 | *.psess 91 | *.vsp 92 | *.vspx 93 | 94 | # Guidance Automation Toolkit 95 | *.gpState 96 | 97 | # ReSharper is a .NET coding add-in 98 | _ReSharper*/ 99 | *.[Rr]e[Ss]harper 100 | 101 | # TeamCity is a build add-in 102 | _TeamCity* 103 | 104 | # DotCover is a Code Coverage Tool 105 | *.dotCover 106 | 107 | # NCrunch 108 | *.ncrunch* 109 | .*crunch*.local.xml 110 | 111 | # Installshield output folder 112 | [Ee]xpress/ 113 | 114 | # DocProject is a documentation generator add-in 115 | DocProject/buildhelp/ 116 | DocProject/Help/*.HxT 117 | DocProject/Help/*.HxC 118 | DocProject/Help/*.hhc 119 | DocProject/Help/*.hhk 120 | DocProject/Help/*.hhp 121 | DocProject/Help/Html2 122 | DocProject/Help/html 123 | 124 | # Click-Once directory 125 | publish/ 126 | 127 | # Publish Web Output 128 | *.Publish.xml 129 | *.pubxml 130 | 131 | # NuGet Packages Directory 132 | ## TODO: If you have NuGet Package Restore enabled, uncomment the next line 133 | #packages/ 134 | 135 | # Windows Azure Build Output 136 | csx 137 | *.build.csdef 138 | 139 | # Windows Store app package directory 140 | AppPackages/ 141 | 142 | # Others 143 | sql/ 144 | *.Cache 145 | ClientBin/ 146 | [Ss]tyle[Cc]op.* 147 | ~$* 148 | *~ 149 | *.dbmdl 150 | *.[Pp]ublish.xml 151 | *.pfx 152 | *.publishsettings 153 | 154 | # RIA/Silverlight projects 155 | Generated_Code/ 156 | 157 | # Backup & report files from converting an old project file to a newer 158 | # Visual Studio version. Backup files are not needed, because we have git ;-) 159 | _UpgradeReport_Files/ 160 | Backup*/ 161 | UpgradeLog*.XML 162 | UpgradeLog*.htm 163 | 164 | # SQL Server files 165 | App_Data/*.mdf 166 | App_Data/*.ldf 167 | 168 | ############# 169 | ## Windows detritus 170 | ############# 171 | 172 | # Windows image file caches 173 | Thumbs.db 174 | ehthumbs.db 175 | 176 | # Folder config file 177 | Desktop.ini 178 | 179 | # Recycle Bin used on file shares 180 | $RECYCLE.BIN/ 181 | 182 | # Mac crap 183 | .DS_Store 184 | 185 | 186 | ############# 187 | ## Python 188 | ############# 189 | 190 | *.py[co] 191 | 192 | # Packages 193 | *.egg 194 | *.egg-info 195 | dist/ 196 | build/ 197 | eggs/ 198 | parts/ 199 | var/ 200 | sdist/ 201 | develop-eggs/ 202 | .installed.cfg 203 | 204 | # Installer logs 205 | pip-log.txt 206 | 207 | # Unit test / coverage reports 208 | .coverage 209 | .tox 210 | 211 | #Translations 212 | *.mo 213 | 214 | #Mr Developer 215 | .mr.developer.cfg -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Contributor Covenant Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | In the interest of fostering an open and welcoming environment, we as 6 | contributors and maintainers pledge to making participation in our project and 7 | our community a harassment-free experience for everyone, regardless of age, body 8 | size, disability, ethnicity, sex characteristics, gender identity and expression, 9 | level of experience, education, socio-economic status, nationality, personal 10 | appearance, race, religion, or sexual identity and orientation. 11 | 12 | ## Our Standards 13 | 14 | Examples of behavior that contributes to creating a positive environment 15 | include: 16 | 17 | * Using welcoming and inclusive language 18 | * Being respectful of differing viewpoints and experiences 19 | * Gracefully accepting constructive criticism 20 | * Focusing on what is best for the community 21 | * Showing empathy towards other community members 22 | 23 | Examples of unacceptable behavior by participants include: 24 | 25 | * The use of sexualized language or imagery and unwelcome sexual attention or 26 | advances 27 | * Trolling, insulting/derogatory comments, and personal or political attacks 28 | * Public or private harassment 29 | * Publishing others' private information, such as a physical or electronic 30 | address, without explicit permission 31 | * Other conduct which could reasonably be considered inappropriate in a 32 | professional setting 33 | 34 | ## Our Responsibilities 35 | 36 | Project maintainers are responsible for clarifying the standards of acceptable 37 | behavior and are expected to take appropriate and fair corrective action in 38 | response to any instances of unacceptable behavior. 39 | 40 | Project maintainers have the right and responsibility to remove, edit, or 41 | reject comments, commits, code, wiki edits, issues, and other contributions 42 | that are not aligned to this Code of Conduct, or to ban temporarily or 43 | permanently any contributor for other behaviors that they deem inappropriate, 44 | threatening, offensive, or harmful. 45 | 46 | ## Scope 47 | 48 | This Code of Conduct applies both within project spaces and in public spaces 49 | when an individual is representing the project or its community. Examples of 50 | representing a project or community include using an official project e-mail 51 | address, posting via an official social media account, or acting as an appointed 52 | representative at an online or offline event. Representation of a project may be 53 | further defined and clarified by project maintainers. 54 | 55 | ## Enforcement 56 | 57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be 58 | reported by contacting the project team at zuobaozhu@gmail.com. All 59 | complaints will be reviewed and investigated and will result in a response that 60 | is deemed necessary and appropriate to the circumstances. The project team is 61 | obligated to maintain confidentiality with regard to the reporter of an incident. 62 | Further details of specific enforcement policies may be posted separately. 63 | 64 | Project maintainers who do not follow or enforce the Code of Conduct in good 65 | faith may face temporary or permanent repercussions as determined by other 66 | members of the project's leadership. 67 | 68 | ## Attribution 69 | 70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, 71 | available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html 72 | 73 | [homepage]: https://www.contributor-covenant.org 74 | 75 | For answers to common questions about this code of conduct, see 76 | https://www.contributor-covenant.org/faq 77 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | ## Contributing guidelines 2 | 3 | All guidelines for contributing to the Seeed_Python_MLX9064x repository can be found at [`How to contribute guideline`](https://github.com/Seeed-Studio/Seeed_Python_MLX9064x/wiki/How_to_contribute). 4 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 hansonCc 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # seeed MLX9064x 2 | 3 | The MLX9064x is a fully calibrated 32x24(12 x 16) pixels IR array in an industry standard 4-lead TO39 package with digital interface The MLX90640 contains 768 FIR pixels and The MLX90641 contains 192 FIR pixels. An ambient sensor is integrated to measure the ambient temperature of the chip and supply sensor to measure the VDD. The outputs of all sensors IR, Ta and VDD are stored in internal RAM and are accessible through I2C. 4 | 5 | # Dependencies 6 | 7 | This driver depends on: 8 | 9 | - [***grove.py***](https://github.com/Seeed-Studio/grove.py) 10 | 11 | This is easy to install with the following command. 12 | 13 | ``` 14 | pip3 install Seeed-grove.py 15 | ``` 16 | 17 | ## Installing from PyPI 18 | 19 | On supported GNU/Linux systems like the Raspberry Pi, you can install the driver locally from PyPI. To install for current user: 20 | 21 | ``` 22 | pip3 install seeed-python-mlx9064x 23 | ``` 24 | 25 | To install system-wide (this may be required in some cases): 26 | 27 | ``` 28 | sudo pip3 install seeed-python-mlx9064x 29 | ``` 30 | 31 | if you want to update the driver locally from PyPI. you can use: 32 | 33 | ``` 34 | pip3 install --upgrade seeed-python-mlx9064x 35 | ``` 36 | 37 | ## Usage Notes 38 | 39 | First, Check the corresponding i2c number of the board: 40 | 41 | ``` 42 | pi@raspberrypi:~ $ ls /dev/i2c* 43 | /dev/i2c-1 44 | ``` 45 | 46 | Check if the i2c device works properly， 0x33 is the MLX9064x i2c address. 47 | 48 | ``` 49 | pi@raspberrypi:~/Seeed_Python_SGP30 $ i2cdetect -y -r 1 50 | 0 1 2 3 4 5 6 7 8 9 a b c d e f 51 | 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 52 | 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 53 | 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 54 | 30: -- -- -- 33 -- -- -- -- -- -- -- -- -- -- -- -- 55 | 40: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 56 | 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 57 | 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 58 | 70: -- -- -- -- -- -- -- -- 59 | ``` 60 | 61 | ## initialize the sersor object: 62 | 63 | Initialize the sersor object and config the sersor refresh rate. 64 | 65 | ```python 66 | import seeed_mlx9064x 67 | mlx = seeed_mlx9064x.grove_mxl90640() 68 | #mlx = seeed_mlx9064x.grove_mxl90641() 69 | mlx.refresh_rate = seeed_mlx9064x.RefreshRate.REFRESH_8_HZ # The fastest for raspberry 4 70 | # REFRESH_0_5_HZ = 0b000 # 0.5Hz 71 | # REFRESH_1_HZ = 0b001 # 1Hz 72 | # REFRESH_2_HZ = 0b010 # 2Hz 73 | # REFRESH_4_HZ = 0b011 # 4Hz 74 | # REFRESH_8_HZ = 0b100 # 8Hz 75 | # REFRESH_16_HZ = 0b101 # 16Hz 76 | # REFRESH_32_HZ = 0b110 # 32Hz 77 | # REFRESH_64_HZ = 0b111 # 64Hz 78 | ``` 79 | 80 | ## Reading from the Sensor 81 | 82 | To read from the sensor: 83 | 84 | ```python 85 | try: 86 | 87 | frame = [0]*768 88 | #frame = [0]*192 89 | mlx.getFrame(frame) 90 | except ValueError: 91 | continue 92 | ``` 93 | 94 | maybe you can add content that below to the config.txt to get the fastest rate recommended for compatibility 95 | 96 | ```bash 97 | dtparam=i2c_arm=on,i2c_arm_baudrate=400000 98 | ``` 99 | 100 | This will give you a framerate of - at most - 8FPS. 101 | 102 | ## Contributing 103 | 104 | If you have any good suggestions or comments, you can send issues or PR us. 105 | -------------------------------------------------------------------------------- /examples/BasicReadings.py: -------------------------------------------------------------------------------- 1 | import seeed_mlx9064x 2 | import time 3 | CHIP_TYPE = 'MLX90640' 4 | def main(): 5 | if CHIP_TYPE == 'MLX90641': 6 | mlx = seeed_mlx9064x.grove_mxl90641() 7 | frame = [0] * 192 8 | elif CHIP_TYPE == 'MLX90640': 9 | mlx = seeed_mlx9064x.grove_mxl90640() 10 | frame = [0] * 768 11 | time.sleep(1) 12 | while True: 13 | start = time.time() 14 | try: 15 | mlx.getFrame(frame) 16 | except ValueError: 17 | continue 18 | print(frame) 19 | end = time.time() 20 | print("The time: %f"%(end - start)) 21 | if __name__ == '__main__': 22 | main() 23 | -------------------------------------------------------------------------------- /examples/MaxRefreshRate.py: -------------------------------------------------------------------------------- 1 | import seeed_mlx9064x 2 | import time 3 | CHIP_TYPE = 'MLX90641' 4 | def main(): 5 | if CHIP_TYPE == 'MLX90641': 6 | mlx = seeed_mlx9064x.grove_mxl90641() 7 | frame = [0] * 192 8 | elif CHIP_TYPE == 'MLX90640': 9 | mlx = seeed_mlx9064x.grove_mxl90640() 10 | frame = [0] * 768 11 | mlx.refresh_rate = seeed_mlx9064x.RefreshRate.REFRESH_8_HZ # The fastest for raspberry 4 12 | time.sleep(1) 13 | while True: 14 | start = time.time() 15 | mlx.getFrame(frame) 16 | print(frame) 17 | end = time.time() 18 | print("The time: %f"%(end - start)) 19 | if __name__ == '__main__': 20 | main() -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | mlx90640 -------------------------------------------------------------------------------- /seeed_mlx9064x.py: -------------------------------------------------------------------------------- 1 | import struct 2 | import math 3 | import time 4 | from grove.i2c import Bus 5 | 6 | # This relies on the driver written by siddacious and can be found at: 7 | # https://github.com/adafruit/Adafruit_CircuitPython_MLX90640 8 | 9 | eeData = [0] * 832 10 | I2C_READ_LEN = 2048 11 | SCALEALPHA = 0.000001 12 | MLX90640_DEVICEID1 = 0x2407 13 | OPENAIR_TA_SHIFT = 12 14 | 15 | class RefreshRate: 16 | """ Enum-like class for MLX90640's refresh rate """ 17 | REFRESH_0_5_HZ = 0b000 # 0.5Hz 18 | REFRESH_1_HZ = 0b001 # 1Hz 19 | REFRESH_2_HZ = 0b010 # 2Hz 20 | REFRESH_4_HZ = 0b011 # 4Hz 21 | REFRESH_8_HZ = 0b100 # 8Hz 22 | REFRESH_16_HZ = 0b101 # 16Hz 23 | REFRESH_32_HZ = 0b110 # 32Hz 24 | REFRESH_64_HZ = 0b111 # 64Hz 25 | class MLX9064X_I2C_Driver: 26 | def __init__(self,address): 27 | self.bus = Bus() 28 | self.addr = address 29 | 30 | def I2CWriteWord(self, writeAddress, data): 31 | write = self.bus.msg.write(self.addr,[writeAddress>>8,writeAddress&0xFF,data>>8,data&0xFF]) 32 | try: 33 | self.bus.i2c_rdwr(write) 34 | except OSError: 35 | print("Error:Please check if the I2C device insert in I2C of Base Hat") 36 | exit(1) 37 | 38 | def I2CReadWords(self, addr, buffer, *, end=None): 39 | if end is None: 40 | remainingWords = len(buffer) 41 | else: 42 | remainingWords = end 43 | write = self.bus.msg.write(self.addr,[addr>>8,addr&0xFF]) 44 | read = self.bus.msg.read(self.addr,2*remainingWords) 45 | try: 46 | self.bus.i2c_rdwr(write, read) 47 | except OSError: 48 | print("Error:Please check if the I2C device insert in I2C of Base Hat") 49 | exit(1) 50 | result = list(read) 51 | for i in range(remainingWords*2): 52 | if i % 2 != 0: 53 | buffer[(i-1)//2] = (result[i-1]<<8)|result[i]&0xff 54 | 55 | class grove_mxl90640(MLX9064X_I2C_Driver): 56 | """Interface to the MLX90640 temperature sensor.""" 57 | kVdd = 0 58 | vdd25 = 0 59 | KvPTAT = 0 60 | KtPTAT = 0 61 | vPTAT25 = 0 62 | alphaPTAT = 0 63 | gainEE = 0 64 | tgc = 0 65 | KsTa = 0 66 | resolutionEE = 0 67 | calibrationModeEE = 0 68 | ksTo = [0] * 5 69 | ct = [0] * 5 70 | alpha = [0] * 768 71 | alphaScale = 0 72 | offset = [0] * 768 73 | kta = [0] * 768 74 | ktaScale = 0 75 | kv = [0] * 768 76 | kvScale = 0 77 | cpAlpha = [0] * 2 78 | cpOffset = [0] * 2 79 | ilChessC = [0] * 3 80 | brokenPixels = [0xFFFF] * 5 81 | outlierPixels = [0xFFFF] * 5 82 | cpKta = 0 83 | cpKv = 0 84 | 85 | def __init__(self,address=0x33): 86 | super(grove_mxl90640, self).__init__(address) 87 | self.refresh_rate = RefreshRate.REFRESH_0_5_HZ 88 | self.I2CReadWords(0x2400, eeData) 89 | # print(eeData) 90 | self._ExtractParameters() 91 | 92 | @property 93 | def serial_number(self): 94 | """ 3-item tuple of hex values that are unique to each MLX90640 """ 95 | serialWords = [0, 0, 0] 96 | self.I2CReadWords(MLX90640_DEVICEID1, serialWords) 97 | return serialWords 98 | 99 | @property 100 | def refresh_rate(self): 101 | """ How fast the MLX90640 will spit out data. Start at lowest speed in 102 | RefreshRate and then slowly increase I2C clock rate and rate until you 103 | max out. The sensor does not like it if the I2C host cannot 'keep up'!""" 104 | controlRegister = [0] 105 | self.I2CReadWords(0x800D, controlRegister) 106 | return (controlRegister[0] >> 7) & 0x07 107 | 108 | @refresh_rate.setter 109 | def refresh_rate(self, rate): 110 | controlRegister = [0] 111 | value = (rate & 0x7) << 7 112 | self.I2CReadWords(0x800D, controlRegister) 113 | value |= controlRegister[0] & 0xFC7F 114 | self.I2CWriteWord(0x800d, value) 115 | 116 | def getFrame(self, framebuf): 117 | """ Request both 'halves' of a frame from the sensor, merge them 118 | and calculate the temperature in C for each of 32x24 pixels. Placed 119 | into the 768-element array passed in! """ 120 | emissivity = 0.95 121 | tr = 23.15 122 | mlx90640Frame = [0] * 834 123 | 124 | for _ in range(2): 125 | status = self._GetFrameData(mlx90640Frame) 126 | if status < 0: 127 | raise RuntimeError("Frame data error") 128 | # For a MLX90640 in the open air the shift is -8 degC. 129 | tr = self._GetTa(mlx90640Frame) - OPENAIR_TA_SHIFT 130 | self._CalculateTo(mlx90640Frame, emissivity, tr, framebuf) 131 | 132 | def _GetFrameData(self, frameData): 133 | dataReady = 0 134 | cnt = 0 135 | statusRegister = [0] 136 | controlRegister = [0] 137 | 138 | while dataReady == 0: 139 | self.I2CReadWords(0x8000, statusRegister) 140 | dataReady = statusRegister[0] & 0x0008 141 | # print("ready status: 0x%x" % dataReady) 142 | 143 | while (dataReady != 0) and (cnt < 5): 144 | self.I2CWriteWord(0x8000, 0x0030) 145 | #print("Read frame", cnt) 146 | self.I2CReadWords(0x0400, frameData, end=832) 147 | 148 | self.I2CReadWords(0x8000, statusRegister) 149 | dataReady = statusRegister[0] & 0x0008 150 | #print("frame ready: 0x%x" % dataReady) 151 | cnt += 1 152 | 153 | if cnt > 4: 154 | raise RuntimeError("Too many retries") 155 | 156 | self.I2CReadWords(0x800D, controlRegister) 157 | frameData[832] = controlRegister[0] 158 | frameData[833] = statusRegister[0] & 0x0001 159 | return frameData[833] 160 | 161 | def _GetTa(self, frameData): 162 | vdd = self._GetVdd(frameData) 163 | 164 | ptat = frameData[800] 165 | if ptat > 32767: 166 | ptat -= 65536 167 | 168 | ptatArt = frameData[768] 169 | if ptatArt > 32767: 170 | ptatArt -= 65536 171 | ptatArt = (ptat / (ptat * self.alphaPTAT + ptatArt)) * math.pow(2, 18) 172 | 173 | ta = (ptatArt / (1 + self.KvPTAT * (vdd - 3.3)) - self.vPTAT25) 174 | ta = ta / self.KtPTAT + 25 175 | return ta 176 | 177 | def _GetVdd(self, frameData): 178 | vdd = frameData[810] 179 | if vdd > 32767: 180 | vdd -= 65536 181 | 182 | resolutionRAM = (frameData[832] & 0x0C00) >> 10 183 | resolutionCorrection = math.pow(2, self.resolutionEE) / math.pow(2, resolutionRAM) 184 | vdd = (resolutionCorrection * vdd - self.vdd25) / self.kVdd + 3.3 185 | 186 | return vdd 187 | 188 | def _CalculateTo(self, frameData, emissivity, tr, result): 189 | # pylint: disable=too-many-locals, too-many-branches, too-many-statements 190 | subPage = frameData[833] 191 | alphaCorrR = [0] * 4 192 | irDataCP = [0, 0] 193 | 194 | vdd = self._GetVdd(frameData) 195 | ta = self._GetTa(frameData) 196 | 197 | ta4 = (ta + 273.15) 198 | ta4 = ta4 * ta4 199 | ta4 = ta4 * ta4 200 | tr4 = (tr + 273.15) 201 | tr4 = tr4 * tr4 202 | tr4 = tr4 * tr4 203 | taTr = tr4 - (tr4-ta4)/emissivity 204 | 205 | ktaScale = math.pow(2, self.ktaScale) 206 | kvScale = math.pow(2, self.kvScale) 207 | alphaScale = math.pow(2, self.alphaScale) 208 | 209 | alphaCorrR[0] = 1 / (1 +self.ksTo[0] * 40) 210 | alphaCorrR[1] = 1 211 | alphaCorrR[2] = (1 + self.ksTo[1] * self.ct[2]) 212 | alphaCorrR[3] = alphaCorrR[2] * (1 + self.ksTo[2] * (self.ct[3] - self.ct[2])) 213 | 214 | #--------- Gain calculation ----------------------------------- 215 | gain = frameData[778] 216 | if gain > 32767: 217 | gain -= 65536 218 | gain = self.gainEE / gain 219 | 220 | #--------- To calculation ------------------------------------- 221 | mode = (frameData[832] & 0x1000) >> 5 222 | 223 | irDataCP[0] = frameData[776] 224 | irDataCP[1] = frameData[808] 225 | for i in range(2): 226 | if irDataCP[i] > 32767: 227 | irDataCP[i] -= 65536 228 | irDataCP[i] *= gain 229 | 230 | irDataCP[0] -= self.cpOffset[0]*(1 + self.cpKta*(ta - 25)) * (1 + self.cpKv*(vdd - 3.3)) 231 | if mode == self.calibrationModeEE: 232 | irDataCP[1] -= (self.cpOffset[1] * 233 | (1 + self.cpKta * (ta - 25)) * 234 | (1 + self.cpKv * (vdd - 3.3))) 235 | else: 236 | irDataCP[1] -= ((self.cpOffset[1] + self.ilChessC[0]) * 237 | (1 + self.cpKta * (ta - 25)) * 238 | (1 + self.cpKv * (vdd - 3.3))) 239 | 240 | for pixelNumber in range(768): 241 | ilPattern = pixelNumber // 32 - (pixelNumber // 64) * 2 242 | chessPattern = ilPattern ^ (pixelNumber - (pixelNumber//2)*2) 243 | conversionPattern = ((pixelNumber + 2) // 4 - 244 | (pixelNumber + 3) // 4 + 245 | (pixelNumber + 1) // 4 - 246 | pixelNumber // 4) * (1 - 2 * ilPattern) 247 | 248 | if mode == 0: 249 | pattern = ilPattern 250 | else: 251 | pattern = chessPattern 252 | 253 | if pattern == frameData[833]: 254 | irData = frameData[pixelNumber] 255 | if irData > 32767: 256 | irData -= 65536 257 | irData *= gain 258 | 259 | kta = self.kta[pixelNumber]/ktaScale 260 | kv = self.kv[pixelNumber]/kvScale 261 | irData -= (self.offset[pixelNumber] * 262 | (1 + kta*(ta - 25)) * 263 | (1 + kv*(vdd - 3.3))) 264 | 265 | if mode != self.calibrationModeEE: 266 | irData += (self.ilChessC[2] * (2 * ilPattern - 1) - 267 | self.ilChessC[1] * conversionPattern) 268 | 269 | irData = irData - self.tgc * irDataCP[subPage] 270 | irData /= emissivity 271 | 272 | alphaCompensated = SCALEALPHA * alphaScale/self.alpha[pixelNumber] 273 | alphaCompensated *= (1 + self.KsTa * (ta - 25)) 274 | 275 | Sx = (alphaCompensated * alphaCompensated * 276 | alphaCompensated * (irData + alphaCompensated * taTr)) 277 | try: 278 | Sx = math.sqrt(math.sqrt(Sx)) * self.ksTo[1] 279 | except ValueError: 280 | result[pixelNumber] = "nan" 281 | continue 282 | 283 | To = math.sqrt(math.sqrt(irData/(alphaCompensated * 284 | (1 - self.ksTo[1] * 273.15) + Sx) + taTr)) - 273.15 285 | 286 | if To < self.ct[1]: 287 | torange = 0 288 | elif To < self.ct[2]: 289 | torange = 1 290 | elif To < self.ct[3]: 291 | torange = 2 292 | else: 293 | torange = 3 294 | 295 | To = math.sqrt(math.sqrt(irData / 296 | (alphaCompensated * alphaCorrR[torange] * 297 | (1 + self.ksTo[torange] * 298 | (To - self.ct[torange]))) + taTr)) - 273.15 299 | 300 | result[pixelNumber] = To 301 | # pylint: enable=too-many-locals, too-many-branches, too-many-statements 302 | 303 | 304 | def _ExtractParameters(self): 305 | self._ExtractVDDParameters() 306 | self._ExtractPTATParameters() 307 | self._ExtractGainParameters() 308 | self._ExtractTgcParameters() 309 | self._ExtractResolutionParameters() 310 | self._ExtractKsTaParameters() 311 | self._ExtractKsToParameters() 312 | self._ExtractCPParameters() 313 | self._ExtractAlphaParameters() 314 | self._ExtractOffsetParameters() 315 | self._ExtractKtaPixelParameters() 316 | self._ExtractKvPixelParameters() 317 | self._ExtractCILCParameters() 318 | self._ExtractDeviatingPixels() 319 | 320 | # debug output 321 | # print('-'*40) 322 | # print("kVdd = %d, vdd25 = %d" % (self.kVdd, self.vdd25)) 323 | # print("KvPTAT = %f, KtPTAT = %f, vPTAT25 = %d, alphaPTAT = %f" % 324 | # (self.KvPTAT, self.KtPTAT, self.vPTAT25, self.alphaPTAT)) 325 | # print("Gain = %d, Tgc = %f, Resolution = %d" % (self.gainEE, self.tgc, self.resolutionEE)) 326 | # print("KsTa = %f, ksTo = %s, ct = %s" % (self.KsTa, self.ksTo, self.ct)) 327 | # print("cpAlpha:", self.cpAlpha, "cpOffset:", self.cpOffset) 328 | # print("alpha: ", self.alpha) 329 | # print("alphascale: ", self.alphaScale) 330 | # print("offset: ", self.offset) 331 | # print("kta:", self.kta) 332 | # print("ktaScale:", self.ktaScale) 333 | # print("kv:", self.kv) 334 | # print("kvScale:", self.kvScale) 335 | # print("calibrationModeEE:", self.calibrationModeEE) 336 | # print("ilChessC:", self.ilChessC) 337 | # print('-'*40) 338 | 339 | def _ExtractVDDParameters(self): 340 | # extract VDD 341 | self.kVdd = (eeData[51] & 0xFF00) >> 8 342 | if self.kVdd > 127: 343 | self.kVdd -= 256 # convert to signed 344 | self.kVdd *= 32 345 | self.vdd25 = eeData[51] & 0x00FF 346 | self.vdd25 = ((self.vdd25 - 256) << 5) - 8192 347 | 348 | def _ExtractPTATParameters(self): 349 | # extract PTAT 350 | self.KvPTAT = (eeData[50] & 0xFC00) >> 10 351 | if self.KvPTAT > 31: 352 | self.KvPTAT -= 64 353 | self.KvPTAT /= 4096 354 | self.KtPTAT = eeData[50] & 0x03FF 355 | if self.KtPTAT > 511: 356 | self.KtPTAT -= 1024 357 | self.KtPTAT /= 8 358 | self.vPTAT25 = eeData[49] 359 | self.alphaPTAT = (eeData[16] & 0xF000) / math.pow(2, 14) + 8 360 | 361 | def _ExtractGainParameters(self): 362 | # extract Gain 363 | self.gainEE = eeData[48] 364 | if self.gainEE > 32767: 365 | self.gainEE -= 65536 366 | 367 | def _ExtractTgcParameters(self): 368 | # extract Tgc 369 | self.tgc = eeData[60] & 0x00FF 370 | if self.tgc > 127: 371 | self.tgc -= 256 372 | self.tgc /= 32 373 | 374 | def _ExtractResolutionParameters(self): 375 | # extract resolution 376 | self.resolutionEE = (eeData[56] & 0x3000) >> 12 377 | 378 | def _ExtractKsTaParameters(self): 379 | # extract KsTa 380 | self.KsTa = (eeData[60] & 0xFF00) >> 8 381 | if self.KsTa > 127: 382 | self.KsTa -= 256 383 | self.KsTa /= 8192 384 | 385 | def _ExtractKsToParameters(self): 386 | # extract ksTo 387 | step = ((eeData[63] & 0x3000) >> 12) * 10 388 | self.ct[0] = -40 389 | self.ct[1] = 0 390 | self.ct[2] = (eeData[63] & 0x00F0) >> 4 391 | self.ct[3] = (eeData[63] & 0x0F00) >> 8 392 | self.ct[2] *= step 393 | self.ct[3] = self.ct[2] + self.ct[3]*step 394 | 395 | KsToScale = (eeData[63] & 0x000F) + 8 396 | KsToScale = 1 << KsToScale 397 | 398 | self.ksTo[0] = eeData[61] & 0x00FF 399 | self.ksTo[1] = (eeData[61] & 0xFF00) >> 8 400 | self.ksTo[2] = eeData[62] & 0x00FF 401 | self.ksTo[3] = (eeData[62] & 0xFF00) >> 8 402 | 403 | for i in range(4): 404 | if self.ksTo[i] > 127: 405 | self.ksTo[i] -= 256 406 | self.ksTo[i] /= KsToScale 407 | self.ksTo[4] = -0.0002 408 | 409 | def _ExtractCPParameters(self): 410 | # extract CP 411 | offsetSP = [0] * 2 412 | alphaSP = [0] * 2 413 | 414 | alphaScale = ((eeData[32] & 0xF000) >> 12) + 27 415 | 416 | offsetSP[0] = eeData[58] & 0x03FF 417 | if offsetSP[0] > 511: 418 | offsetSP[0] -= 1024 419 | 420 | offsetSP[1] = (eeData[58] & 0xFC00) >> 10 421 | if offsetSP[1] > 31: 422 | offsetSP[1] -= 64 423 | offsetSP[1] += offsetSP[0] 424 | 425 | alphaSP[0] = eeData[57] & 0x03FF 426 | if alphaSP[0] > 511: 427 | alphaSP[0] -= 1024 428 | alphaSP[0] /= math.pow(2, alphaScale) 429 | 430 | alphaSP[1] = (eeData[57] & 0xFC00) >> 10 431 | if alphaSP[1] > 31: 432 | alphaSP[1] -= 64 433 | alphaSP[1] = (1 + alphaSP[1]/128) * alphaSP[0] 434 | 435 | cpKta = eeData[59] & 0x00FF 436 | if cpKta > 127: 437 | cpKta -= 256 438 | ktaScale1 = ((eeData[56] & 0x00F0) >> 4) + 8 439 | self.cpKta = cpKta / math.pow(2, ktaScale1) 440 | 441 | cpKv = (eeData[59] & 0xFF00) >> 8 442 | if cpKv > 127: 443 | cpKv -= 256 444 | kvScale = (eeData[56] & 0x0F00) >> 8 445 | self.cpKv = cpKv / math.pow(2, kvScale) 446 | 447 | self.cpAlpha[0] = alphaSP[0] 448 | self.cpAlpha[1] = alphaSP[1] 449 | self.cpOffset[0] = offsetSP[0] 450 | self.cpOffset[1] = offsetSP[1] 451 | 452 | def _ExtractAlphaParameters(self): 453 | # extract alpha 454 | accRemScale = eeData[32] & 0x000F 455 | accColumnScale = (eeData[32] & 0x00F0) >> 4 456 | accRowScale = (eeData[32] & 0x0F00) >> 8 457 | alphaScale = ((eeData[32] & 0xF000) >> 12) + 30 458 | alphaRef = eeData[33] 459 | accRow = [0]*24 460 | accColumn = [0]*32 461 | alphaTemp = [0] * 768 462 | 463 | for i in range(6): 464 | p = i * 4 465 | accRow[p + 0] = (eeData[34 + i] & 0x000F) 466 | accRow[p + 1] = (eeData[34 + i] & 0x00F0) >> 4 467 | accRow[p + 2] = (eeData[34 + i] & 0x0F00) >> 8 468 | accRow[p + 3] = (eeData[34 + i] & 0xF000) >> 12 469 | 470 | for i in range(24): 471 | if accRow[i] > 7: 472 | accRow[i] -= 16 473 | 474 | for i in range(8): 475 | p = i * 4 476 | accColumn[p + 0] = (eeData[40 + i] & 0x000F) 477 | accColumn[p + 1] = (eeData[40 + i] & 0x00F0) >> 4 478 | accColumn[p + 2] = (eeData[40 + i] & 0x0F00) >> 8 479 | accColumn[p + 3] = (eeData[40 + i] & 0xF000) >> 12 480 | 481 | for i in range(32): 482 | if accColumn[i] > 7: 483 | accColumn[i] -= 16 484 | 485 | for i in range(24): 486 | for j in range(32): 487 | p = 32 * i + j 488 | alphaTemp[p] = (eeData[64 + p] & 0x03F0) >> 4 489 | if alphaTemp[p] > 31: 490 | alphaTemp[p] -= 64 491 | alphaTemp[p] *= 1 << accRemScale 492 | alphaTemp[p] += (alphaRef + (accRow[i] << accRowScale) + 493 | (accColumn[j] << accColumnScale)) 494 | alphaTemp[p] /= math.pow(2, alphaScale) 495 | alphaTemp[p] -= self.tgc * (self.cpAlpha[0] + self.cpAlpha[1])/2 496 | alphaTemp[p] = SCALEALPHA / alphaTemp[p] 497 | #print("alphaTemp: ", alphaTemp) 498 | 499 | temp = max(alphaTemp) 500 | #print("temp", temp) 501 | 502 | alphaScale = 0 503 | while temp < 32768: 504 | temp *= 2 505 | alphaScale += 1 506 | 507 | for i in range(768): 508 | temp = alphaTemp[i] * math.pow(2, alphaScale) 509 | self.alpha[i] = int(temp + 0.5) 510 | 511 | self.alphaScale = alphaScale 512 | 513 | def _ExtractOffsetParameters(self): 514 | # extract offset 515 | occRow = [0] * 24 516 | occColumn = [0] * 32 517 | 518 | occRemScale = (eeData[16] & 0x000F) 519 | occColumnScale = (eeData[16] & 0x00F0) >> 4 520 | occRowScale = (eeData[16] & 0x0F00) >> 8 521 | offsetRef = eeData[17] 522 | if offsetRef > 32767: 523 | offsetRef -= 65536 524 | 525 | for i in range(6): 526 | p = i * 4 527 | occRow[p + 0] = (eeData[18 + i] & 0x000F) 528 | occRow[p + 1] = (eeData[18 + i] & 0x00F0) >> 4 529 | occRow[p + 2] = (eeData[18 + i] & 0x0F00) >> 8 530 | occRow[p + 3] = (eeData[18 + i] & 0xF000) >> 12 531 | 532 | for i in range(24): 533 | if occRow[i] > 7: 534 | occRow[i] -= 16 535 | 536 | for i in range(8): 537 | p = i * 4 538 | occColumn[p + 0] = (eeData[24 + i] & 0x000F) 539 | occColumn[p + 1] = (eeData[24 + i] & 0x00F0) >> 4 540 | occColumn[p + 2] = (eeData[24 + i] & 0x0F00) >> 8 541 | occColumn[p + 3] = (eeData[24 + i] & 0xF000) >> 12 542 | 543 | for i in range(32): 544 | if occColumn[i] > 7: 545 | occColumn[i] -= 16 546 | 547 | for i in range(24): 548 | for j in range(32): 549 | p = 32 * i + j 550 | self.offset[p] = (eeData[64 + p] & 0xFC00) >> 10 551 | if self.offset[p] > 31: 552 | self.offset[p] -= 64 553 | self.offset[p] *= 1 << occRemScale 554 | self.offset[p] += (offsetRef + (occRow[i] << occRowScale) + 555 | (occColumn[j] << occColumnScale)) 556 | 557 | def _ExtractKtaPixelParameters(self): # pylint: disable=too-many-locals 558 | # extract KtaPixel 559 | KtaRC = [0] * 4 560 | ktaTemp = [0] * 768 561 | 562 | KtaRoCo = (eeData[54] & 0xFF00) >> 8 563 | if KtaRoCo > 127: 564 | KtaRoCo -= 256 565 | KtaRC[0] = KtaRoCo 566 | 567 | KtaReCo = eeData[54] & 0x00FF 568 | if KtaReCo > 127: 569 | KtaReCo -= 256 570 | KtaRC[2] = KtaReCo 571 | 572 | KtaRoCe = (eeData[55] & 0xFF00) >> 8 573 | if KtaRoCe > 127: 574 | KtaRoCe -= 256 575 | KtaRC[1] = KtaRoCe 576 | 577 | KtaReCe = eeData[55] & 0x00FF 578 | if KtaReCe > 127: 579 | KtaReCe -= 256 580 | KtaRC[3] = KtaReCe 581 | 582 | ktaScale1 = ((eeData[56] & 0x00F0) >> 4) + 8 583 | ktaScale2 = (eeData[56] & 0x000F) 584 | 585 | for i in range(24): 586 | for j in range(32): 587 | p = 32 * i + j 588 | split = 2*(p//32 - (p//64)*2) + p%2 589 | ktaTemp[p] = (eeData[64 + p] & 0x000E) >> 1 590 | if ktaTemp[p] > 3: 591 | ktaTemp[p] -= 8 592 | ktaTemp[p] *= 1 << ktaScale2 593 | ktaTemp[p] += KtaRC[split] 594 | ktaTemp[p] /= math.pow(2, ktaScale1) 595 | # ktaTemp[p] = ktaTemp[p] * mlx90640->offset[p] 596 | 597 | temp = abs(ktaTemp[0]) 598 | for kta in ktaTemp: 599 | temp = max(temp, abs(kta)) 600 | 601 | ktaScale1 = 0 602 | while temp < 64: 603 | temp *= 2 604 | ktaScale1 += 1 605 | 606 | for i in range(768): 607 | temp = ktaTemp[i] * math.pow(2, ktaScale1) 608 | if temp < 0: 609 | self.kta[i] = int(temp - 0.5) 610 | else: 611 | self.kta[i] = int(temp + 0.5) 612 | self.ktaScale = ktaScale1 613 | 614 | 615 | def _ExtractKvPixelParameters(self): 616 | KvT = [0] * 4 617 | kvTemp = [0] * 768 618 | 619 | KvRoCo = (eeData[52] & 0xF000) >> 12 620 | if KvRoCo > 7: 621 | KvRoCo -= 16 622 | KvT[0] = KvRoCo 623 | 624 | KvReCo = (eeData[52] & 0x0F00) >> 8 625 | if KvReCo > 7: 626 | KvReCo -= 16 627 | KvT[2] = KvReCo 628 | 629 | KvRoCe = (eeData[52] & 0x00F0) >> 4 630 | if KvRoCe > 7: 631 | KvRoCe -= 16 632 | KvT[1] = KvRoCe 633 | 634 | KvReCe = eeData[52] & 0x000F 635 | if KvReCe > 7: 636 | KvReCe -= 16 637 | KvT[3] = KvReCe 638 | 639 | kvScale = (eeData[56] & 0x0F00) >> 8 640 | 641 | for i in range(24): 642 | for j in range(32): 643 | p = 32 * i + j 644 | split = 2*(p//32 - (p//64)*2) + p%2 645 | kvTemp[p] = KvT[split] 646 | kvTemp[p] /= math.pow(2, kvScale) 647 | #kvTemp[p] = kvTemp[p] * mlx90640->offset[p] 648 | 649 | temp = abs(kvTemp[0]) 650 | for kv in kvTemp: 651 | temp = max(temp, abs(kv)) 652 | 653 | kvScale = 0 654 | while temp < 64: 655 | temp *= 2 656 | kvScale += 1 657 | 658 | for i in range(768): 659 | temp = kvTemp[i] * math.pow(2, kvScale) 660 | if temp < 0: 661 | self.kv[i] = int(temp - 0.5) 662 | else: 663 | self.kv[i] = int(temp + 0.5) 664 | self.kvScale = kvScale 665 | 666 | def _ExtractCILCParameters(self): 667 | ilChessC = [0] * 3 668 | 669 | self.calibrationModeEE = (eeData[10] & 0x0800) >> 4 670 | self.calibrationModeEE = self.calibrationModeEE ^ 0x80 671 | 672 | ilChessC[0] = eeData[53] & 0x003F 673 | if ilChessC[0] > 31: 674 | ilChessC[0] -= 64 675 | ilChessC[0] /= 16.0 676 | 677 | ilChessC[1] = (eeData[53] & 0x07C0) >> 6 678 | if ilChessC[1] > 15: 679 | ilChessC[1] -= 32 680 | ilChessC[1] /= 2.0 681 | 682 | ilChessC[2] = (eeData[53] & 0xF800) >> 11 683 | if ilChessC[2] > 15: 684 | ilChessC[2] -= 32 685 | ilChessC[2] /= 8.0 686 | 687 | self.ilChessC = ilChessC 688 | 689 | def _ExtractDeviatingPixels(self): 690 | self.brokenPixels = [0xFFFF] * 5 691 | self.outlierPixels = [0xFFFF] * 5 692 | 693 | pixCnt = 0 694 | brokenPixCnt = 0 695 | outlierPixCnt = 0 696 | 697 | while (pixCnt < 768) and (brokenPixCnt < 5) and (outlierPixCnt < 5): 698 | if eeData[pixCnt+64] == 0: 699 | self.brokenPixels[brokenPixCnt] = pixCnt 700 | brokenPixCnt += 1 701 | elif (eeData[pixCnt+64] & 0x0001) != 0: 702 | self.outlierPixels[outlierPixCnt] = pixCnt 703 | outlierPixCnt += 1 704 | pixCnt += 1 705 | 706 | if brokenPixCnt > 4: 707 | raise RuntimeError("More than 4 broken pixels") 708 | if outlierPixCnt > 4: 709 | raise RuntimeError("More than 4 outlier pixels") 710 | if (brokenPixCnt + outlierPixCnt) > 4: 711 | raise RuntimeError("More than 4 faulty pixels") 712 | print("Found %d broken pixels, %d outliers" % (brokenPixCnt, outlierPixCnt)) 713 | # TODO INCOMPLETE 714 | 715 | class grove_mxl90641(MLX9064X_I2C_Driver): 716 | """Interface to the MLX90640 temperature sensor.""" 717 | kVdd = 0 718 | vdd25 = 0 719 | KvPTAT = 0 720 | KtPTAT = 0 721 | vPTAT25 = 0 722 | alphaPTAT = 0 723 | gainEE = 0 724 | tgc = 0 725 | resolutionEE = 0 726 | KsTa = 0 727 | ksTo = [0] * 8 728 | ct = [0] * 8 729 | alpha = [0] * 192 730 | alphaScale = 0 731 | offset = [[0 for i in range(192)] for i in range(2)] 732 | kta = [0] * 192 733 | ktaScale = 0 734 | kv = [0] * 192 735 | kvScale = 0 736 | cpAlpha = 0 737 | cpOffset = 0 738 | brokenPixels = [0xFFFF] * 5 739 | cpKta = 0 740 | cpKv = 0 741 | emissivityEE = 0 742 | def __init__(self,address=0x33): 743 | super(grove_mxl90641, self).__init__(address) 744 | self.refresh_rate = RefreshRate.REFRESH_0_5_HZ 745 | self.I2CReadWords(0x2400, eeData) 746 | self._HammingDecode() 747 | self._ExtractParameters() 748 | 749 | @property 750 | def refresh_rate(self): 751 | """ How fast the MLX90641 will spit out data. Start at lowest speed in 752 | RefreshRate and then slowly increase I2C clock rate and rate until you 753 | max out. The sensor does not like it if the I2C host cannot 'keep up'!""" 754 | controlRegister = [0] 755 | self.I2CReadWords(0x800D, controlRegister) 756 | return (controlRegister[0] & 0x0380) & 0x07 757 | 758 | @refresh_rate.setter 759 | def refresh_rate(self, rate): 760 | controlRegister = [0] 761 | value = (rate & 0x7) << 7 762 | self.I2CReadWords(0x800D, controlRegister) 763 | value |= controlRegister[0] & 0xFC7F 764 | self.I2CWriteWord(0x800d, value) 765 | 766 | def getFrame(self, framebuf): 767 | """ Request both 'halves' of a frame from the sensor, merge them 768 | and calculate the temperature in C for each of 12x16 pixels. Placed 769 | into the 192-element array passed in! """ 770 | emissivity = 0.95 771 | tr = 23.15 772 | mlx90641Frame = [0] * 242 773 | 774 | for _ in range(2): 775 | mlx90641Frame = self._GetFrameData() 776 | if mlx90641Frame[241] < 0: 777 | raise RuntimeError("Frame data error") 778 | # For a MLX90641 in the open air the shift is -8 degC. 779 | tr = self._GetTa(mlx90641Frame) - OPENAIR_TA_SHIFT 780 | self._CalculateTo(mlx90641Frame, emissivity, tr, framebuf) 781 | 782 | def _GetFrameData(self): 783 | dataReady = 0 784 | cnt = 0 785 | statusRegister = [0] 786 | controlRegister = [0] 787 | subPage = 0 788 | while dataReady == 0: 789 | self.I2CReadWords(0x8000, statusRegister) 790 | dataReady = statusRegister[0] & 0x0008 791 | subPage = statusRegister[0] & 0x0001 792 | 793 | while (dataReady != 0) and (cnt < 5): 794 | self.I2CWriteWord(0x8000, 0x0030) 795 | #print("Read frame", cnt) 796 | recive_data = [0] * 32 797 | reciver = [0] 798 | if subPage == 0: 799 | # print(data) 800 | self.I2CReadWords(0x0400, recive_data, end=32) 801 | reciver = reciver + recive_data 802 | self.I2CReadWords(0x0440, recive_data, end=32) 803 | reciver = reciver + recive_data 804 | self.I2CReadWords(0x0480, recive_data, end=32) 805 | reciver = reciver + recive_data 806 | self.I2CReadWords(0x04C0, recive_data, end=32) 807 | reciver = reciver + recive_data 808 | self.I2CReadWords(0x0500, recive_data, end=32) 809 | reciver = reciver + recive_data 810 | self.I2CReadWords(0x0540, recive_data, end=32) 811 | reciver = reciver + recive_data 812 | else: 813 | self.I2CReadWords(0x0420, recive_data, end=32) 814 | reciver = reciver + recive_data 815 | self.I2CReadWords(0x0460, recive_data, end=32) 816 | reciver = reciver + recive_data 817 | self.I2CReadWords(0x04A0, recive_data, end=32) 818 | reciver = reciver + recive_data 819 | self.I2CReadWords(0x04E0, recive_data, end=32) 820 | reciver = reciver + recive_data 821 | self.I2CReadWords(0x0520, recive_data, end=32) 822 | reciver = reciver + recive_data 823 | self.I2CReadWords(0x0560, recive_data, end=32) 824 | reciver = reciver + recive_data 825 | recive_data = [0] * 48 826 | self.I2CReadWords(0x0580, recive_data, end=48) 827 | reciver = reciver + recive_data 828 | self.I2CReadWords(0x8000, statusRegister) 829 | dataReady = statusRegister[0] & 0x0008 830 | subPage = statusRegister[0] & 0x0001 831 | cnt += 1 832 | if cnt > 4: 833 | raise RuntimeError("Too many retries") 834 | self.I2CReadWords(0x800D, controlRegister) 835 | reciver.append(controlRegister[0]) 836 | reciver.append(statusRegister[0] & 0x0001) 837 | del reciver[0] 838 | return reciver 839 | 840 | def _GetTa(self, frameData): 841 | vdd = self._GetVdd(frameData) 842 | ptat = frameData[224] 843 | if ptat > 32767: 844 | ptat -= 65536 845 | 846 | ptatArt = frameData[192] 847 | if ptatArt > 32767: 848 | ptatArt -= 65536 849 | ptatArt = (ptat / (ptat * self.alphaPTAT + ptatArt)) * math.pow(2, 18) 850 | 851 | ta = (ptatArt / (1 + self.KvPTAT * (vdd - 3.3)) - self.vPTAT25) 852 | ta = ta / self.KtPTAT + 25 853 | 854 | return ta 855 | 856 | def _GetVdd(self, frameData): 857 | vdd = frameData[234] 858 | if vdd > 32767: 859 | vdd -= 65536 860 | resolutionRAM = (frameData[240] & 0x0C00) >> 10 861 | resolutionCorrection = math.pow(2, self.resolutionEE) / math.pow(2, resolutionRAM) 862 | vdd = (resolutionCorrection * vdd - self.vdd25) / self.kVdd + 3.3 863 | 864 | return vdd 865 | 866 | def _CalculateTo(self, frameData, emissivity, tr, result): 867 | # pylint: disable=too-many-locals, too-many-branches, too-many-statements 868 | subPage = frameData[241] 869 | alphaCorrR = [0] * 8 870 | 871 | vdd = self._GetVdd(frameData) 872 | ta = self._GetTa(frameData) 873 | 874 | ta4 = (ta + 273.15) 875 | ta4 = ta4 * ta4 876 | ta4 = ta4 * ta4 877 | tr4 = (tr + 273.15) 878 | tr4 = tr4 * tr4 879 | tr4 = tr4 * tr4 880 | taTr = tr4 - (tr4-ta4) / emissivity 881 | 882 | ktaScale = math.pow(2, self.ktaScale) 883 | kvScale = math.pow(2, self.kvScale) 884 | alphaScale = math.pow(2, self.alphaScale) 885 | 886 | alphaCorrR[1] = 1 / (1 + self.ksTo[1] * 20) 887 | alphaCorrR[0] = alphaCorrR[1] / (1 + self.ksTo[0] * 20) 888 | alphaCorrR[2] = 1 889 | alphaCorrR[3] = (1 + self.ksTo[2] * self.ct[3]) 890 | alphaCorrR[4] = alphaCorrR[3] * (1 + self.ksTo[3] * (self.ct[4] - self.ct[3])) 891 | alphaCorrR[5] = alphaCorrR[4] * (1 + self.ksTo[4] * (self.ct[5] - self.ct[4])) 892 | alphaCorrR[6] = alphaCorrR[5] * (1 + self.ksTo[5] * (self.ct[6] - self.ct[5])) 893 | alphaCorrR[7] = alphaCorrR[6] * (1 + self.ksTo[6] * (self.ct[7] - self.ct[6])) 894 | #--------- Gain calculation ----------------------------------- 895 | gain = frameData[202] 896 | if gain > 32767: 897 | gain -= 65536 898 | gain = self.gainEE / gain 899 | #--------- To calculation ------------------------------------- 900 | irDataCP = frameData[200] 901 | if irDataCP > 32767 : 902 | irDataCP -= 65536 903 | irDataCP *= gain 904 | irDataCP -= self.cpOffset*(1 + self.cpKta*(ta - 25)) * (1 + self.cpKv*(vdd - 3.3)) 905 | for pixelNumber in range(192): 906 | irData = frameData[pixelNumber] 907 | if irData > 32767: 908 | irData -= 65536 909 | irData *= gain 910 | kta = self.kta[pixelNumber]/ktaScale 911 | kv = self.kv[pixelNumber]/kvScale 912 | 913 | irData -= (self.offset[subPage][pixelNumber] * 914 | (1 + kta*(ta - 25)) * 915 | (1 + kv*(vdd - 3.3))) 916 | irData = irData - self.tgc * irDataCP 917 | irData /= emissivity 918 | alphaCompensated = SCALEALPHA * alphaScale/self.alpha[pixelNumber] 919 | alphaCompensated *= (1 + self.KsTa * (ta - 25)) 920 | Sx = (alphaCompensated * alphaCompensated * 921 | alphaCompensated * (irData + alphaCompensated * taTr)) 922 | try: 923 | Sx = math.sqrt(math.sqrt(Sx)) * self.ksTo[2] 924 | except ValueError: 925 | result[pixelNumber] = "nan" 926 | continue 927 | To = math.sqrt(math.sqrt(irData / (alphaCompensated * (1 - self.ksTo[2] * 273.15) + Sx) + taTr)) - 273.15 928 | if To < self.ct[1]: 929 | torange = 0 930 | elif To < self.ct[2]: 931 | torange = 1 932 | elif To < self.ct[3]: 933 | torange = 2 934 | elif To < self.ct[4]: 935 | torange = 3 936 | elif To < self.ct[5]: 937 | torange = 4 938 | elif To < self.ct[6]: 939 | torange = 5 940 | elif To < self.ct[7]: 941 | torange = 6 942 | else: 943 | torange = 7 944 | 945 | To = math.sqrt(math.sqrt(irData / 946 | (alphaCompensated * alphaCorrR[torange] * 947 | (1 + self.ksTo[torange] * 948 | (To - self.ct[torange]))) + taTr)) - 273.15 949 | 950 | result[pixelNumber] = To 951 | # pylint: enable=too-many-locals, too-many-branches, too-many-statements 952 | 953 | def _HammingDecode(self): 954 | parity = [0] * 5 955 | D = [0] * 16 956 | error = 0 957 | switcher = { 958 | 16: 15, 959 | 24: 14, 960 | 20: 13, 961 | 18: 12, 962 | 17: 11, 963 | 31: 10, 964 | 30: 9, 965 | 29: 8, 966 | 28: 7, 967 | 27: 6, 968 | 26: 5, 969 | 25: 4, 970 | 23: 3, 971 | 22: 2, 972 | 21: 1, 973 | 19: 0, 974 | } 975 | for addr in range(16,832): 976 | parity[0] = -1 977 | parity[1] = -1 978 | parity[2] = -1 979 | parity[3] = -1 980 | parity[4] = -1 981 | data = eeData[addr] 982 | mask = 1 983 | for i in range(16): 984 | D[i] = (data & mask) >> i 985 | mask = mask << 1 986 | parity[0] = D[0]^D[1]^D[3]^D[4]^D[6]^D[8]^D[10]^D[11] 987 | parity[1] = D[0]^D[2]^D[3]^D[5]^D[6]^D[9]^D[10]^D[12] 988 | parity[2] = D[1]^D[2]^D[3]^D[7]^D[8]^D[9]^D[10]^D[13] 989 | parity[3] = D[4]^D[5]^D[6]^D[7]^D[8]^D[9]^D[10]^D[14] 990 | parity[4] = D[0]^D[1]^D[2]^D[3]^D[4]^D[5]^D[6]^D[7]^D[8]^D[9]^D[10]^D[11]^D[12]^D[13]^D[14]^D[15] 991 | if (parity[0]!=0) or (parity[1]!=0) or (parity[2]!=0) or (parity[3]!=0) or (parity[4]!=0) : 992 | check = (parity[0]<<0) + (parity[1]<<1) + (parity[2]<<2) + (parity[3]<<3) + (parity[4]<<4) 993 | if (check > 15) and (check < 32): 994 | D[switcher[check]] = 1 - D[switcher[check]] 995 | if error == 0 : 996 | raise RuntimeError("check error") 997 | data = 0 998 | mask = 1 999 | for j in range(16): 1000 | data = data + D[j]*mask 1001 | mask = mask << 1 1002 | else: 1003 | raise RuntimeError("cannot find check number") 1004 | 1005 | eeData[addr] = data & 0x07FF 1006 | 1007 | def _ExtractParameters(self): 1008 | self._ExtractVDDParameters() 1009 | self._ExtractPTATParameters() 1010 | self._ExtractGainParameters() 1011 | self._ExtractTgcParameters() 1012 | self._ExtractEmissivityParameters() 1013 | self._ExtractResolutionParameters() 1014 | self._ExtractKsTaParameters() 1015 | self._ExtractKsToParameters() 1016 | self._ExtractAlphaParameters() 1017 | self._ExtractOffsetParameters() 1018 | self._ExtractKtaPixelParameters() 1019 | self._ExtractKvPixelParameters() 1020 | self._ExtractCPParameters() 1021 | self._ExtractDeviatingPixels() 1022 | # debug output 1023 | # print('-'*40) 1024 | # print("kVdd = %d, vdd25 = %d" % (self.kVdd, self.vdd25)) 1025 | # print("KvPTAT = %f, KtPTAT = %f, vPTAT25 = %d, alphaPTAT = %f" % 1026 | # (self.KvPTAT, self.KtPTAT, self.vPTAT25, self.alphaPTAT)) 1027 | # print("Gain = %d, Tgc = %f, Resolution = %d" % (self.gainEE, self.tgc, self.resolutionEE)) 1028 | # print("KsTa = %f, ksTo = %s, ct = %s" % (self.KsTa, self.ksTo, self.ct)) 1029 | # print("cpAlpha:", self.cpAlpha, "cpOffset:", self.cpOffset) 1030 | # print("alpha: ", self.alpha) 1031 | # print("alphascale: ", self.alphaScale) 1032 | # print("offset: ", self.offset) 1033 | # print("kta:", self.kta) 1034 | # print("ktaScale:", self.ktaScale) 1035 | # print("kv:", self.kv) 1036 | # print("kvScale:", self.kvScale) 1037 | # print(eeData) 1038 | # print('-'*40) 1039 | def _ExtractVDDParameters(self): 1040 | # extract VDD 1041 | self.kVdd = eeData[39] 1042 | if self.kVdd > 1023: 1043 | self.kVdd = self.kVdd - 2048 1044 | self.kVdd = 32 * self.kVdd 1045 | 1046 | self.vdd25 = eeData[38] 1047 | if self.vdd25 > 1023: 1048 | self.vdd25 = self.vdd25 - 2048 1049 | self.vdd25 = 32 * self.vdd25 1050 | 1051 | def _ExtractPTATParameters(self): 1052 | # extract PTAT 1053 | self.KvPTAT = eeData[43] 1054 | if self.KvPTAT > 1023: 1055 | self.KvPTAT = self.KvPTAT - 2048 1056 | self.KvPTAT = self.KvPTAT / 4096 1057 | 1058 | self.KtPTAT = eeData[42] 1059 | if self.KtPTAT > 1023: 1060 | self.KtPTAT = self.KtPTAT - 2048 1061 | self.KtPTAT = self.KtPTAT / 8 1062 | 1063 | self.vPTAT25 = 32 * eeData[40] + eeData[41] 1064 | self.alphaPTAT = eeData[44] / 128 1065 | 1066 | def _ExtractGainParameters(self): 1067 | # extract Gain 1068 | self.gainEE = 32 * eeData[36] + eeData[37] 1069 | 1070 | def _ExtractTgcParameters(self): 1071 | # extract Tgc 1072 | self.tgc = eeData[51] & 0x01FF 1073 | if self.tgc > 255: 1074 | self.tgc -= 512 1075 | self.tgc /= 64 1076 | def _ExtractEmissivityParameters(self): 1077 | self.emissivityEE = eeData[35] 1078 | if self.emissivityEE > 1023: 1079 | self.emissivityEE -= 2048 1080 | self.emissivityEE /= 512 1081 | 1082 | def _ExtractResolutionParameters(self): 1083 | # extract resolution 1084 | self.resolutionEE = (eeData[51] & 0x0600) >> 9 1085 | 1086 | def _ExtractKsTaParameters(self): 1087 | # extract KsTa 1088 | self.KsTa = eeData[34] 1089 | if self.KsTa > 1023: 1090 | self.KsTa = self.KsTa - 2048 1091 | self.KsTa /= 32768 1092 | 1093 | def _ExtractKsToParameters(self): 1094 | # extract ksTo 1095 | self.ct[0] = -40 1096 | self.ct[1] = -20 1097 | self.ct[2] = 0 1098 | self.ct[3] = 80 1099 | self.ct[4] = 120 1100 | self.ct[5] = eeData[58] 1101 | self.ct[6] = eeData[60] 1102 | self.ct[7] = eeData[62] 1103 | 1104 | KsToScale = eeData[52] 1105 | KsToScale = 1 << KsToScale 1106 | 1107 | self.ksTo[0] = eeData[53] 1108 | self.ksTo[1] = eeData[54] 1109 | self.ksTo[2] = eeData[55] 1110 | self.ksTo[3] = eeData[56] 1111 | self.ksTo[4] = eeData[57] 1112 | self.ksTo[5] = eeData[59] 1113 | self.ksTo[6] = eeData[61] 1114 | self.ksTo[7] = eeData[63] 1115 | for i in range(8): 1116 | if self.ksTo[i] > 1023: 1117 | self.ksTo[i] -= 2048 1118 | self.ksTo[i] /= KsToScale 1119 | 1120 | def _ExtractCPParameters(self): 1121 | # extract CP 1122 | self.cpOffset = 32 * eeData[47] + eeData[48] 1123 | if self.cpOffset > 32767: 1124 | self.cpOffset -= 65536 1125 | 1126 | self.cpAlpha = eeData[45] 1127 | if self.cpAlpha > 1023 : 1128 | self.cpAlpha = self.cpAlpha - 2048 1129 | self.cpAlpha //= math.pow(2,self.cpAlpha) 1130 | 1131 | self.cpKta = eeData[49] & 0x001F 1132 | if self.cpKta > 31: 1133 | self.cpKta -= 64 1134 | ktaScale1 = eeData[49] >> 6 1135 | self.cpKta /= math.pow(2,ktaScale1) 1136 | 1137 | self.cpKv = eeData[50] & 0x001F 1138 | if self.cpKv > 31: 1139 | self.cpKv = self.cpKv - 64 1140 | kvScale = eeData[50] >> 6 1141 | self.cpKv /= math.pow(2,kvScale) 1142 | 1143 | def _ExtractAlphaParameters(self): 1144 | # extract alpha 1145 | scaleRowAlpha = [0] * 6 1146 | rowMaxAlphaNorm = [0] * 6 1147 | alphaTemp = [0] * 192 1148 | scaleRowAlpha[0] = (eeData[25] >> 5) + 20 1149 | scaleRowAlpha[1] = (eeData[25] & 0x001F) + 20 1150 | scaleRowAlpha[2] = (eeData[26] >> 5) + 20 1151 | scaleRowAlpha[3] = (eeData[26] & 0x001F) + 20 1152 | scaleRowAlpha[4] = (eeData[27] >> 5) + 20 1153 | scaleRowAlpha[5] = (eeData[27] & 0x001F) + 20 1154 | 1155 | for i in range(6): 1156 | rowMaxAlphaNorm[i] = eeData[28 + i] / math.pow(2,scaleRowAlpha[i]) 1157 | rowMaxAlphaNorm[i] /= 2047 1158 | 1159 | for i in range(6): 1160 | for j in range(32): 1161 | p = 32 * i +j 1162 | alphaTemp[p] = eeData[256 + p] * rowMaxAlphaNorm[i] 1163 | alphaTemp[p] = alphaTemp[p] - self.tgc * self.cpAlpha 1164 | alphaTemp[p] = SCALEALPHA / alphaTemp[p] 1165 | 1166 | temp = max(alphaTemp) 1167 | 1168 | self.alphaScale = 0 1169 | while temp < 32768 : 1170 | temp = temp * 2 1171 | self.alphaScale = self.alphaScale + 1 1172 | 1173 | for i in range(192): 1174 | temp = alphaTemp[i] * math.pow(2,self.alphaScale) 1175 | self.alpha[i] = int(temp + 0.5) 1176 | 1177 | 1178 | def _ExtractOffsetParameters(self): 1179 | # extract offset 1180 | scaleOffset = eeData[16] >> 5 1181 | scaleOffset = 1 << scaleOffset 1182 | offsetRef = 32 * eeData[17] + eeData[18] 1183 | if offsetRef > 32767: 1184 | offsetRef -= 65536 1185 | for Index in range(192): 1186 | tempOffset = eeData[64 + Index] 1187 | if tempOffset > 1023: 1188 | tempOffset = eeData[64 + Index] - 2048 1189 | self.offset[0][Index] = tempOffset * scaleOffset + offsetRef 1190 | tempOffset = eeData[640 + Index] 1191 | if tempOffset > 1023: 1192 | tempOffset = eeData[640 + Index] - 2048 1193 | self.offset[1][Index] = tempOffset * scaleOffset + offsetRef 1194 | 1195 | def _ExtractKtaPixelParameters(self): # pylint: disable=too-many-locals 1196 | # extract KtaPixel 1197 | ktaTemp = [0] * 192 1198 | ktaAvg = eeData[21] 1199 | if ktaAvg > 1023: 1200 | ktaAvg = ktaAvg - 2048 1201 | ktaScale1 = eeData[22] >> 5 1202 | ktaScale2 = eeData[22] & 0x001F 1203 | for i in range(192): 1204 | tempKta = (eeData[448 + i] >> 5) 1205 | if tempKta > 31: 1206 | tempKta = tempKta - 64 1207 | ktaTemp[i] = tempKta * math.pow(2,ktaScale2) 1208 | ktaTemp[i] += ktaAvg 1209 | ktaTemp[i] /= math.pow(2,ktaScale1) 1210 | temp = max(map(abs,ktaTemp)) 1211 | ktaScale1 = 0 1212 | while temp < 64 : 1213 | temp = temp * 2 1214 | ktaScale1 += 1 1215 | for i in range(192): 1216 | temp = ktaTemp[i] * math.pow(2,ktaScale1) 1217 | if temp < 0: 1218 | self.kta[i] = int(temp - 0.5) 1219 | else: 1220 | self.kta[i] = int(temp + 0.5) 1221 | self.ktaScale = ktaScale1 1222 | 1223 | def _ExtractKvPixelParameters(self): 1224 | kvTemp = [0] * 192 1225 | kvAvg = eeData[23] 1226 | if kvAvg > 1023: 1227 | kvAvg -= 2048 1228 | kvScale1 = eeData[24] >> 5 1229 | kvScale2 = eeData[24] & 0x001F 1230 | for i in range(192): 1231 | tempKv = (eeData[448 + i] & 0x001F) 1232 | if tempKv > 15: 1233 | tempKv = tempKv - 32 1234 | kvTemp[i] = tempKv * math.pow(2,kvScale2) 1235 | kvTemp[i] += kvAvg 1236 | kvTemp[i] /= math.pow(2,kvScale1) 1237 | temp = abs(kvTemp[0]) 1238 | for kv in kvTemp: 1239 | temp = max(temp, abs(kv)) 1240 | kvScale1 = 0 1241 | while temp < 64 : 1242 | temp = temp * 2 1243 | kvScale1 += 1 1244 | for i in range(192): 1245 | temp = kvTemp[i] * math.pow(2,kvScale1) 1246 | if temp < 0: 1247 | self.kv[i] = int(temp - 0.5) 1248 | else: 1249 | self.kv[i] = int(temp + 0.5) 1250 | self.kvScale = kvScale1 1251 | 1252 | def _ExtractDeviatingPixels(self): 1253 | self.brokenPixels = [0xFFFF] * 5 1254 | 1255 | pixCnt = 0 1256 | brokenPixCnt = 0 1257 | 1258 | while (pixCnt < 192) and (brokenPixCnt < 3): 1259 | if (eeData[pixCnt+64] == 0) and (eeData[pixCnt+256] == 0) and (eeData[pixCnt+448] == 0) and (eeData[pixCnt+640] == 0): 1260 | self.brokenPixels[brokenPixCnt] = pixCnt 1261 | brokenPixCnt += 1 1262 | pixCnt += 1 1263 | if brokenPixCnt > 2: 1264 | raise RuntimeError("More than 3 broken pixels") 1265 | print("Found %d broken pixels" % (brokenPixCnt)) 1266 | -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | 2 | """A setuptools based setup module. 3 | See: 4 | https://packaging.python.org/en/latest/distributing.html 5 | https://github.com/pypa/sampleproject 6 | """ 7 | 8 | # Always prefer setuptools over distutils 9 | from setuptools import setup, find_packages 10 | # To use a consistent encoding 11 | from codecs import open 12 | from os import path 13 | 14 | here = path.abspath(path.dirname(__file__)) 15 | 16 | # Get the long description from the README file 17 | with open(path.join(here, 'README.md'), encoding='utf-8') as f: 18 | long_description = f.read() 19 | 20 | setup( 21 | name='seeed-python-mlx9064x', 22 | version="1.1.3", 23 | description='Python library for the Grove - Thermal Imaging Camera(MLX9064x) is an thermal sensor. ', 24 | long_description=long_description, 25 | long_description_content_type='text/markdown', 26 | 27 | # The project's main homepage. 28 | url='https://github.com/Seeed-Studio/Seeed_Python_MLX9064x', 29 | 30 | # Author details 31 | author='Hanson', 32 | author_email='595355940@qq.com', 33 | 34 | install_requires=['Seeed-grove.py'], 35 | 36 | # Choose your license 37 | license='MIT', 38 | 39 | # See https://pypi.python.org/pypi?%3Aaction=list_classifiers 40 | classifiers=[ 41 | 'Development Status :: 3 - Alpha', 42 | 'Intended Audience :: Developers', 43 | 'Topic :: Software Development :: Libraries', 44 | 'Topic :: System :: Hardware', 45 | 'License :: OSI Approved :: MIT License', 46 | 'Programming Language :: Python :: 3', 47 | 'Programming Language :: Python :: 3.4', 48 | 'Programming Language :: Python :: 3.5', 49 | ], 50 | 51 | # What does your project relate to? 52 | keywords='seeed grove mlx9064x thermal Camera sensor i2c hardware', 53 | 54 | # You can just specify the packages manually here if your project is 55 | # simple. Or you can use find_packages(). 56 | py_modules=['seeed_mlx9064x'], 57 | ) 58 | 59 | --------------------------------------------------------------------------------