From 03cca53d2af26c7fbe5bb909954d52bbbd94da0a Mon Sep 17 00:00:00 2001 From: William Penner Date: Fri, 19 Dec 2014 13:18:11 -0800 Subject: [PATCH] am2315: Sensor added Signed-off-by: William Penner Signed-off-by: Brendan Le Foll --- docs/images/am2315.jpeg | Bin 0 -> 19517 bytes examples/CMakeLists.txt | 3 + examples/am2315.cxx | 75 ++++++++ src/am2315/CMakeLists.txt | 5 + src/am2315/am2315.cpp | 368 ++++++++++++++++++++++++++++++++++++++ src/am2315/am2315.h | 195 ++++++++++++++++++++ src/am2315/jsupm_am2315.i | 8 + src/am2315/pyupm_am2315.i | 13 ++ 8 files changed, 667 insertions(+) create mode 100644 docs/images/am2315.jpeg create mode 100755 examples/am2315.cxx create mode 100644 src/am2315/CMakeLists.txt create mode 100644 src/am2315/am2315.cpp create mode 100644 src/am2315/am2315.h create mode 100644 src/am2315/jsupm_am2315.i create mode 100644 src/am2315/pyupm_am2315.i diff --git a/docs/images/am2315.jpeg b/docs/images/am2315.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..f13efe82105389b3c20fc28b5375a944992070af GIT binary patch literal 19517 zcmbTdcT^Ky^fnr#geFBrL7EDRfOP34A_~$46hx{N>Akmvq96!_Dxy^BHPS(P4Lvkz zp$80|gc=|TU*6yS)_2#sf8Be}%w)}4b7pe(oH@^V_Oti7n!Q>9Flnf&s{+W#$N-k4 z4REyzc<|ES;UfT`tql+W007jaYc~Moq%$(o_CMtc2~YuCBP087|KEk2lKj6yML|JM z38Vr7|2wE@=xC^^X{mug+UvBmbo8VGq+wvZPS5b)`F{`j@Am)hBJK3lK#X>*^aCoBnil_w@F``v(RmCa3;R&&|f1ed~E*ZdE4@kAyyk#maM>_BQX+)rZ*sO#2_p{@)oE{{PFe|6|zy zZPz@2o}7%-dF0Fh5CDV0TSF_TOrfUSqd7-PU}CMCQt^mA2Jrjgc{{Cp$hKpR(kdJ^LKc0d z^egm9w5M8C-f$;s=PiEWD0wF<<(J;G+Z5$xP;l*ZLdEmRP&vYWhEKi`;tEh1`os-A z-i+03SA1m={MYiF=R79h9!z&S^x;h^rIa?;-Jpv%l#N#auH&ZpMZ)Ga4`E%Dh7GXI zw3)> zFeM|e0I+A*`T^T=V-FYjyT&st`4IU+njQ|u2@PsH8_2%o-zeJMmw7CN-9d!HE zOwlY#6N)2kFoSc81&xmgR<^wul}C;@=1fsnfC{zm3`$vbs@jrGGAW`K*u3Edx#Qzv zX%{r>$rV5;WhU7=@G^$N*g@2j(KQ9waj^52txpWuDySI|AF%c8cJM+XZsKXFNAlaR z=&Y20<|y22ihnLeSo~JCdUMg%>pS`4mcIDw0By82bVKdu-uV=xTttJy||$#Acw9~K~JFku^@%r~?(OM6=-dF&09c00O&7Jmf@%b~l@r<6sk z%{^?NnaDB1*MwHEMc@LTEcjMft2_70I zd~wU40Sa2rj^P@f_5X<9i{YG51Ki}qHUHDC7=Y)o!s|Q=bO!dvDJ--dqk9ky;;y*Y zHtFq=Z{NUCSyU!lSML!UsT{#u3TeG7zHXUlVH_-Y1qj!~F?M|AgvZvkYW7NN9x0Xs zcW;}?8iY@@F{&Ctw_a~QY~1rY%HZcwl>OJrzB;oThZS6#5*^9G@%7yKHY3=^-dATY z#0#7Vkm|hxK#jJ1GuOC3Ujb^kvQ#7Tacn7+f0_pqmkV|9*hU1m)$#h(jt*cP!%DQVdo5cPT<>j8I z_=$QGagPFnKxYPMwa39MJJ&9A-Kn+cnTU84{mJ3owghPmo89QwY~S@Q=o~$|v5%Ok;7H!?Uf2cajgZ=C zg0owVdydrkYBBDTlRhmXEc%ND2u*)&?FOp@`{LC|T@;B2S7Es-@^Fxjw(A(jtuyiW z>E5l}8ew!i;@{Mn%73bJa28EBfusxX*mH!<>IXDk0d~&H9WDR5#We>=wOuOenh1@S zSsGllSo=-Cj{VVK$GdkZJK}U2ODL3#3^3`*GL84+7Bqg>snmG8=nC*0?--eW`5Zhs zZ?n6MNmeDa2b8!{1VV~=jw`zZ81Y9sH(cE;f{m_geZ4LcrFM1&=v4fI{pX!kSKx{i zX>!0Z`8%D)r-4)}M$}Muy6N`v%xka>U4p0Q zDo*nX2L*$;RsFZ(OmsfJiEXI~HV8J5)^z-5l#p7t*T=zAdqq8y4Y$%P!Ej@9>nKy4 zLkYxZ5iFf_1sKpM>D6S}N0s!MyNb0hrP$)W`9K-#e>!n4w*E^icaXkbzpOtgJh4CO zwaNSZnX_ezvnYkFs*^~WPYEI%e+NrvVNy0Chw99_pBd}02BJ%J5dFA=?g06TXISp* z>je3fE;F?VuDOL7%tN{yI5SV9inZ=f;w=haZfrFOFFf(ny8;Yl^sGP-;;+c_Bo*%5 zR6#zuZ4Fc{o70$1!`ak=;}QKBtg*`^?9*8;4)(V3lZ`b##=)6T^>6c{m#*g44;8i2cc z{Qv}IFM*%NB{;zD0SsQ`1YXhtQb13$yR)bBgyOFN@0B0vJX3(a2e363xt(!3HYNkH zBLZ3)m)1pf01X{cRq;TBuPcPfM1&S3E0ytQZOAsoqLTAkD4#*f@fF}if1e$aX=E(R zvA?*Z`463QaXCf_6@5I=C%^K#k_OcP#Fk!S2|x{RE%gJqPT&{?(b83H23qkrO=t_j z@z=6f%`sJzuWH}x+06hr5{A|%hqIxOKg{^Fo2F0LgX9IBz77qQ7_tiOp~N-iYbf8m zG&hdE2cS~FXS8XtYjFjjD5=4mw6;fs`BW%Rb7+UCLf^LQ{}GYE*~f$fgic0wI02W^pQMk=s?VZ zRw29XPE@&y8Rqw9R%rK1ov5q7FSy9(MiETk*$&p}qSU__BKN))k-{Cpm?GL1x5-c|Z+*V30)IeXvq z@yUu&9Pa3}0tZ9!&nt4PV2IIf_XbTJi99t>azb%l;)X@;Gbj09bx&2B zL$0;KDrDKd(U~b)%`cv+^H$1T0VeMsmnDL`+H0-=5w5p2%dP+{+sZQhL1kS`SAgYW z9#DmUd$bZa-Wmsew38hRx&AaIx%~E|S(*iod#;}#m^uYn$ugJ6nn)}J+hg{y)`OWJ zx5y9{%{J|$WlNhA+|ASINqzi1LfUb`Eb&fVdaH$LJAx=L!(Cv|h*P^1*`XbW=PbOt zA=ZX`|L2KPmUSaRa6{XgNaKQzYL1C*pCX8Bauo#Lp)r+&G(tBtQsmNj@M2+I8?P`-BZ+q;Y-Q}zV zUkiDbB7^iU5rEYL3@&Dh@Y1CB8s-n{lpYUhb{Q7vKC7>Mi|tcaA<*RgC|%Y&oD7m@ z1+gg6;u=BabnHtGuMQ;cCKxA5t;Al%ZbG`F|?}Ci)SfwIt{hEh~OT5;$p+3qI7rvXtPny6~G6q-yRUWM~8a`IX+b>E65CFA__}2aA4LiWFxVXE(_%<;AT6Pl^n1%UZF%ZM z!jw~5+xqv=;U|tv5Xx7yk|UufC9B=L4#${{zT*40$Yos z5A&g16B~by_s%EaL%vslyI~wRiQLnf?O{8!V-z{-VDHmlk=ExjY^V#p<|7373ZMZ< zXfNSbna)6DWvjf7ToAj6dEMQvtMcro_vwYZ!)!mg@n9*JqXASQqrq?uHOW;=_QY+( zbke!#uSjlvUAWWFvh>@Jb0ftMb#{GAOXD?fJOg;DvnW%$fm6@m_#5a`_G#^Eyw3D- zWQ04->Pa)lgWp3ItTjzx2K5iz8I1op2c~QEGrl8)LaeS!pE`{1wJ5L2Shrz`c?_$p z$OoI_qTMftsw;p!2*)oH1?DnQ&%rB9?gsu zL;)}VVqv||d5NCvTW&UKrhoVO;=W%2@^ZyGfQ6k?c9(OdaZ+8oCyZafd>CNYOjh40 z@!)Nf;o=jif2^&?_rO$$K)?g$WTigL z!5#@{>4vjxE9zFrlidPkt^n;no#w!|Nwm*M_$l4@NElUaQE?yI#_KM@%(J}$Yz6A$ zw5z!}d#OKZY$_@@`@J~mx^9_L*e z^ssB~%@rWDvC?`?1b+k7VZpMS-;T3gOIMIBenqEN=s3Y%Mnlub@{zkO+9T_omTnzb z-rl12<#e(?pV7DJbx|c7k*f9^jeJ`ZZBRlsXr=hia;Qj-39?DV($;IkPee$ zyh9LnZb3-LTn&PCTe;H%oxK9|)uVd?U+zPNk509pi$APsA#nQH)mIJq2*Ew({?u*{qm+t*sTKN1sZ70j>GvV% z#t{4Qy{9f?5hS2{#smD}Q-r^HC=zCIw-)jRM7y7L*>QGwezz@AvG20tzC}us6raR% zcE_W1CQ&~Bh3%$1A;S$}`^{5@pG4ZdOKxK@0&;t|#b`C?zSAlrM|m1Evg4Clp;;yU z*kcX>snrMcp%M>@=~!V2`h#g!&^Hfp*zp$g>9m3n$kixOu9BD^7IyxsJ0%2}Y(p`^haF=eb^E z+`yrF1rXB#8ye|@zM$^R%CB2j1f8oosEKvK?*%i_4!m;$qTxmj0CJT@b%Z^z=#r5REW)NTJD0V+DwQ^G?>|>GImxJE_*j`~@p2erEwYiziXMgs5>lq@qPnLw zJ%s-Dtv_RnEqIdwq2>hE`OoYsUkYwr0jkbAKe)&v5im!AhQN(OVT$Td->y%G)?aSF z9TnHC|1115Kq>puXyEcSaq%uR^y&D9zvk+c?~Gh|Pq>fM9Dex`3uo@97sJavht3=V z+!9Io$-%?({1uG;xOD9EzOzojwbqYAt7Y|~My+S?D`fNbZ`_xMTz ziRrp!TAW5tKbovPFPy+XWY2!|mz^;XsG7zZ^4y#A@ELpxf-z%^|IywBrSP}z`r&ct zjJLQxGrwUdKs3GXioCTnxv?s_I@J6xpLrG4si>w@>Mr3 z)M_LifCixtVWL>O-hlnD50sP@f=GTAx#_=(HCaiT*(0cDNSUxxIX|Lkqt|So{De~< zt?!)Xk=63|=|pgMlCG9dfyBY4Qj2$ql`jv+c^pKGx=y2e*F`7LX$Gc|hzgsA5xEoQIfo-!G<7V*}rFEKu)lj z3rIvTdm-J3!Rv?lSy}~^nSj2_pV0vM2U@WiH`L#}wev9~hJvgtW_LQ5F*@0EFkOsm z7=NRt=S*N>!IS6wK3~z~!;Q8SdqBt1N}Z_}`oqfBaj(kKXr9J{h_q*GY2zR(Z7-e3 z`8CKM`&Sv;q{l-KODl#w-4c%9K8Xpl`M4i{ zA2m!X2(HQSPENlnU}V{-GK{U3%V6>oGc;IWa>AleQC-c52yPbq%T<#Jgins+O=C6< z=cB(IpA*Q(>$=X zd7o}h&}A!)&5rlqiHSziHOLAyJMI)O=RypxN{a)dbpE#7S=+PdR=Q{Q=U;^T^yEN|<3dv68Qr6)%n6Q<+!G0zHi=RvlEBP_zmh3j3ZQdXR5s& z=fU=z#xcg=$>r_2M5_&H4^`N|FJ{nR>z{Mid7iN12m4&2VJ!TyY=TJX=OD82a}LI@ z$en)j^;XRj;NMb`)0N~Z@@KovBrkM1nZV!X<_r$m7IRNltt>BRQ=u|Q=!lKT4vu;5 zm6Xrb)rP|nqRu}<+qFLausLtO`1gJ95aS*Q4SeRm37lyKfWQ!8#n!EYL&c~%Y4G%! zVynIH{K6^zF?7{`nXB=;jK#D3=55y^(g$6)&@vqmJ*K;q}5zM7xt@Mo=8UIBxDIUhtqD z#}l<%E_wYqdJSAf=Mt7*GnU#(e(zQmniY-vrO!?b3~%9wMYeJHD;=zX;%Y<4b&;og zR;PlG>B^jq{Ak(g*FUojD27U2daQ=XzaXTy+a13|e#pgHXmZ;oEWJla0;fNTetx0=KgXK3-$5~ zu>+)OP5*P2kQ`|TPleqZMO7Ojpfob)4;^Vqn9|D zR;p!}vhu*KwRPcENl$)@y8>Y3wz9aXG*OunBg`tr{>r1}$w|%8Ob@;mD37%yJXrTR zu#j|YqiVzKmw4EQI4EXrZI#XE9AU$Rz29?n53&F~aB7sl27VaOCSw4U(a+RA$TxHqytK3n=X>3c)7II=%igb2)N^8gcZT+8T~ zDu$%@4`x?&mv$eM3p|#}_>> zE%x80+`{Wnh8Sa1h}4`YD6>ho7bynA;vdv`ySiui^jpsMMXWG8nVDYFvJ-vgkUR?d ztzbZ?w+UnRqe{UGcMPinSuNvub$dkSy>T^C;MPjXILK2as25J(`}QXuhBgXe=@!_9=Sg3SP0-1`22FAQ%|`U>A8CGsK z%da@Ko8h&GUI`KWM#9#%O=kNmKz(72chhLq2fF}1Md~jqSAbeIv^go#Me!QPuzbDU z&WU~NzQ5fJI@vJ6_rY@tXQkieZ;u%9EO*u(_@hqeu-@)1Udq3ODl_7v?xi-wE!fSg z`6zAM7vz1A4&qi^klqAJ(tm9{0ik0u^N%FrTOGw|r3IIZ56l3DwzCZGq{;8s4+*5A zqQIo9IUI z!u@nx1NC$Y+M%0tZt0T8FZz@n(I8SrM8+j@-1w5$=YfURfU} zH{7ch{_^b?+qZphRto3+d9~rmLB*ahIJc6Z!cd3J`kmAj|9UliLwz^MND_O;s2$gk zHwST;Q>HwLtA01)#a<(ow~@s2shWhuURt-sckUPrrMerAofq++)Z?R)qSR~0{$cp z8fj8tYJZT}e!uLSfnG6E(#T^BZ->LKLfP=ljlciaT?blV2qSe9+ICX8A0+?OMn|zO z<;isL1_l{zLU%W?ZpwtJb~|?Umgb=55S_7JFDLgh0jj=%`#wDMWDEJs;fl(zf>o?f zRPXIJ%)ctDi`YM~w9^B6|14^|wAY5IHe{djO}533=$JP6EMpWVs3zBxu8~G&5YAv# zH?~g5YxQH9NcgYTZxW@rAiZzK$6ty-cDkaqp{DQT-4d5a45O=VxyN4bvwbM-llQU< zJH89nBThrAAJtvb1^Y*P5BN|A%a_S70%D2;w&RD!1? z{adnsS_ih9s-13IuZSy{Rh{v2AfafR`r!ufF9GX$wjvX<9|Q{AxLbzHkvT(?kRoh?=FwFX$4cr_XW>+>i~;iv=^7*{tnO|qZe zTtH@D*xuJ7s-{&nbiwz8Ti3zu%iWg>xHU>Ml~riB=4(~z$zypJ&`HA^$sZs)*qkzQ zIJraao|}vQx!Srg05%w8!Qtdvb}^P3)q@4eQH$>aeA4m4Y=HvyBfmYp~Up(LtWw6@lS0zRjz-x zv}RCsGhZbITbFG2y01Z6=SwsLo(>(22*xWNB@=@tH?oa^PXl>QU~tkadB+X3|D`LU z=Ts7~O6AAh*TT4#jlT`vc`aV}xoAO3ZE!+rJR4>)Hq)79r0AfK5uerbx;S6h>o52T zc)@~M=?U8n^!u!?>F3HZBe6D6-%(FRRl$MxYCoQj_NEU!Q6JzvRF~v=**u@TyB>>* zPiOh1?tG{5i+lINOe?sHyQ;71(k$30vP<62g2ACOY5VLGQ)%W40X3sw>xjeHtPZZp zQx4Jxq=Q4BRE05W*djhhEL!#*|kdmZhIXT9==di z(jU6pFkC#WGo6^~(L%@8FlnuO8mOmDHdRc+I&h$E9fsV|K9VN82)z6Jd4pLi^c=tA zqSc90fWm)#FlF4@(m-Um@?99X)2wG@XWmU6et|<~|D42@-l?)fPR1I3LeuoGc*UO> z+G8NCs<~B&Z7HRX{(ErL8zBWH>UAI4%1D2|j4VRP6=2li^t4fiJ4%xLk1$RjzAF~X z01?O~jOC3FOIv z7R{U6cya&ykMnAci0M2(1f>58kUbsO8{vHgpanz?4|=;aB6NpNa%8|+Em+(-_${lA zV0K3cgz$z<5dhEOycnanJbQfEDr+SRLSKxTGU`As{!;BlHzyK-KZ4Gb)lVJ^q~`LvcY6E4ZR#?oqv_*zM0PK3wWxT zY;g}~2N%V;$|Hk*7Oyq5TH3~6aMy0lX#Ota-Bj}L(CZnufj6c9P1I2oe2z6uGsHMl zbtx&F&exGy8B#L4Q8jZm_yB z#Tb|OQYBOgA+xr9zXLv;&;RflEKUK0YCIu4%}qM$nZE1wr7-Ra;8kfq+Aff`q#|ng z%qRe%pX^C?aI7111wiiEi%4FV@0s@1NuFQUr7JA48H!7M)l+8kSm&XkEnR4j(l(;M zez!7Y1ao9mhkYB@0-Be~o;|Z~rtHhY41PUYwW+zMTG`%gIo4m5*3Ft32G_;PpSnQJ zFfMzUshQAt1T#e$%Gt#>Et&ky4NtE!5G=`zRe-?XBD==w>Z#NcO#LBe{U+E49HwS&& z8F=}o5gD3aJM4sleudPe#kG+yopT9eD(iAw(<@Lv_Wypa>xSvkcd%~2%bmNI+C$c{ zBA=BM=LDR_eww`lJeb;ZPooaG0CK@6D*_sN%@|2=ShJD)_sL!%HY&qw$#rO`T=DdbCHI7q|Om<0;(flXf`kZLOjeS+B%z3&-6 zx2Sm0%<91MO_r*ek!Qs{mgtkR8~$adF4!mcc`z_qRIFDxnW)`@X*Vj;efe7t z^@<_bk6i(rK;c&aposZV_aE-iU=gqJ!ilG4CVVm{_KDhF7NijPN_86mGx%z+veSJh zV@(@=$T7Z`_UzR8{Obw~&xBfQfV$@W>^+kc3H4rF(LDY7c}gUmc3r`}qnA;ECCPr) zt2dZs~`8*?wfB1}Zp8kx6*6)56&kqfN7ol?d`km{~{gc{QaU|Ce zc-#I$yQRwB@GR}f=JVl{05-!WYgvmRxC)zRC(;42kkinlpdj`u08X`btGay?9nz^! z%`^M~ZcbbJ`=r<_dG<--Wz^+INT<0HCvgDG^22Gwe0eWPkX2~yfo55?ylUu1QwM^U zhCN+P68H7e57Mcv5JaMegnCMeXODyr`D=irg*dmX(`<;764eO@QI`MlPkHTx;5 zEH$beZ}~$x=7kcg z$5V9E>m>@@=JIbN9_fgB?aRGo<-V`Wl`+-zn!BAZ_DG8^<}zUAV)6w%`+)oX=lpq( z6SkA%!m=A`LkGQpcR&u`3-^~iAUu*~ppc&ZK-ZPGac(>K08Jk$7AJt$on;}P;AU#t@s4@kUyE0Yd0UdFoDj3vC?3;cR ze(>ts2PtG|*TWR41F=sQ3OCl1goQfXb>7SV{8vKc+j%}c?_9+?M9&cQ8^5ywi4NRt zxSLTVG{jW|1EI0yg~=};Atv0e<8{CG{G~rDPd$VHUyzp=od+59HUS+*g4!z-{GAS5ApmGNZDKQhr0%y9uZuYhu zjue#_TGX7EN8Ul!j6_dG#=mZ%(wAYC)gJ^$;mj^gRn|<-`LeckzY@nAjJ>_nYxoxd$%9&&-Y66zr<-$1mGm0$BdeRTzk zOTkLGPu7AAuzW46o1(F$G`|*jQk7{Ae_yYce3A5U6v7H|<({=Tg_0jwiWW{h+Ff%k56Fq|xGE!}t*fE@FR znW-J0mg4X}E#0_V74-|J=Ms9ZwkB9K;l2F05_mqMG!N%XqLO7Pux1cjI5~JDY;E*1 z!tQ*_jO$yQW~Ce|?A?Wp(nnBnMcIuHBo+cJDZ7Ipphi`J4~iJx*!dL&7EyfPBs)1P z`KBYwc2Yt8$gsumSJ>c{6nDd~6cs zzJ(y?gdlJRVjJ1H_^n8NBXSu8%t9Ca>?RF0S_ZB!np8T(UqF_vp%1!*te-oHJ7rV(@{1E7a*Lb=*3go4KQ@SO9_N@gXUHAFd5jF-g~?} zY17}H|LzudIJIuQnM zZBrOfRITLQOR_;9^(&VaX8tXAanF~!NcmSBWc1DTt@%qHFLxv2-5sk6heG|xmcISk zP@5-G;C@>IYTNzy@12suD3%zvUe42jdkNAn0a9{Vf3e(=!4S?){iG18{p*2zpOx+p zIS)nCt{e+Z%Ak)~)T9vlqS-W*cN>nhWOZ< z`@vD)#ln+|U<2VzZ=ByPX-^SsTxXJ`jG=dM63^oqgo|Fb;Oqv3r1#?<@PHAMx-frW z@BHnmUjy9pk%?uF-=^QEFyDxwcj0+3+T7AT&g$~ULN?xMRa>)b2Fx{8`9x$-*jc39 z)?e7A(#rm0eIkvankt~Igo5QBlQJ;Tf+YBM^5ea*lcy!PujNh+Sv-vqU7Lv8u*&T! z$@M$QwT_he?%%EjNU;vZ4JP&&1yHWVTa0s)kf@W7q;(z4Gj<0i#oaX{@0mdlLyfEd z*cZmNY5lwRvYEVrRm`3BGqR6c&duz4g>5eG{kIj7+_R!`MF~<2F0b8%8~4bfr+qfh zI7{14lQ@NG*65n)xf_`7ylx?;r?6BAbiu~KIzQgOtDQfCh`jd66|QqUZ=dvdb#Zdz zAI!LWne{}HgPCcLe7VTNvDt~4wxVGSHIZ;v?!C2}X{=wxJ7fT7&^0y3p?ZDx;*+xJ zkt{HFSKc6g#lHIy^#`a5!lJ7%4$F#$!Zb?Af2THBCnh5F4Ek08ps&AA@+rcfv)aj^ zfq3Gra^xFg)*^rD1{4(rC!hXdI3`gBsvqPdPe}n@Gpfk|1&|+ev0N(1o^$< zt@!0tUGYfQKn{lX)z^36eC$x(uo(CBgbWD}#0+WLdMnCzz4=~(n(EfM_XSC)mr@TN zzR?~OuLv3_j$M`oZmfsPhe(`o7jQWVqGbf!sbx_G01cA>R)u3Uo8rie?HADzajo(O zDoqxvi&^492EhxJih=lrz|$N+@czPHCoq-ucm?eJJ9Ct{fSNicW*4aO{xqNrMRUY6 z0<({Zw~7a)=`W7@Ac*s`9AIs)spqojxmR+MSk^N7sKA%<=eVx*4s`H`Z^FA^WVH#o z{Hsm=8@e6zWXZ8XW7h(*f*s)?iJOybvZO^Bm(%9u=b;=7={pM-M9F}RHgNN^otV+7 zK5?mfUA+^kP#F-b2`NHJfdc6sjRfd^eX59fq&CJRIH#aSuE}F3vzLK7JYH)AF>P6C zchEyCUNms{Dfk(Udu0h;J5xnp7!^Ct%Ltu;GmPYm?OQ_TBV(qHhAI?tOJQspyKcwk z?LyY(Tk@(N$0c{fzM4r#C_Q$}qH8jYwDS*RQw0tFwym)N5gfzP9CGq@xFaBSymGZp zoIP!(F{*E&_h!bqC~<$%#vbt*0+-swEi?Dl>B|SZa}B};$CNmTV{%0i=$Bc>e4n^m zvtH`tfU`}4^=mNbr~@C9p+w58pRQ*HP3N&5559ebgDHdARxFrzK=shQ2xm7FYyado zjAA{`^-_tk7!FF0Tg)p||FmNmjGJa~(U&SvHZVetP?w2(a>mrn{1|6dq2Rc4Ebxx` zzzm4Lai9);;daA6X-(3&P;ATah=%$;)x%6SuZZMRPZ|!Fi-{mp##w0iU36p%_e!RO zGG_Sp{G-JDo)0yXC|`cp&tLZ_qpj3GS`BMTNJ!l1`Eklf7p(eIGf~--hHV7{PCY+g zg?+g(UtMd!L`K2192bc0CMCf=_%|&Xxr!g7`ui|Shm^<9k~wEuw5j%4NpjBV&(j~S z&74`e`3v`B{t1p0-ejYYT3dc>YA1_gL$F}g;H3B$r0W2w(sdCP5Bb>6?C>pcvgFUt zE*M{$gSWZ%dRHa6iLH%GDKPa5>g~HeG|Y&QUDr;A_e*R6p{^TUKAH{*`}NH*QgG$% zSxE|$k*`(fLs4eaWefaCzAg8ZZ{gt^WcQ$oZLpF{` zVD5;1^fQB#UT`P=87}Puiv0x!w5N#qhwPPFV|KA!BXhk!eT+LR|C!UIbt5-boqE=p z#V0rwBnX~p$Ed|wYmDtH*kUB!xqT&4CZ2_Sn-C+k=SL=n#yi=vWjlTk^G^|bINNzw z7*+c*AAbokNmv`lItv}yL?kG)p(Q<;>j0wywJ#n6D_5v_^2o>je)Wo^BY6A|uLb9J+|fSN}d*4h%{~O5Lqbn zJ=t?RdCv+Mn+A^e;z{|dHorop?YL7J69{U+ED+)x&;Ld9PwEh7(>#^e^3yC!9~56M zDZTTg{nkeC@3VioLIbjH-@Oiwi(Xu^Vq_Gu5A=#}@`TF!b@VY7oe&(F zBQdSYt|;yz4Jc&L1Sl)hkDei6nSfzNKTvi6MP4DwYsbTtS+zyf7Jn-)r9A4cBTuwI zY4I^9=)CdB4x}##rH~3_-iE;bTdK#w_7JVGVoi=e84=0MY?m$s7R&CC;DkeMNPCfL zKNK5w@M`khd3n#PkCbx>Lbn1QXu?ekB{o4K74jq9hs(Ow$O~_{MSzME3P8CBKFN89Jl>2s)V{Mo0Xz2k5f;4hHiB3rpvmD1bi$BHiM z1T@#GuI>@Zog~&!1H&?Ij#*0%Zr2AbLOmr$d;^m<=kgk@=f{A}f4)MjG30`r%f0>9T zKrr#|TIJ8{QprY-37j}T?BVjeIND()SGgHAY!r%RIt`O`b}6t|;iLG1PTnCeq~d0y ztR>;i-t|bJz$=~tum?_l&9!7@UWBr~aVA5A7{t+?KioUTwV1&kbhYzbeuyHg!jw=)}vcS@AJ{s?_})BM$M zkzHydkZ4EhD}ipF{d%v67=)@@;U<9{1OH0ALqvjUzfn&N={fK`S{vMYWA+TZzt)z= z!%!4^Lg7K01VA4c*@y@w-n3p2jbvG)Z^QQ|FJ==ecT*_v@fm~}PWfaD7NG+uJ;AE}*kV2vDIz?rc zzYT z>xp{((X;$ovV>7w(WQbv<7qwSbL$}?a&@2Srn5WVphdr1bvW4$e)} zb{`CvGb3d7WjkOQSK~(64aQFdE$SQ&d&*(y58S&HL>E|Xu7%diRIKV1RF;wSyzq}} zP`Gjj+hDf!R_s)0bpmO{d2$1+VFzEf*FNt>q{%J7A-mjhmn$y}OzqDMJq))6Du}Nwh zBl33Xqp}DUf&inm2jc*_%>LsABOXqwC4au+gI6!cF$;&(B!t-^T2xS~fQH~&UKx-q zhuDq*!s@oDa(*I7BMFry3936eG{ZmHH_$K;@efOn$I0kqJe52o`)GnPII|_VNP!~| z5+~EI^&Q|13`@*7tpFs;8CMmDqFW9;mK<{x*C@R4H4K1hrWTQ13=zx;d7IE9VR zV@dU6&?JKw>T1k2ZsT1~c}S#HGSjn3-;Zp;X4=wn5oy~lDsxZ3D#G+86>HuURUgq1fE56bnR&y>SjNGs zgWAlI$?OkiBZ~>-lNW|A`{_;n9Xrdd0QbA`&_+Y9++QdhMDAE{Q4lX%?xLcOE?PAh z1ZG<}eAd;-eF#ls+i6yy_u;$(6!>05M)&z*vs;|FE?>>f=lj_`8LFMg`%ZG$yK`BJ z0t$B(1(i%f;*`}h&$`^^MS4IqKJo$O2d=)z?8Ryg{ddj5<%-p!5RJ>_Q<5_mp1DPQ zeE4g+Qae6J?B|g8Y!iy$EI8TrUP*@B&A{S&zDr5@!NcE;#vgp+U&tC7gctp<05A&A z_1M;OrkP4sKcTOOU$mu%iFCN0_2Ij;ya1)dEVDx}ZQO{mjj0$gyzh#{x#gneH z;N3|0cT$x3j}&KhrNQ8k@tzJw22`ti^Iwa9v)Ap>;*Wzmf~#CK_H00!Hu>Y25AVi! zCm8{T7-xf;{R{n;f8e8f4~}DoG{1vLxsf(J6HA*(3C2RZb00?G@y32*lUTU8?rNoV zW_>O2d-kL8@9cfzwTo40G@D~ESDSyCrCzAX$vq=D4fnCPpd_5v*&ZhSv~9jJcxp>) z3#~rh%~6J;v&s?YOyHFbm1vGZAQIhj0)kJ)zZ3reXjoX-sp>lj40?4q}T!e?R%%i{{Vx!R*$MdsA_vH zw5<+BzPypJa;QTE1G_N+Kpc|T9M{SoEAc%3GVwmAs!tlD>X&levPR{WHj#^!Qb{{U zL7v#IxW>%EO8S-BP-E(O$?Mmk>Hh%Nr^^2TyUAXsA74^Es;Ujmp1JRwrpH0ljqNK{vVGNo@fjK8+Y;seLv6R??$7$EVPD0$;UasrkO+f zd-1@i3i40PPa^>1JdS<2q>1;a@0Z%;k z<2n30RAIt(AA6<;Q&E}ngRdL_4^Da?%e^6R&9iEZ^iJoJeW))|M{r}>2j0(of+`!F zp~ok<1a!w=tv{HQdz`jE1JCFB)n~*x!kjKf0q@_B^VWdWihcr|cIUo-$Tddb6Zq$o z(-nT>7{DO<;;FLt$4)cf-}R-aYEhXuKK{MxtkG{jp~rf=EJTBkTy*?u2V5T6#(LBR z(Vq6$&NG^)CAJ$F;PP`?awysQR1z=A@`KMHfx)1AnKxGZB>M6VXU}LKw;lM+Z%qg- zj_Xw?wcMWApbl>HPv`sD=jmBjT3Bv=Zn*1RUDco~^*oPCrFmcm2HYG90OIeoq0b%b z7XJWB#(4VIcYCMgecXRq%e~Tk!<-KFJfM00p`_$={VNvxOW02zi0@v7d!&b6m5qI* z<2-(pxmX+|)|CT6wz`Ym9|ZCGR!!EQu=L`P?#!CMqIiPy!`EVaN#%k??v0H0=Ao9< zgHW_ZO$DDx{2~7Uf|h(m_-Emt?3*287-QTDeX7nI$dCfWg%YEAc`QlUfP3_>slVWz z-|$p#5Bxfx#54RxytcH|FDLWklGjf1?e1eSpxUW#8C76o1pK*j#QemX{KR2{SM-*a zYlV$-iqF}lst2k+OTTD;_$UN_wQj!ldMr}uei>OqEG}^+`;K?XjO|c<>Swm&&ecu^ zHQcyetH|xw{PX$x*MNK)nY6-~-|vHhNF9G#_iZluZX*ScIN%;Tdj9~P)x35yO2zmi z+NV4Wr92ZE+}|_((r|djIsTPhUACTgVM}%C{(mmGr|;j+SwfBo9D5&X zU``mJ=z9`D;Pd`}I!NWCWOu+EoEzsa}{Qm$t9JQ$=XCKhH{Q&HJx2kG;k^pY#3{$CL$5 z`?3KYGxhcURB8jI2Q8UQn8?UH~h^<4nw%CfjUI{Ouia$FCGA{o%_A2SK!BBOSlbr9dUXapmv{U^xU2^Nu}* z9(G-G_hjna3?2vb^`N~+NjjGyiu#g4A&Ku%{{X6w<>)c@y|MNG06C$g-yj(IU!lid zryu9(OlR7>XPl6KKgNOvZ4V&ejmLqHtygcq?~nlNnwodo?m78;dSjpQH4KBN;f(z_ ztjdX2Mc5a&9=~6&y+tailZEyN*S%Pq=Hz!gW}tD&a1x$i&}EtZCc!*)=uSSB43UH!{oM2v0h=Tr zmv4HjHLg^TPJhqjYgTB=jAxATimyGt%007>dH}_^vfRGd$m8o-_f|lTI%o5)ifc>^ z0mgl5l-9mtocH6J0Ojtq{n_L6th>E15Oez1U3F)Wc*xIOVyIo|;3?w=>p&bu?v%Ta z2c=}*X&bY}cQ;yQSJY##rDopgTYsHq2LXGe^NqEebElZkLtWMOlkHhIdO$tDIsoL2 zm(R~k*HhsAJ~%?0bJnW1kC{Ku6}6#Rd2Ta6?#|=E@-4ip{39Ik*1dbfI)O2c3XpIz zNgeQO$h<9XOv&5V=z7FJMLf&Or4)CtAM zJAelq<+=Wz)f-G39FF4z=Od}<>q|6@kF@1jCTbYaGDdj5W&T4TZkU+2ve_DgXcg literal 0 HcmV?d00001 diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index b9e77baf..6d0aa2f0 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -47,6 +47,7 @@ add_executable (tsl2561-example tsl2561.cxx) add_executable (htu21d-example htu21d.cxx) add_executable (mpl3115a2-example mpl3115a2.cxx) add_executable (ldt0028-example ldt0028.cxx) +add_executable (am2315-example am2315.cxx) include_directories (${PROJECT_SOURCE_DIR}/src/hmc5883l) include_directories (${PROJECT_SOURCE_DIR}/src/grove) @@ -83,6 +84,7 @@ include_directories (${PROJECT_SOURCE_DIR}/src/tsl2561) include_directories (${PROJECT_SOURCE_DIR}/src/htu21d) include_directories (${PROJECT_SOURCE_DIR}/src/mpl3115a2) include_directories (${PROJECT_SOURCE_DIR}/src/ldt0028) +include_directories (${PROJECT_SOURCE_DIR}/src/am2315) target_link_libraries (hmc5883l-example hmc5883l ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (groveled-example grove ${CMAKE_THREAD_LIBS_INIT}) @@ -133,3 +135,4 @@ target_link_libraries (tsl2561-example tsl2561 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (htu21d-example htu21d ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (mpl3115a2-example mpl3115a2 ${CMAKE_THREAD_LIBS_INIT}) target_link_libraries (ldt0028-example ldt0028 ${CMAKE_THREAD_LIBS_INIT}) +target_link_libraries (am2315-example am2315 ${CMAKE_THREAD_LIBS_INIT}) diff --git a/examples/am2315.cxx b/examples/am2315.cxx new file mode 100755 index 00000000..4b95e1c7 --- /dev/null +++ b/examples/am2315.cxx @@ -0,0 +1,75 @@ +/* + * Author: William Penner + * Copyright (c) 2014 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining + * a copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sublicense, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +#include +#include +#include + +#include "am2315.h" + +volatile int doWork = 0; + +upm::AM2315 *sensor = NULL; + +void +sig_handler(int signo) +{ + if (signo == SIGINT) { + printf("\nCtrl-C received.\n"); + doWork = 1; + } +} + +int +main(int argc, char **argv) +{ + // Register signal handler + signal(SIGINT, sig_handler); + + //! [Interesting] + float humidity = 0.0; + float temperature = 0.0; + + sensor = new upm::AM2315(0, AM2315_I2C_ADDRESS); + + sensor->testSensor(); + + while (!doWork) { + humidity = sensor->getHumidity(); + temperature = sensor->getTemperature(); + + std::cout << "humidity value = " << + humidity << + ", temperature value = " << + temperature << std::endl; + usleep (500000); + } + //! [Interesting] + + std::cout << "exiting application" << std::endl; + + delete sensor; + + return 0; +} diff --git a/src/am2315/CMakeLists.txt b/src/am2315/CMakeLists.txt new file mode 100644 index 00000000..5931421c --- /dev/null +++ b/src/am2315/CMakeLists.txt @@ -0,0 +1,5 @@ +set (libname "am2315") +set (libdescription "libupm Humidity Sensor") +set (module_src ${libname}.cpp) +set (module_h ${libname}.h) +upm_module_init() diff --git a/src/am2315/am2315.cpp b/src/am2315/am2315.cpp new file mode 100644 index 00000000..9cea295b --- /dev/null +++ b/src/am2315/am2315.cpp @@ -0,0 +1,368 @@ +/* + * Author: William Penner + * Copyright (c) 2014 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#include +#include +#include +#include +#include +#include + +#include "am2315.h" + +using namespace upm; + +char g_name[] = AM2315_NAME; + +AM2315::AM2315(int bus, int devAddr) { + m_temperature = 0; + m_humidity = 0; + m_last_time = 0; + + m_name = g_name; + + m_controlAddr = devAddr; + m_bus = bus; + + initialize_priority(); + + m_i2ControlCtx = mraa_i2c_init(m_bus); + + mraa_result_t ret = mraa_i2c_address(m_i2ControlCtx, m_controlAddr); + if (ret != MRAA_SUCCESS) { + fprintf(stderr, "%s: Error accessing i2c bus\n", m_name); + } + m_model = i2cReadReg_16(AM2315_MODEL); + m_version = i2cReadReg_8(AM2315_VERSION); + m_id = i2cReadReg_32(AM2315_ID); + + fprintf(stdout,"%s: Model: 0x%04x Version: 0x%02x ID: 0x%08x\n", + m_name, m_model, m_version, m_id ); +} + +AM2315::~AM2315() { + mraa_i2c_stop(m_i2ControlCtx); +} + +void +AM2315::update_values(void) +{ + time_t ctime = time(NULL); + if ((ctime - m_last_time) >= AM2315_SAMPLE) { + uint32_t uival = i2cReadReg_32(AM2315_HUMIDITY); + m_humidity = uival >> 16; + m_temperature = uival & 0xffff; + m_last_time = ctime; + } + else { + // In case the time is changed - backwards + if (ctime < m_last_time) + m_last_time = ctime; + } +} + +float +AM2315::getTemperature(void) +{ + update_values(); + return (float)m_temperature / 10; +} + +float +AM2315::getTemperatureF(void) +{ + return getTemperature() * 9 / 5 + 32; +} + +float +AM2315::getHumidity(void) +{ + update_values(); + return (float)m_humidity / 10; +} + +/* + * Test function: when reading the AM2315 many times rapidly should + * result in a temperature increase. This test will verify that the + * value is changing from read to read + */ + +int +AM2315::testSensor(void) +{ + int i; + int iError = 0; + float fTemp, fHum; + float fTempMax, fTempMin; + float fHumMax, fHumMin; + + fprintf(stdout, "%s: Executing Sensor Test\n", m_name ); + + fHum = getHumidity(); + fTemp = getTemperature(); + fTempMax = fTempMin = fTemp; + fHumMax = fHumMin = fHum; + + // Then sample the sensor a few times + for (i=0; i < 10; i++) { + fHum = getHumidity(); + fTemp = getTemperature(); + if (fHum < fHumMin) fHumMin = fHum; + if (fHum > fHumMax) fHumMax = fHum; + if (fTemp < fTempMin) fTempMin = fTemp; + if (fTemp > fTempMax) fTempMax = fTemp; + usleep(50000); + } + + // Now check the results + if (fHumMin == fHumMax && fTempMin == fTempMax) { + fprintf(stdout, "%s: Humidity/Temp reading was unchanged - warning\n", + m_name ); + iError++; + } + if (iError == 0) { + fprintf(stdout, "%s: Device appears functional\n", m_name ); + } + + fprintf(stdout, "%s: Test complete\n", m_name ); + + return iError; +} + +/* + * Functions to alter the thread priority while reading the sensor + * to ensure we can get good data + */ + +void +AM2315::initialize_priority(void) +{ + m_use_priority = true; + this_thread = pthread_self(); + + base_policy = 0; + int ret = pthread_getschedparam(this_thread, &base_policy, &base_params); + if (ret != 0) { + fprintf(stdout, "%s: Error accessing pthread scheduling.\n", m_name); + return; + } +} + +void +AM2315::high_priority(void) +{ + if (! m_use_priority) + return; + + struct sched_param params; + params.sched_priority = sched_get_priority_max(SCHED_FIFO); + int ret = pthread_setschedparam(this_thread, SCHED_FIFO, ¶ms); + if (ret != 0) { + fprintf(stdout,"%s: Unable to set thread priority.\n", m_name); + m_use_priority = false; + return; + } + int policy = 0; + ret = pthread_getschedparam(this_thread, &policy, ¶ms); + if (ret != 0) { + fprintf(stdout,"%s: Unable to get thread priority.\n", m_name); + m_use_priority = false; + return; + } + if(policy != SCHED_FIFO) { + fprintf(stdout,"%s: Unable to change thread priority.\n", m_name); + m_use_priority = false; + } +} + +void +AM2315::normal_priority(void) +{ + if (! m_use_priority) + return; + + int ret = pthread_setschedparam(this_thread, base_policy, &base_params); + if (ret != 0) { + fprintf(stdout,"%s: Unable to set thread priority.\n", m_name); + } +} + +uint16_t +AM2315::crc16(uint8_t* ptr, uint8_t len) +{ + uint16_t crc = 0xffff; + uint8_t i; + + while(len--) { + crc ^= *ptr++; + for (i=0; i < 8; i++) { + if (crc & 0x01) { + crc >>= 1; + crc ^= 0xA001; + } + else { + crc >>= 1; + } + } + } + return crc; +} + +/* + * Functions to read and write data to the i2c device in the + * special format used by the device. This is using i2c to + * interface to a controller that the AOSONG AM2315 uses to + * perform the measurements and manage other registers. + */ +int +AM2315::i2cWriteReg(uint8_t reg, uint8_t* data, uint8_t ilen) +{ + uint8_t tdata[16] = { AM2315_WRITE, reg, ilen }; + mraa_result_t error; + + for (int i=0; i < ilen; i++) { + tdata[i+3] = data[i]; + } + uint16_t crc = crc16(tdata, ilen+3); + // CRC is sent out backwards from other registers (low, high) + tdata[ilen+3] = crc; + tdata[ilen+4] = (crc >> 8); + + mraa_result_t ret = mraa_i2c_address(m_i2ControlCtx, m_controlAddr); + int iLoops = 5; + high_priority(); + do { + error = mraa_i2c_write(m_i2ControlCtx, tdata, ilen+5); + usleep(800); + } while(error != MRAA_SUCCESS && --iLoops); + normal_priority(); + + if (error != MRAA_SUCCESS) { + fprintf(stdout, "%s: Error, timeout writing sensor.\n", m_name); + return -1; + } + crc = crc16(tdata,3); + mraa_i2c_read(m_i2ControlCtx, tdata, 5); + if ((tdata[0] != AM2315_WRITE) || + (tdata[1] != reg) || + (tdata[2] != ilen) || + (tdata[3] != (crc & 0xff)) || + (tdata[4] != (crc >> 8))) { + fprintf(stdout, "%s: CRC error during write verification\n", m_name); + return -1; + } + return 0; +} + + +// TODO: Need to patch up function to return only the data that +// is needed and not require the various functions that call this +// to send it enough buffer to cover the function + +uint8_t +AM2315::i2cReadReg(int reg, uint8_t* data, int ilen) +{ + uint8_t tdata[16] = { AM2315_READ, reg, ilen }; + + mraa_result_t ret = mraa_i2c_address(m_i2ControlCtx, m_controlAddr); + int iLoops = 5; + high_priority(); + do { + ret = mraa_i2c_write(m_i2ControlCtx, tdata, 3); + usleep(800); + } while(ret != MRAA_SUCCESS && --iLoops); + if (ret != MRAA_SUCCESS) { + fprintf(stdout, "%s: Error, timeout reading sensor.\n", m_name); + normal_priority(); + return -1; + } + usleep(5000); + mraa_i2c_read(m_i2ControlCtx, tdata, ilen+4); + normal_priority(); + + uint16_t crc = crc16(tdata, ilen+2); + if ((tdata[0] != AM2315_READ) || + (tdata[1] != ilen) || + (tdata[ilen+2] != (crc & 0xff)) || + (tdata[ilen+3] != (crc >> 8))) { + fprintf(stdout, "%s: Read crc failed.\n", m_name); + } + for (int i=0; i < ilen; i++) + data[i] = tdata[i+2]; + + return 0; +} + +/* + * Functions to set up the reads and writes to simplify the process of + * formatting data as needed by the microcontroller + */ + +int +AM2315::i2cWriteReg_32(int reg, uint32_t ival) { + uint8_t data[4]; + data[0] = ival >> 24; + data[1] = ival >> 16; + data[1] = ival >> 8; + data[1] = ival & 0xff; + return i2cWriteReg(reg, data, 4); +} + +int +AM2315::i2cWriteReg_16(int reg, uint16_t ival) { + uint8_t data[2]; + data[0] = ival & 0xff; + data[1] = ival >> 8; + return i2cWriteReg(reg, data, 2); +} + +int +AM2315::i2cWriteReg_8(int reg, uint8_t ival) { + uint8_t data[2]; + data[0] = ival & 0xff; + data[1] = ival >> 8; + return i2cWriteReg(reg, data, 2); +} + +uint32_t +AM2315::i2cReadReg_32 (int reg) { + uint8_t data[4]; + i2cReadReg(reg, data, 4); + return ((((((uint32_t)data[0] << 8) | data[1]) << 8) | + data[2]) << 8) | data[3]; +} + +uint16_t +AM2315::i2cReadReg_16 (int reg) { + uint8_t data[2]; + i2cReadReg(reg, data, 2); + return ((int16_t)data[0] << 8) | (uint16_t)data[1]; +} + +uint8_t +AM2315::i2cReadReg_8 (int reg) { + uint8_t data[1]; + i2cReadReg(reg, data, 1); + return data[0]; +} + diff --git a/src/am2315/am2315.h b/src/am2315/am2315.h new file mode 100644 index 00000000..d4aea832 --- /dev/null +++ b/src/am2315/am2315.h @@ -0,0 +1,195 @@ +/* + * Author: William Penner + * Copyright (c) 2014 Intel Corporation. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + */ + +#pragma once + +#include +#include +#include + +#define AM2315_NAME "am2315" +#define AM2315_I2C_ADDRESS 0x5c + +#define AM2315_READ 0x03 +#define AM2315_WRITE 0x10 + +/* AM2315 Commands */ +#define AM2315_HUMIDITY 0x00 +#define AM2315_TEMP 0x02 +#define AM2315_MODEL 0x08 +#define AM2315_VERSION 0x0A +#define AM2315_ID 0x0B +#define AM2315_STATUS 0x0F +#define AM2315_USER_A 0x10 +#define AM2315_USER_B 0x12 + +#define AM2315_SAMPLE 2 + +namespace upm { + +/** + * @brief AM2315 humidity sensor library + * @defgroup htu21d libupm-htu21 + */ + +/** + * @brief C++ API for AM2315 chip (Atmospheric Pressure Sensor) + * + * Measurement Specialties [AM2315] + * (http://www.aosong.com/asp_bin/Products/en/AM2315.pdf) + * is a digital humidity sensor with temperature output. + * RH will report between 0 and 100% and temperature range is + * -40 to +125 degC. + * The sampling period of this sensor is 2 seconds. Reads occurring + * more often than that will return cached data. + * + * @ingroup am2315 i2c + * @snippet am2315.cxx Interesting + * @image html am2315.jpeg + */ +class AM2315 { + public: + /** + * Instanciates a AM2315 object + * + * @param bus number of used bus + * @param devAddr address of used i2c device + * @param mode AM2315 oversampling + */ + AM2315 (int bus, int devAddr=AM2315_I2C_ADDRESS); + + /** + * AM2315 object destructor, basicaly it close i2c connection. + */ + ~AM2315 (); + + /** + * Get the current measured humidity [RH] + * Data is updated every 2 seconds - accesses more often than + * that will return cached data + */ + float getHumidity(void); + + /** + * Get the humidity cell temperature [degC] + * Data is updated every 2 seconds - accesses more often than + * that will return cached data + */ + float getTemperature(void); + + /** + * Get the humidity cell temperature [degF] + * Data is updated every 2 seconds - accesses more often than + * that will return cached data + */ + float getTemperatureF(void); + + /** + * Function intended to test the device and verify it + * is correctly operating. + * + */ + int testSensor(void); + + /** + * Write four byte (32b) register + * + * Note: These access routines are not the normal accesses to an i2c + * device. The AM2315 contains a microcontroller that manages the + * actual readings. These handlers then make requests over i2c using + * a protocol defined by the AM2315. + * + * @param reg address of a register + * @param ival 32b value + */ + int i2cWriteReg_32(int reg, uint32_t ival); + + /** + * Write two byte (16b) register + * + * @param reg address of a register + * @param ival 16b value + */ + int i2cWriteReg_16(int reg, uint16_t ival); + + /** + * Write one byte (8b) register + * + * @param reg address of a register + * @param ival 8b value + */ + int i2cWriteReg_8(int reg, uint8_t ival); + + /** + * Read four bytes register + * + * @param reg address of a register + */ + uint32_t i2cReadReg_32 (int reg); + + /** + * Read two bytes register + * + * @param reg address of a register + */ + uint16_t i2cReadReg_16 (int reg); + + /** + * Read one byte register + * + * @param reg address of a register + */ + uint8_t i2cReadReg_8 (int reg); + + private: + + char* m_name; + + int m_controlAddr; + int m_bus; + mraa_i2c_context m_i2ControlCtx; + + void update_values(void); + uint8_t i2cReadReg(int reg, uint8_t* data, int ilen); + int i2cWriteReg(uint8_t reg, uint8_t* data, uint8_t ilen); + uint16_t crc16(uint8_t* ptr, uint8_t len); + void initialize_priority(void); + void high_priority(void); + void normal_priority(void); + + int32_t m_temperature; + int32_t m_humidity; + + uint16_t m_model; + uint16_t m_version; + uint32_t m_id; + + time_t m_last_time; + + bool m_use_priority; + struct sched_param base_params; + int base_policy; + pthread_t this_thread; +}; + +} diff --git a/src/am2315/jsupm_am2315.i b/src/am2315/jsupm_am2315.i new file mode 100644 index 00000000..f6baf25a --- /dev/null +++ b/src/am2315/jsupm_am2315.i @@ -0,0 +1,8 @@ +%module jsupm_am2315 +%include "../upm.i" + +%{ + #include "am2315.h" +%} + +%include "am2315.h" diff --git a/src/am2315/pyupm_am2315.i b/src/am2315/pyupm_am2315.i new file mode 100644 index 00000000..a0f0ad7a --- /dev/null +++ b/src/am2315/pyupm_am2315.i @@ -0,0 +1,13 @@ +%module pyupm_am2315 +%include "../upm.i" + +%feature("autodoc", "3"); + +#ifdef DOXYGEN +%include "am2315_doc.i" +#endif + +%include "am2315.h" +%{ + #include "am2315.h" +%}