From f17c4c609f1ae69e2d96af39d5415e8ffa32715a Mon Sep 17 00:00:00 2001 From: samarth Date: Mon, 18 Dec 2023 14:00:02 +0000 Subject: [PATCH] Update --- CMakeCache.txt | 3 + bin/main | Bin 0 -> 26072 bytes bin/main_test | Bin 0 -> 17280 bytes include/signal.h | 2 + src_autogen/candata.c | 439 ++++++++++++++++++++++++++++++ src_autogen/candata.h | 609 ++++++++++++++++++++++++++++++++++++++++++ tidy-output.log | 184 +++++++++++++ 7 files changed, 1237 insertions(+) create mode 100755 bin/main create mode 100755 bin/main_test create mode 100644 src_autogen/candata.c create mode 100644 src_autogen/candata.h create mode 100644 tidy-output.log diff --git a/CMakeCache.txt b/CMakeCache.txt index c273c5e..106e661 100644 --- a/CMakeCache.txt +++ b/CMakeCache.txt @@ -209,6 +209,9 @@ CMAKE_STRIP:FILEPATH=/usr/bin/strip // Studio IDE projects all commands are done without /nologo. CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE +//No help, variable specified on the command line. +EXPORT_COMPILE_COMMANDs:UNINITIALIZED=ON + //Value Computed by CMake dbc_example_BINARY_DIR:STATIC=/home/coventry/Documents/7166CEM diff --git a/bin/main b/bin/main new file mode 100755 index 0000000000000000000000000000000000000000..c546fe556bccfd0f161f49ccd1378267da06b8ca GIT binary patch literal 26072 zcmeHQ3wV>&-9KrG+(}VTK!G5aRe{i!i-4=W5e(XLDXrEErXfjbq-{!)UT}b&3?=JO zoIJ`m-DGofY`V#&Lu8uO*)Hl#`vN4M4?I>bw*}i3ft$5^=0duTvg9m4@8>}7KXxZ@G&tKX>y5n(8z-7fX z3D-1SSK*q0%Z6(fE-ExPsCU=knvZKCE-F8Ha_i8wcYkd|#kj3QH;=r#;86`4GxmJ>3wI7K`OQbqt=#>qw`aY-_vnhn-BT|6TCx4t zr`$7YfA{X??>#Vk^*bL8TlmP(`1k)XuI`KHEX7Uhp4nTt>rd8Sp51WV`$qjW&%9Z* zYa^>%_40!EpE&#Xn?(!yzn%sp-?9n97=o7!e=Y_7+Z6bg6gXgJO{h^YZ>7+`7=xFr zJp(bY$?#87_!*kQ&+94lPo=;Yqq)iIZBF5TR|=fwlvQ*+;dMlcdjFULZ-I5P_Pmk; zr#WlIWi0Qe@PBIx{CjYatlokY`iE2CpCCRX**G?)TC_+#R}XOgEH*t?;Bi4%1CM7G zGtrw6B^!EFO89)pV$3^)mty2Fx+|O9XswE)FRO#oc&k3MJ_V=sM zr?^d%`e1qavGl)rrr@(+Pi46DbIj156|!Dqe5$1X+11>f$!ghL>3{GPfoDm=%S(%Km=c(BJQ% zy;n*dJvl7>=Tr++_4i8>pCNIuysVb(&z88F4>754mH0(MoiXQe}gj^as@(8r%+9*=yo-DTp^d!<#T!hzGkm8;9b|`4TfOq z^#*(mYc#;)b^ASDmeQam;BN>yLxFV{Y|+%v=yI>sJl6X|{(#fn6bN|XDByMVG2VuR zx|`ii&eg6EI=$X$aMG_I+|PMhm00U}8YKFsnwO+SEwx^6oio_z^?HJ;Sx%?B)#a@5 zHMr`0chRt55#yG_Qt$FLu%O?))*E8=-ufU&V^b)|f}uczyKy}W)_J{+Y_+e!!+d^s zsE(xWT2}yGFs|;kPIv8EXN}7T0R}2m!{CA3`5Qxwsu3fL1rq0Ip)`+T?R5Ja8ocfh zyJ=Zzg>!LvQJLMjxU}ec=Je7`U`3^+oOiCYSFkcytFxR&qI`LoFs}0lz3e7`UC6b@ z%f*ZNxRV^Hv)NVG#3u<2pa)Imvy0C|Rw9SC#8u~Rs&j>W{ssm+eH$7Bez!Lmbk+o1 z^$6FJW$3EM*WhdldOfTHbF19Djs+U)(O86qdeai{g+zt?u7>Jd4G*Hq3V#68nXG71 zvx@Q+`r4@SVmXgWmy|83u$Ob6)O0wa_R0=jU%I5Y#F=NC!_?jEzS}(8TsEuLU+=0K+o*Pd~ZM0L3QD#`VGboiwl5ih+ue4Y-s zN_-$N6%!I?>u~ifCOk)nt7kFc^L4nH09gukIMtzwLx-yvk!-mRN1(M*rNf74C}Y(+ ze5eku)#1Z*c%u%-Kx?H{hmX)u#@ckaMTc+I;cD)Xc)JeQuiJL&@Jn=lcIj~X-lfWJ z9X?utpnG)qWjcJH4#!t5tweM8==C}SNu{Bj+hzD-9U9f5QN(h*2UARU2p z1kw>mM<5-6bOh27NJrp*BLb%_6FzZlJ~hbEZvJfnV~#D6P)5ANvH2H+4)N;abN_T5 zW3l+uZV<~vM*6iRiFLgjkH@!jo;EmQUB@+^Ha22i2Q;2GUSeH8(sx&vs8yvB&bsA3_8?i2z#?yvItZRkF(?&+Dt4QN%10&XztMRmP5$l?y z@w8zP>l&%?v{4c3GHE<*P{g`E{!I0kHYU)2ji-$w^k3s?g9826c-oji|23XAB+!42 zr;P~oU*l4gAXn{^th%Cwe~jqb1?vcR0fDIX1uF zv%JEd8_9jeu`T};rcHeGL(n`^W3x>B5(W)#pl$gt0C8+H|Cq>v-q2{gwVLT3Z>_=c zPRqnL(mNz6^ut_#?ma}V`pgmTaUA$_f#X1Lro(jDas0E;C^)c72ZQ3BHGJHaJ-z?h z@=45^rdK*P=U+*;j_?PeVUG6vX<(u+d>W5OJ($dg&EvtFR>4-QpX|F@Af%g0*x_N& z=m>Az8SdF?-{Enz515+G9ol=rPRDu>I-H8=q$DhwOusc-J$e z++McRvCZDGpWZi)@EeZsk*EiaaBQpWXtzK8;_NVE;UoJXWYO0+Zr`(?HrHMxh_s&s zT64s{XFO}ScZTiH9kK7Gs@pd1V4)dsvm0)T_R(X+5k9`39v?4y@dC>kutcB-?nBe! z-BTRf%Jx8)dq+#4@Dx{AKX4ytygL&@M|)+j$1!~r?`X&z9Sq4Uhjj7C3U55uZa)X( z>mWMYaUeRepWG2{>OsGIptqkM52CUO(082ea2$vhoY%skS)4j|VHSOL+&~tad$TM% zA{SW47-8Y)XWH}2!mm2Q_8v#LvKQ0%Bz8AxNDloY9=GhZpRw$XU;ug?+in=- z2p^=;-DWp&ht2yzx<`P2T=3rqfx$zZnC~Z0 z8f*{>?I7GBAowqUz??YC^O5jjRDRo7Ub&b~t9T2{6*~Dcy*wZC!{&Jqn_y}eqUaw# zp}v_X1K!+Y`cfohf$&->d=P(2!GxJ59T0|>% zf!&GFW`m7cZjGF_j6{5&H*b}A1g;d`3p^z86FU4{jpZ+|oVMIrcBaN**>n^y4HzHu z3u8o3=v@VIFOn);{~FG07y1)~ek<3vfN3TD zQBuWn-?f-O05Ul+!(_SlY5{yWmpb(@v)n%x0Q&MKfQMPvP$4Fc_jv-0_k#%^tU3F( zWywKADzBOP{sh1`XaILh)t2dC9_0-BPImVs+EsG9wE&+YyGE(X?cAI}49M<=L^}_+ zn+@m-oMQj-M8F(odDk908NLPVmcfJ zfax$%h!1ly`b=Sd28FRU^?W1IR-}SA5Dkx znC|-k-Wl({7`H#b?I?Q7?BX}uSLs(8g@y$e9#id?h$m6W8G7t)fDt=vZWg3bkUK$4 zsCqf*PW31RzZkrDIQ|L`$Br6H_R*N-j#nX>rq_&Fvc?Y|h5lHwJ0O1(yx9ysX1N7? zmf6Jbt2$tJ4u8!iJiY^uCrH|j_CfOmq#clI^#eN;vs4`fJwT7;qfmHOuK@l#nmc0y z!+K3>U>&N_H_#)h6(X&$u(-q6>;*@<2g8`y!*4ej%@>|!4EeVD*3I_NZ3 zSnYQ0Q*)VK*d2p#oB0-w*-t?4gtm;`jWG+`e{sa#X~m-Xu>Ji3S{+e0oMJ`v?Hp93 zd`E2pe2~Cx=AojVs6$jSSh5SiVkKr=VQe#3kr~!R;bYOMa3plF;_l?@r0$WTOXv}c z&V`R7_6Xf~f3DpgaqP70U1W}8(ZY3K(d!O|?q++$Bq(Kso~H2&5yBjzBsB=?J7Fkd8n)0_g~(Bk+GA0(96ek87HxYs%qmZIS?h}+MlT`8IiNstX)}%<BtztqMLk9Fm_8}!2>J4vHpc9{xpP2 zPr>C|raXJseP1XrU7mUE4j|ZzVbR~m<3~Yj{}7M&fVP4T!hTP*Galaq{`kA`xE1`n z@5SSVpr(`Ycs1y3&^Ayn=q}JlKqH{9fOdj@{C+%6({s*;um}A!Xd&p0-LMC}?a#0W zJq@}GlnVALc`@Bp&P=UYrpt#79JC$22)_bX4%#%0G!_lS)(qpvispchK_93sY(&=L z5o2z!3~d?I#tOzQyn6POD@l*+Z^za6AMrRhBoKx05UyI_jbtwi)%6uz-$Q-;jH!J@ z*1Z`e!!ODlXhM^CTb_pe-zYYqOv!I1sc7qKpd`=J%YA+FQ^21(k9-)~^Yin_XFz`J zJn~Y=--Vo?QC98CoT#Pz$roz!uRuNwW6006DtX3_cn2sxPecAB`-kN)C7lMl>P@>7t%iMg;-AD@f|H2=deCvH52pZOEyf8%n3(j^^% zbOh27NJk(Yfpi4^pGRPd=$|?-j->-Hn2nZH5vj%o$#clEn=D)2&^nfiI!lhfa^j_m{)Q7p;X6kNUbQMaAH34Jev08i-ewO27wC9Gxha-R) z^i;GeM9@os;$Ggjg@iG$^38g7!chw@KR zJ}F~TizJSMkr`^G8|t(JN)W#yoBX(5Ltt^RJb0{}{1C;X{6m zv)g68)@p&P&v}o;$4Fd#j#7TkWck`I0#5Z>CksD(j|;byZztJ2`G(Xt<`>&7abupf z=YS{6Ll=?y({n|=>Vf~V#Ep61-r~5>)xUm_0>2D_qH)Qs7TRiDrU9q^8uR5XL*8VWtB>fok+=YQtz1h{m2rMr2fMBSprpD%Gefip)p?asAGPVUNOP1fcrp~|GRp<0ze>&)N zHMKIgzrL}~i=O~&ImtCBub9v23Its1kq!%Krx@Qsc6yrX>(|3X$2p-HN>HWjV`z_4 z=EJftT|{}}$Rkx2^gC;@XHJ>q7TvP6sBB3IP-H-L+8xrsv8WtSMOlecnqFVJthlJu zxoq)bBo1>{6cv}+;gIU3oLW2$SdzSLGN)OgN~=Y=wEAU9)1*kcC9|Vx5EZ@|EM_$E+|D>0zh#jkY*1h6ujV+Z-!Kb|LF{HytaNl zp`UJ2BqRJ6DdTurzQmuvcoIHiZoqO|`(pVe3< z@nX!gt@b~pnCq&0qLXpao`bSamCu}Xsi^gl;26V+r38CpUh^qRQBr&yClva=sIOmr zUscqapiSTX63fkC@rUJp)qb_FqiBy*SL;1v`(2O^#ii_b$qE$RDmRFzjTC2Pul8Sj zz_6s!?A1P!qH5m=D!h;neOU*F_GDE3Y9B_?W~r>&uk;k%1Uc>TC|>RJC|W4(jqR5( z+lCwJva(nEPKrjPqN?B6|3{>KvD8!hScR{qM={+{6a zkN;y3=WcbJS<&x8rnlcUNhm9-^pp$5E4s&Ezen0Ds{gH;d?-6bUohCK z?-hy;v5-|?QFaP>2{-!ot9=Va)&8l{H@<&fmiB7=S)tUFbiO7KxEepH#a_n^)vwgl zeuttvl%k}@`rk3wcN7anMQ13-(%xAA2f%4-liq_=)P9lre+Z2FidXbw*ieX-z1pAZ zDJ5@x^Hp$tyt4lk0-C$ZUhM;^|5rl&{}J^5qoVB8I6ei8;-~D@zVV=Cq>cZdLJ;j$ z*(-VxjP>@cTBu-~Rqu&WG#ii<3&tKZ-RBh*m@+Cqa3@8ib^ILFz^(uZOZj#x5a=XwNry42^ H3@rO6SyT6S literal 0 HcmV?d00001 diff --git a/bin/main_test b/bin/main_test new file mode 100755 index 0000000000000000000000000000000000000000..9d3a824ca2ddfd0a72a3349137ce5a4a5c21aec8 GIT binary patch literal 17280 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 E-vYVx)&Kwi literal 0 HcmV?d00001 diff --git a/include/signal.h b/include/signal.h index b35297e..43018e2 100644 --- a/include/signal.h +++ b/include/signal.h @@ -19,6 +19,8 @@ struct candata_motor_current_t Curr_value; uint16_t Max_Front_RPM; uint16_t Max_Rear_RPM; + + bool RPM_FRAME_FLAG; bool TRQ_FRAME_FLAG; bool VOLT_FRAME_FLAG; diff --git a/src_autogen/candata.c b/src_autogen/candata.c new file mode 100644 index 0000000..603874b --- /dev/null +++ b/src_autogen/candata.c @@ -0,0 +1,439 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2018-2019 Erik Moqvist + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/** + * This file was generated by cantools version 39.4.0 Sun Dec 17 18:38:47 2023. + */ + +#include + +#include "candata.h" + +static inline uint8_t pack_left_shift_u16( + uint16_t value, + uint8_t shift, + uint8_t mask) +{ + return (uint8_t)((uint8_t)(value << shift) & mask); +} + +static inline uint8_t pack_right_shift_u16( + uint16_t value, + uint8_t shift, + uint8_t mask) +{ + return (uint8_t)((uint8_t)(value >> shift) & mask); +} + +static inline uint16_t unpack_left_shift_u16( + uint8_t value, + uint8_t shift, + uint8_t mask) +{ + return (uint16_t)((uint16_t)(value & mask) << shift); +} + +static inline uint16_t unpack_right_shift_u16( + uint8_t value, + uint8_t shift, + uint8_t mask) +{ + return (uint16_t)((uint16_t)(value & mask) >> shift); +} + +int candata_ai_drive_request_pack( + uint8_t *dst_p, + const struct candata_ai_drive_request_t *src_p, + size_t size) +{ + uint16_t front_trq_request; + uint16_t rear_trq_request; + uint16_t steering_request; + + if (size < 6u) { + return (-EINVAL); + } + + memset(&dst_p[0], 0, 6); + + front_trq_request = (uint16_t)src_p->front_trq_request; + dst_p[0] |= pack_left_shift_u16(front_trq_request, 0u, 0xffu); + dst_p[1] |= pack_right_shift_u16(front_trq_request, 8u, 0xffu); + steering_request = (uint16_t)src_p->steering_request; + dst_p[2] |= pack_left_shift_u16(steering_request, 0u, 0xffu); + dst_p[3] |= pack_right_shift_u16(steering_request, 8u, 0xffu); + rear_trq_request = (uint16_t)src_p->rear_trq_request; + dst_p[4] |= pack_left_shift_u16(rear_trq_request, 0u, 0xffu); + dst_p[5] |= pack_right_shift_u16(rear_trq_request, 8u, 0xffu); + + return (6); +} + +int candata_ai_drive_request_unpack( + struct candata_ai_drive_request_t *dst_p, + const uint8_t *src_p, + size_t size) +{ + uint16_t front_trq_request; + uint16_t rear_trq_request; + uint16_t steering_request; + + if (size < 6u) { + return (-EINVAL); + } + + front_trq_request = unpack_right_shift_u16(src_p[0], 0u, 0xffu); + front_trq_request |= unpack_left_shift_u16(src_p[1], 8u, 0xffu); + dst_p->front_trq_request = (int16_t)front_trq_request; + steering_request = unpack_right_shift_u16(src_p[2], 0u, 0xffu); + steering_request |= unpack_left_shift_u16(src_p[3], 8u, 0xffu); + dst_p->steering_request = (int16_t)steering_request; + rear_trq_request = unpack_right_shift_u16(src_p[4], 0u, 0xffu); + rear_trq_request |= unpack_left_shift_u16(src_p[5], 8u, 0xffu); + dst_p->rear_trq_request = (int16_t)rear_trq_request; + + return (0); +} + +int candata_ai_drive_request_init(struct candata_ai_drive_request_t *msg_p) +{ + if (msg_p == NULL) return -1; + + memset(msg_p, 0, sizeof(struct candata_ai_drive_request_t)); + + return 0; +} + +int16_t candata_ai_drive_request_front_trq_request_encode(double value) +{ + return (int16_t)(value); +} + +double candata_ai_drive_request_front_trq_request_decode(int16_t value) +{ + return ((double)value); +} + +bool candata_ai_drive_request_front_trq_request_is_in_range(int16_t value) +{ + (void)value; + + return (true); +} + +int16_t candata_ai_drive_request_steering_request_encode(double value) +{ + return (int16_t)(value / 0.01); +} + +double candata_ai_drive_request_steering_request_decode(int16_t value) +{ + return ((double)value * 0.01); +} + +bool candata_ai_drive_request_steering_request_is_in_range(int16_t value) +{ + return ((value >= -35) && (value <= 35)); +} + +int16_t candata_ai_drive_request_rear_trq_request_encode(double value) +{ + return (int16_t)(value); +} + +double candata_ai_drive_request_rear_trq_request_decode(int16_t value) +{ + return ((double)value); +} + +bool candata_ai_drive_request_rear_trq_request_is_in_range(int16_t value) +{ + (void)value; + + return (true); +} + +int candata_vcu_wheel_speeds_pack( + uint8_t *dst_p, + const struct candata_vcu_wheel_speeds_t *src_p, + size_t size) +{ + if (size < 8u) { + return (-EINVAL); + } + + memset(&dst_p[0], 0, 8); + + dst_p[0] |= pack_left_shift_u16(src_p->fl_wheel_speed, 0u, 0xffu); + dst_p[1] |= pack_right_shift_u16(src_p->fl_wheel_speed, 8u, 0xffu); + dst_p[2] |= pack_left_shift_u16(src_p->fr_wheel_speed, 0u, 0xffu); + dst_p[3] |= pack_right_shift_u16(src_p->fr_wheel_speed, 8u, 0xffu); + dst_p[4] |= pack_left_shift_u16(src_p->rl_wheel_speed, 0u, 0xffu); + dst_p[5] |= pack_right_shift_u16(src_p->rl_wheel_speed, 8u, 0xffu); + dst_p[6] |= pack_left_shift_u16(src_p->rr_wheel_speed, 0u, 0xffu); + dst_p[7] |= pack_right_shift_u16(src_p->rr_wheel_speed, 8u, 0xffu); + + return (8); +} + +int candata_vcu_wheel_speeds_unpack( + struct candata_vcu_wheel_speeds_t *dst_p, + const uint8_t *src_p, + size_t size) +{ + if (size < 8u) { + return (-EINVAL); + } + + dst_p->fl_wheel_speed = unpack_right_shift_u16(src_p[0], 0u, 0xffu); + dst_p->fl_wheel_speed |= unpack_left_shift_u16(src_p[1], 8u, 0xffu); + dst_p->fr_wheel_speed = unpack_right_shift_u16(src_p[2], 0u, 0xffu); + dst_p->fr_wheel_speed |= unpack_left_shift_u16(src_p[3], 8u, 0xffu); + dst_p->rl_wheel_speed = unpack_right_shift_u16(src_p[4], 0u, 0xffu); + dst_p->rl_wheel_speed |= unpack_left_shift_u16(src_p[5], 8u, 0xffu); + dst_p->rr_wheel_speed = unpack_right_shift_u16(src_p[6], 0u, 0xffu); + dst_p->rr_wheel_speed |= unpack_left_shift_u16(src_p[7], 8u, 0xffu); + + return (0); +} + +int candata_vcu_wheel_speeds_init(struct candata_vcu_wheel_speeds_t *msg_p) +{ + if (msg_p == NULL) return -1; + + memset(msg_p, 0, sizeof(struct candata_vcu_wheel_speeds_t)); + + return 0; +} + +uint16_t candata_vcu_wheel_speeds_fl_wheel_speed_encode(double value) +{ + return (uint16_t)(value / 0.1); +} + +double candata_vcu_wheel_speeds_fl_wheel_speed_decode(uint16_t value) +{ + return ((double)value * 0.1); +} + +bool candata_vcu_wheel_speeds_fl_wheel_speed_is_in_range(uint16_t value) +{ + (void)value; + + return (true); +} + +uint16_t candata_vcu_wheel_speeds_fr_wheel_speed_encode(double value) +{ + return (uint16_t)(value / 0.1); +} + +double candata_vcu_wheel_speeds_fr_wheel_speed_decode(uint16_t value) +{ + return ((double)value * 0.1); +} + +bool candata_vcu_wheel_speeds_fr_wheel_speed_is_in_range(uint16_t value) +{ + (void)value; + + return (true); +} + +uint16_t candata_vcu_wheel_speeds_rl_wheel_speed_encode(double value) +{ + return (uint16_t)(value / 0.1); +} + +double candata_vcu_wheel_speeds_rl_wheel_speed_decode(uint16_t value) +{ + return ((double)value * 0.1); +} + +bool candata_vcu_wheel_speeds_rl_wheel_speed_is_in_range(uint16_t value) +{ + (void)value; + + return (true); +} + +uint16_t candata_vcu_wheel_speeds_rr_wheel_speed_encode(double value) +{ + return (uint16_t)(value / 0.1); +} + +double candata_vcu_wheel_speeds_rr_wheel_speed_decode(uint16_t value) +{ + return ((double)value * 0.1); +} + +bool candata_vcu_wheel_speeds_rr_wheel_speed_is_in_range(uint16_t value) +{ + (void)value; + + return (true); +} + +int candata_vcu_battery_pack( + uint8_t *dst_p, + const struct candata_vcu_battery_t *src_p, + size_t size) +{ + if (size < 2u) { + return (-EINVAL); + } + + memset(&dst_p[0], 0, 2); + + dst_p[0] |= pack_left_shift_u16(src_p->voltage, 0u, 0xffu); + dst_p[1] |= pack_right_shift_u16(src_p->voltage, 8u, 0xffu); + + return (2); +} + +int candata_vcu_battery_unpack( + struct candata_vcu_battery_t *dst_p, + const uint8_t *src_p, + size_t size) +{ + if (size < 2u) { + return (-EINVAL); + } + + dst_p->voltage = unpack_right_shift_u16(src_p[0], 0u, 0xffu); + dst_p->voltage |= unpack_left_shift_u16(src_p[1], 8u, 0xffu); + + return (0); +} + +int candata_vcu_battery_init(struct candata_vcu_battery_t *msg_p) +{ + if (msg_p == NULL) return -1; + + memset(msg_p, 0, sizeof(struct candata_vcu_battery_t)); + + return 0; +} + +uint16_t candata_vcu_battery_voltage_encode(double value) +{ + return (uint16_t)(value / 0.001); +} + +double candata_vcu_battery_voltage_decode(uint16_t value) +{ + return ((double)value * 0.001); +} + +bool candata_vcu_battery_voltage_is_in_range(uint16_t value) +{ + return (value <= 13000u); +} + +int candata_motor_current_pack( + uint8_t *dst_p, + const struct candata_motor_current_t *src_p, + size_t size) +{ + uint16_t front_current; + uint16_t rear_current; + + if (size < 4u) { + return (-EINVAL); + } + + memset(&dst_p[0], 0, 4); + + front_current = (uint16_t)src_p->front_current; + dst_p[0] |= pack_left_shift_u16(front_current, 0u, 0xffu); + dst_p[1] |= pack_right_shift_u16(front_current, 8u, 0xffu); + rear_current = (uint16_t)src_p->rear_current; + dst_p[2] |= pack_left_shift_u16(rear_current, 0u, 0xffu); + dst_p[3] |= pack_right_shift_u16(rear_current, 8u, 0xffu); + + return (4); +} + +int candata_motor_current_unpack( + struct candata_motor_current_t *dst_p, + const uint8_t *src_p, + size_t size) +{ + uint16_t front_current; + uint16_t rear_current; + + if (size < 4u) { + return (-EINVAL); + } + + front_current = unpack_right_shift_u16(src_p[0], 0u, 0xffu); + front_current |= unpack_left_shift_u16(src_p[1], 8u, 0xffu); + dst_p->front_current = (int16_t)front_current; + rear_current = unpack_right_shift_u16(src_p[2], 0u, 0xffu); + rear_current |= unpack_left_shift_u16(src_p[3], 8u, 0xffu); + dst_p->rear_current = (int16_t)rear_current; + + return (0); +} + +int candata_motor_current_init(struct candata_motor_current_t *msg_p) +{ + if (msg_p == NULL) return -1; + + memset(msg_p, 0, sizeof(struct candata_motor_current_t)); + + return 0; +} + +int16_t candata_motor_current_front_current_encode(double value) +{ + return (int16_t)(value); +} + +double candata_motor_current_front_current_decode(int16_t value) +{ + return ((double)value); +} + +bool candata_motor_current_front_current_is_in_range(int16_t value) +{ + return ((value >= -30000) && (value <= 30000)); +} + +int16_t candata_motor_current_rear_current_encode(double value) +{ + return (int16_t)(value); +} + +double candata_motor_current_rear_current_decode(int16_t value) +{ + return ((double)value); +} + +bool candata_motor_current_rear_current_is_in_range(int16_t value) +{ + return ((value >= -30000) && (value <= 30000)); +} diff --git a/src_autogen/candata.h b/src_autogen/candata.h new file mode 100644 index 0000000..e74e53e --- /dev/null +++ b/src_autogen/candata.h @@ -0,0 +1,609 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2018-2019 Erik Moqvist + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +/** + * This file was generated by cantools version 39.4.0 Sun Dec 17 18:38:47 2023. + */ + +#ifndef CANDATA_H +#define CANDATA_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#ifndef EINVAL +# define EINVAL 22 +#endif + +/* Frame ids. */ +#define CANDATA_AI_DRIVE_REQUEST_FRAME_ID (0x521u) +#define CANDATA_VCU_WHEEL_SPEEDS_FRAME_ID (0x525u) +#define CANDATA_VCU_BATTERY_FRAME_ID (0x526u) +#define CANDATA_MOTOR_CURRENT_FRAME_ID (0x320u) + +/* Frame lengths in bytes. */ +#define CANDATA_AI_DRIVE_REQUEST_LENGTH (6u) +#define CANDATA_VCU_WHEEL_SPEEDS_LENGTH (8u) +#define CANDATA_VCU_BATTERY_LENGTH (2u) +#define CANDATA_MOTOR_CURRENT_LENGTH (4u) + +/* Extended or standard frame types. */ +#define CANDATA_AI_DRIVE_REQUEST_IS_EXTENDED (0) +#define CANDATA_VCU_WHEEL_SPEEDS_IS_EXTENDED (0) +#define CANDATA_VCU_BATTERY_IS_EXTENDED (0) +#define CANDATA_MOTOR_CURRENT_IS_EXTENDED (0) + +/* Frame cycle times in milliseconds. */ + + +/* Signal choices. */ + + +/* Frame Names. */ +#define CANDATA_AI_DRIVE_REQUEST_NAME "AI_DRIVE_REQUEST" +#define CANDATA_VCU_WHEEL_SPEEDS_NAME "VCU_WHEEL_SPEEDS" +#define CANDATA_VCU_BATTERY_NAME "VCU_BATTERY" +#define CANDATA_MOTOR_CURRENT_NAME "MOTOR_CURRENT" + +/* Signal Names. */ +#define CANDATA_AI_DRIVE_REQUEST_FRONT_TRQ_REQUEST_NAME "FRONT_TRQ_REQUEST" +#define CANDATA_AI_DRIVE_REQUEST_STEERING_REQUEST_NAME "STEERING_REQUEST" +#define CANDATA_AI_DRIVE_REQUEST_REAR_TRQ_REQUEST_NAME "REAR_TRQ_REQUEST" +#define CANDATA_VCU_WHEEL_SPEEDS_FL_WHEEL_SPEED_NAME "FL_WHEEL_SPEED" +#define CANDATA_VCU_WHEEL_SPEEDS_FR_WHEEL_SPEED_NAME "FR_WHEEL_SPEED" +#define CANDATA_VCU_WHEEL_SPEEDS_RL_WHEEL_SPEED_NAME "RL_WHEEL_SPEED" +#define CANDATA_VCU_WHEEL_SPEEDS_RR_WHEEL_SPEED_NAME "RR_WHEEL_SPEED" +#define CANDATA_VCU_BATTERY_VOLTAGE_NAME "VOLTAGE" +#define CANDATA_MOTOR_CURRENT_FRONT_CURRENT_NAME "FRONT_CURRENT" +#define CANDATA_MOTOR_CURRENT_REAR_CURRENT_NAME "REAR_CURRENT" + +/** + * Signals in message AI_DRIVE_REQUEST. + * + * All signal values are as on the CAN bus. + */ +struct candata_ai_drive_request_t { + /** + * Range: -32768..32767 (-32768..32767 Nm) + * Scale: 1 + * Offset: 0 + */ + int16_t front_trq_request; + + /** + * Range: -35..35 (-0.35..0.35 rad) + * Scale: 0.01 + * Offset: 0 + */ + int16_t steering_request; + + /** + * Range: -32768..32767 (-32768..32767 Nm) + * Scale: 1 + * Offset: 0 + */ + int16_t rear_trq_request; +}; + +/** + * Signals in message VCU_WHEEL_SPEEDS. + * + * All signal values are as on the CAN bus. + */ +struct candata_vcu_wheel_speeds_t { + /** + * Range: 0..655350 (0..65535 rpm) + * Scale: 0.1 + * Offset: 0 + */ + uint16_t fl_wheel_speed; + + /** + * Range: 0..655350 (0..65535 rpm) + * Scale: 0.1 + * Offset: 0 + */ + uint16_t fr_wheel_speed; + + /** + * Range: 0..655350 (0..65535 rpm) + * Scale: 0.1 + * Offset: 0 + */ + uint16_t rl_wheel_speed; + + /** + * Range: 0..655350 (0..65535 rpm) + * Scale: 0.1 + * Offset: 0 + */ + uint16_t rr_wheel_speed; +}; + +/** + * Signals in message VCU_BATTERY. + * + * All signal values are as on the CAN bus. + */ +struct candata_vcu_battery_t { + /** + * Range: 0..13000 (0..13 V) + * Scale: 0.001 + * Offset: 0 + */ + uint16_t voltage; +}; + +/** + * Signals in message MOTOR_CURRENT. + * + * All signal values are as on the CAN bus. + */ +struct candata_motor_current_t { + /** + * Range: -30000..30000 (-30000..30000 mA) + * Scale: 1 + * Offset: 0 + */ + int16_t front_current; + + /** + * Range: -30000..30000 (-30000..30000 mA) + * Scale: 1 + * Offset: 0 + */ + int16_t rear_current; +}; + +/** + * Pack message AI_DRIVE_REQUEST. + * + * @param[out] dst_p Buffer to pack the message into. + * @param[in] src_p Data to pack. + * @param[in] size Size of dst_p. + * + * @return Size of packed data, or negative error code. + */ +int candata_ai_drive_request_pack( + uint8_t *dst_p, + const struct candata_ai_drive_request_t *src_p, + size_t size); + +/** + * Unpack message AI_DRIVE_REQUEST. + * + * @param[out] dst_p Object to unpack the message into. + * @param[in] src_p Message to unpack. + * @param[in] size Size of src_p. + * + * @return zero(0) or negative error code. + */ +int candata_ai_drive_request_unpack( + struct candata_ai_drive_request_t *dst_p, + const uint8_t *src_p, + size_t size); + +/** + * Init message fields to default values from AI_DRIVE_REQUEST. + * + * @param[in] msg_p Message to init. + * + * @return zero(0) on success or (-1) in case of nullptr argument. + */ +int candata_ai_drive_request_init(struct candata_ai_drive_request_t *msg_p); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +int16_t candata_ai_drive_request_front_trq_request_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_ai_drive_request_front_trq_request_decode(int16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_ai_drive_request_front_trq_request_is_in_range(int16_t value); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +int16_t candata_ai_drive_request_steering_request_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_ai_drive_request_steering_request_decode(int16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_ai_drive_request_steering_request_is_in_range(int16_t value); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +int16_t candata_ai_drive_request_rear_trq_request_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_ai_drive_request_rear_trq_request_decode(int16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_ai_drive_request_rear_trq_request_is_in_range(int16_t value); + +/** + * Pack message VCU_WHEEL_SPEEDS. + * + * @param[out] dst_p Buffer to pack the message into. + * @param[in] src_p Data to pack. + * @param[in] size Size of dst_p. + * + * @return Size of packed data, or negative error code. + */ +int candata_vcu_wheel_speeds_pack( + uint8_t *dst_p, + const struct candata_vcu_wheel_speeds_t *src_p, + size_t size); + +/** + * Unpack message VCU_WHEEL_SPEEDS. + * + * @param[out] dst_p Object to unpack the message into. + * @param[in] src_p Message to unpack. + * @param[in] size Size of src_p. + * + * @return zero(0) or negative error code. + */ +int candata_vcu_wheel_speeds_unpack( + struct candata_vcu_wheel_speeds_t *dst_p, + const uint8_t *src_p, + size_t size); + +/** + * Init message fields to default values from VCU_WHEEL_SPEEDS. + * + * @param[in] msg_p Message to init. + * + * @return zero(0) on success or (-1) in case of nullptr argument. + */ +int candata_vcu_wheel_speeds_init(struct candata_vcu_wheel_speeds_t *msg_p); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +uint16_t candata_vcu_wheel_speeds_fl_wheel_speed_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_vcu_wheel_speeds_fl_wheel_speed_decode(uint16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_vcu_wheel_speeds_fl_wheel_speed_is_in_range(uint16_t value); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +uint16_t candata_vcu_wheel_speeds_fr_wheel_speed_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_vcu_wheel_speeds_fr_wheel_speed_decode(uint16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_vcu_wheel_speeds_fr_wheel_speed_is_in_range(uint16_t value); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +uint16_t candata_vcu_wheel_speeds_rl_wheel_speed_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_vcu_wheel_speeds_rl_wheel_speed_decode(uint16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_vcu_wheel_speeds_rl_wheel_speed_is_in_range(uint16_t value); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +uint16_t candata_vcu_wheel_speeds_rr_wheel_speed_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_vcu_wheel_speeds_rr_wheel_speed_decode(uint16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_vcu_wheel_speeds_rr_wheel_speed_is_in_range(uint16_t value); + +/** + * Pack message VCU_BATTERY. + * + * @param[out] dst_p Buffer to pack the message into. + * @param[in] src_p Data to pack. + * @param[in] size Size of dst_p. + * + * @return Size of packed data, or negative error code. + */ +int candata_vcu_battery_pack( + uint8_t *dst_p, + const struct candata_vcu_battery_t *src_p, + size_t size); + +/** + * Unpack message VCU_BATTERY. + * + * @param[out] dst_p Object to unpack the message into. + * @param[in] src_p Message to unpack. + * @param[in] size Size of src_p. + * + * @return zero(0) or negative error code. + */ +int candata_vcu_battery_unpack( + struct candata_vcu_battery_t *dst_p, + const uint8_t *src_p, + size_t size); + +/** + * Init message fields to default values from VCU_BATTERY. + * + * @param[in] msg_p Message to init. + * + * @return zero(0) on success or (-1) in case of nullptr argument. + */ +int candata_vcu_battery_init(struct candata_vcu_battery_t *msg_p); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +uint16_t candata_vcu_battery_voltage_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_vcu_battery_voltage_decode(uint16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_vcu_battery_voltage_is_in_range(uint16_t value); + +/** + * Pack message MOTOR_CURRENT. + * + * @param[out] dst_p Buffer to pack the message into. + * @param[in] src_p Data to pack. + * @param[in] size Size of dst_p. + * + * @return Size of packed data, or negative error code. + */ +int candata_motor_current_pack( + uint8_t *dst_p, + const struct candata_motor_current_t *src_p, + size_t size); + +/** + * Unpack message MOTOR_CURRENT. + * + * @param[out] dst_p Object to unpack the message into. + * @param[in] src_p Message to unpack. + * @param[in] size Size of src_p. + * + * @return zero(0) or negative error code. + */ +int candata_motor_current_unpack( + struct candata_motor_current_t *dst_p, + const uint8_t *src_p, + size_t size); + +/** + * Init message fields to default values from MOTOR_CURRENT. + * + * @param[in] msg_p Message to init. + * + * @return zero(0) on success or (-1) in case of nullptr argument. + */ +int candata_motor_current_init(struct candata_motor_current_t *msg_p); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +int16_t candata_motor_current_front_current_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_motor_current_front_current_decode(int16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_motor_current_front_current_is_in_range(int16_t value); + +/** + * Encode given signal by applying scaling and offset. + * + * @param[in] value Signal to encode. + * + * @return Encoded signal. + */ +int16_t candata_motor_current_rear_current_encode(double value); + +/** + * Decode given signal by applying scaling and offset. + * + * @param[in] value Signal to decode. + * + * @return Decoded signal. + */ +double candata_motor_current_rear_current_decode(int16_t value); + +/** + * Check that given signal is in allowed range. + * + * @param[in] value Signal to check. + * + * @return true if in range, false otherwise. + */ +bool candata_motor_current_rear_current_is_in_range(int16_t value); + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/tidy-output.log b/tidy-output.log new file mode 100644 index 0000000..443c96f --- /dev/null +++ b/tidy-output.log @@ -0,0 +1,184 @@ +/home/coventry/Documents/7166CEM/src/main.c:1:1: warning: system include math.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:2:1: warning: system include stdio.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:3:1: warning: system include stdlib.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:4:1: warning: system include string.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:5:1: warning: system include unistd.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:7:1: warning: system include linux/can.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:8:1: warning: system include linux/can/raw.h not allowed [llvmlibc-restrict-system-libc-headers] +#include +^~~~~~~~~~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:10:10: error: 'can_wrap.h' file not found [clang-diagnostic-error] +#include "can_wrap.h" + ^~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:12:1: warning: system include signal.h not allowed [llvmlibc-restrict-system-libc-headers] +#include "signal.h" +^~~~~~~~~~~~~~~~~~~ +/home/coventry/Documents/7166CEM/src/main.c:17:3: warning: if with identical then and else branches [bugprone-branch-clone] + if (rpm.fl_wheel_speed > rpm.fr_wheel_speed) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:24:3: note: else branch starts here + else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:30:3: warning: if with identical then and else branches [bugprone-branch-clone] + if (rpm.rl_wheel_speed > rpm.rr_wheel_speed) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:37:3: note: else branch starts here + else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:56:16: warning: variable 'Front_Req' is not initialized [cppcoreguidelines-init-variables] + const float Front_Req = Initilize; + ^ + = NAN +/home/coventry/Documents/7166CEM/src/main.c:57:16: warning: variable 'Steer_Req' is not initialized [cppcoreguidelines-init-variables] + const float Steer_Req = Initilize; + ^ + = NAN +/home/coventry/Documents/7166CEM/src/main.c:58:17: warning: variable 'Rear_req' is not initialized [cppcoreguidelines-init-variables] + const float Rear_req = Initilize; + ^ + = NAN +/home/coventry/Documents/7166CEM/src/main.c:82:16: warning: variable 'Bat_Value' is not initialized [cppcoreguidelines-init-variables] + const double Bat_Value = + ^ + = NAN +/home/coventry/Documents/7166CEM/src/main.c:95:6: warning: function 'RPM_Battery_LIMITER' has cognitive complexity of 68 (threshold 25) [readability-function-cognitive-complexity] +void RPM_Battery_LIMITER() { + ^ +/home/coventry/Documents/7166CEM/src/main.c:98:3: note: +1, including nesting penalty of 0, nesting level increased to 1 + if (Vol_value.voltage >= 2.8) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:100:5: note: +2, including nesting penalty of 1, nesting level increased to 2 + if (Trq_Req.front_trq_request > 0) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:101:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM > 700) && (Trq_Req.front_trq_request > 50)) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:104:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 700) && (Max_Front_RPM > 600) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:108:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 600) && (Max_Front_RPM > 500) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:113:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 500) && (Max_Front_RPM > 400) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:117:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 400) && (Max_Front_RPM > 300) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:124:5: note: +1, nesting level increased to 2 + else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:126:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM > 700) && (abs(Trq_Req.front_trq_request) > 50)) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:129:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 700) && (Max_Front_RPM > 600) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:133:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 600) && (Max_Front_RPM > 500) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:138:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 500) && (Max_Front_RPM > 400) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:142:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Front_RPM <= 400) && (Max_Front_RPM > 300) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:150:5: note: +2, including nesting penalty of 1, nesting level increased to 2 + if (Trq_Req.rear_trq_request > 0) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:151:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM > 700) && (Trq_Req.rear_trq_request > 50)) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:154:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 700) && (Max_Rear_RPM > 600) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:158:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 600) && (Max_Rear_RPM > 500) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:163:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 500) && (Max_Rear_RPM > 400) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:167:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 400) && (Max_Rear_RPM > 300) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:174:5: note: +1, nesting level increased to 2 + else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:176:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM > 700) && (abs(Trq_Req.rear_trq_request) > 50)) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:179:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 700) && (Max_Rear_RPM > 600) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:183:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 600) && (Max_Rear_RPM > 500) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:188:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 500) && (Max_Rear_RPM > 400) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:192:7: note: +3, including nesting penalty of 2, nesting level increased to 3 + if ((Max_Rear_RPM <= 400) && (Max_Rear_RPM > 300) && + ^ +/home/coventry/Documents/7166CEM/src/main.c:197:5: note: +1, nesting level increased to 1 + } else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:100:5: warning: if with identical then and else branches [bugprone-branch-clone] + if (Trq_Req.front_trq_request > 0) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:124:5: note: else branch starts here + else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:150:5: warning: if with identical then and else branches [bugprone-branch-clone] + if (Trq_Req.rear_trq_request > 0) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:174:5: note: else branch starts here + else { + ^ +/home/coventry/Documents/7166CEM/src/main.c:210:16: warning: variable 'Front_Motor' is not initialized [cppcoreguidelines-init-variables] + const double Front_Motor = + ^ + = NAN +/home/coventry/Documents/7166CEM/src/main.c:215:16: warning: variable 'Rear_Motor' is not initialized [cppcoreguidelines-init-variables] + const double Rear_Motor = + ^ + = NAN +/home/coventry/Documents/7166CEM/src/main.c:226:13: warning: variable 'canSocket' is not initialized [cppcoreguidelines-init-variables] + const int canSocket = can_connect(canChannel, false); + ^ + = 0 +/home/coventry/Documents/7166CEM/src/main.c:241:3: warning: kernel performance could be improved by unrolling this loop with a '#pragma unroll' directive [altera-unroll-loops] + for (int i = 0; i < frame0.can_dlc; ++i) + ^ +/home/coventry/Documents/7166CEM/src/main.c:241:43: warning: statement should be inside braces [google-readability-braces-around-statements,hicpp-braces-around-statements,readability-braces-around-statements] + for (int i = 0; i < frame0.can_dlc; ++i) + ^ + { +/home/coventry/Documents/7166CEM/src/main.c:245:38: warning: statement should be inside braces [google-readability-braces-around-statements,hicpp-braces-around-statements,readability-braces-around-statements] + if (!can_write(canSocket, &frame0)) + ^ + { +/home/coventry/Documents/7166CEM/src/main.c:247:3: warning: function is not thread safe [concurrency-mt-unsafe] + sleep(1); + ^ +/home/coventry/Documents/7166CEM/src/main.c:272:14: warning: parameter 'argc' is unused [misc-unused-parameters] +int main(int argc, char *argv[]) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:272:26: warning: parameter 'argv' is unused [misc-unused-parameters] +int main(int argc, char *argv[]) { + ^ +/home/coventry/Documents/7166CEM/src/main.c:275:13: warning: variable 'canSocket' is not initialized [cppcoreguidelines-init-variables] + const int canSocket = can_connect(canChannel, false); + ^ + = 0