{
int taskRetVal;
- if ((taskRetVal = xTaskCreate(processCmd, (const signed char*)"processCmd", 1000, NULL, priority, processCmdHandler)) != pdPASS) {
+ if ((taskRetVal = xTaskCreate(processCmd, (const signed char *)"processCmd", 1000, NULL, priority, processCmdHandler)) != pdPASS) {
rpp_sci_printf("FreeRTOS: Creating task processCmd failed. Error code: %d", taskRetVal);
/* An error occurred, block program */
while (1)
#endif /* DOCGEN */
/** Root list in which commands are stored */
-cmd_des_t const * *cmd_list;
+cmd_des_t const **cmd_list;
/** Command descriptor for sleep command */
cmd_des_t const cmd_des_sleep = {
"This command configures the LIN and CAN peripherals to enter sleep mode\n"
"and turn the whole device into sleep mode. External signal on CAN or\n"
"LIN will wake the device up.\n",
- CMD_HANDLER(cmd_do_sleep), (void*)&cmd_list
+ CMD_HANDLER(cmd_do_sleep), (void *)&cmd_list
};
/** Command descriptor for show help command */
"This command without parameter prints the list of all available\n"
"commands with short help text for each of them. If a parameter is\n"
"provided, the command prints a long description for given command.\n",
- CMD_HANDLER(cmd_do_help), (void*)&cmd_list
+ CMD_HANDLER(cmd_do_help), (void *)&cmd_list
};
cmd_des_t const cmd_des_version = {
" ADC10 107 lsb ~ 0.54 V\n"
" ADC11 110 lsb ~ 0.55 V\n"
" ADC12 108 lsb ~ 0.54 V\n",
- CMD_HANDLER(cmd_do_read_adc1_values), (void*)&cmd_list_adc
+ CMD_HANDLER(cmd_do_read_adc1_values), (void *)&cmd_list_adc
};
cmd_des_t const cmd_des_read_adc2 = {
"\n"
" --> adcread1\n"
" ADC1 2331 lsb ~ 11.66 V\n",
- CMD_HANDLER(cmd_do_read_adc1_values), (void*)&cmd_list_adc
+ CMD_HANDLER(cmd_do_read_adc1_values), (void *)&cmd_list_adc
};
cmd_des_t const cmd_des_adcwatch = {
" 1 2 3 4 5 6 7 8 9 10 11 12\n"
" 2331 107 108 106 107 110 110 109 107 107 110 109 lsb\n"
" 11.66 0.54 0.54 0.53 0.54 0.55 0.55 0.55 0.54 0.54 0.55 0.55 V\n",
- CMD_HANDLER(cmd_do_adc_watch), (void*)&cmd_list_adc
+ CMD_HANDLER(cmd_do_adc_watch), (void *)&cmd_list_adc
};
/** List of commands for adc, defined as external */
"\n"
"### Example ###\n"
" --> caninit\n",
- CMD_HANDLER(cmd_do_can_init), (void*)&cmd_list_can
+ CMD_HANDLER(cmd_do_can_init), (void *)&cmd_list_can
};
cmd_des_t const cmd_des_can_baudrate = {
" canbaudrate2=500000\n"
"\n"
" --> canbaudrate2:100000\n",
- CMD_HANDLER(cmd_do_can_change_baudrate), (void*)&cmd_list_can
+ CMD_HANDLER(cmd_do_can_change_baudrate), (void *)&cmd_list_can
};
cmd_des_t const cmd_des_can_timing = {
" tQ: 125 ns\n"
"\n"
" --> cantiming2:5 8 7 4 1\n",
- CMD_HANDLER(cmd_do_can_change_timing), (void*)&cmd_list_can
+ CMD_HANDLER(cmd_do_can_change_timing), (void *)&cmd_list_can
};
"### Example ###\n"
" --> cansend 2 0x123 DEAD BEEF\n"
" Sent: can2 123 [4] DE AD BE EF\n",
- CMD_HANDLER(cmd_do_can_send), (void*)&cmd_list_can
+ CMD_HANDLER(cmd_do_can_send), (void *)&cmd_list_can
};
"\n"
" --> candump 2\n"
"can2 0000FADE [2] 12 34\n",
- CMD_HANDLER(cmd_do_can_dump), (void*)&cmd_list_can
+ CMD_HANDLER(cmd_do_can_dump), (void *)&cmd_list_can
};
cmd_des_t const cmd_des_can_test = {
"---"
"Reset the CAN bus."
" CAN bus Initialization...OK",
- CMD_HANDLER(cmd_do_can_test_functions), (void*)&cmd_list_can
+ CMD_HANDLER(cmd_do_can_test_functions), (void *)&cmd_list_can
};
" dacpinenable1=1\n"
"\n"
"Enables pin DAC1 and prints its actual state (which will be 1)\n",
- CMD_HANDLER(cmd_do_dac_pin_setup), (void*)&cmd_list_dac
+ CMD_HANDLER(cmd_do_dac_pin_setup), (void *)&cmd_list_dac
};
/** Descriptor of command for dac pin value set */
" dacpinval1 =4095\n"
"\n"
"Set pin DAC1 voltage to 12V, and prints the value (4095).\n",
- CMD_HANDLER(cmd_do_dac_pin_set_val), (void*)&cmd_list_dac
+ CMD_HANDLER(cmd_do_dac_pin_set_val), (void *)&cmd_list_dac
};
/** Descriptor of command for dac pin voltage set */
" dacpinvoltage2 =500\n"
"\n"
"Sets pin DAC2 to 500mV, prints actual voltage (500)\n",
- CMD_HANDLER(cmd_do_dac_pin_set_voltage), (void*)&cmd_list_dac
+ CMD_HANDLER(cmd_do_dac_pin_set_voltage), (void *)&cmd_list_dac
};
/** List of commands for dac, defined as external */
int cmd_do_din_watch(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
{
- rpp_sci_printf((const char*)
+ rpp_sci_printf((const char *)
"Digital Inputs Test [0-15]:\r\n"
);
- rpp_sci_printf((const char*)
+ rpp_sci_printf((const char *)
"===========================================================\r\n"
);
- rpp_sci_printf((const char*)
+ rpp_sci_printf((const char *)
" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A B C D E F G H\r\n"
// 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
);
// Print inputs
// Terminal needs to be at least 47 chars long
for (pin = 0; pin < 16; pin++) {
- rpp_sci_printf((const char*)" %d ", rpp_din_get(pin));
+ rpp_sci_printf((const char *)" %d ", rpp_din_get(pin));
}
for (pin = 8; pin < 16; pin++) {
- rpp_sci_printf((const char*)" %d ", rpp_din_get_tr(pin));
+ rpp_sci_printf((const char *)" %d ", rpp_din_get_tr(pin));
}
rpp_sci_printf("\r");
"\n"
"Sets the DIN0 through DIN7 as switch to ground, tri-state, wake-up/IRQ\n"
"enabled.\n",
- CMD_HANDLER(cmd_do_din_setup), (void*)&cmd_list_din
+ CMD_HANDLER(cmd_do_din_setup), (void *)&cmd_list_din
};
/** Command descriptor for din state command */
" dinget1 =0\n"
"\n"
"DIN1 is in open state.\n",
- CMD_HANDLER(cmd_do_din_get), (void*)&cmd_list_din
+ CMD_HANDLER(cmd_do_din_get), (void *)&cmd_list_din
};
/** Command descriptor for din state command */
" dindiag1 =0\n"
"\n"
"Prints value of the diagnostic bit of DIN1.\n",
- CMD_HANDLER(cmd_do_din_diag), (void*)&cmd_list_din
+ CMD_HANDLER(cmd_do_din_diag), (void *)&cmd_list_din
};
/** Command descriptor for din state command */
" ===========================================================\n"
" 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A B C D E F G H\n"
" 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1\n",
- CMD_HANDLER(cmd_do_din_watch), (void*)&cmd_list_din
+ CMD_HANDLER(cmd_do_din_watch), (void *)&cmd_list_din
};
/** List of commands for din, defined as external */
/* Frame descriptor used for receiving frames --
it might be placed in normal RAM or in CPPI ram of EMAC */
//EMAC_Desc rx_desc __attribute__((aligned(4)));
-volatile EMAC_Desc *rx_desc = ((EMAC_Desc*)EMAC_CTRL_RAM_BASE);
+volatile EMAC_Desc *rx_desc = ((EMAC_Desc *)EMAC_CTRL_RAM_BASE);
#define BUFF_SIZE 2048
/* TX */
for (j = 0; j < 8; j++) {
fr1.pNext = NULL;
- fr1.pBuffer = (uint8_t*)&efr1;
+ fr1.pBuffer = (uint8_t *)&efr1;
fr1.BufOffLen = 65;
fr1.PktFlgLen = (EMAC_DSC_FLAG_SOP | EMAC_DSC_FLAG_EOP | EMAC_DSC_FLAG_OWNER | 65);
"Command tries to send a few ethernet frames. No real connection or\n"
"meaningful packets are sent. This only tests, if Ethernet is just\n"
"working.\n",
- CMD_HANDLER(emac_test), (void*)&cmd_list_emac
+ CMD_HANDLER(emac_test), (void *)&cmd_list_emac
};
cmd_des_t const *cmd_list_emac[] = {
" FlexRay cluster configuration accepted.\n"
" --> frbtconfignode 0x0 0x0 0x2 0x1 0x3 0x3 0x0 0x0 0x1 0x1 0x10D 0x6 0x6 0x18 0x18 0x36B00 0xCD 0x151 0x0 0x1 0x0 0x2 0x81 0x36DA2 0x151 0x33 0x0 0x0\n"
" FlexRay node configuration accepted.\n",
- CMD_HANDLER(cmd_do_fr_user_config), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_user_config), (void *)&cmd_list_fr_basic_test
};
cmd_des_t const cmd_des_fr_config_buffer = {
" frbtcfgbufD0 slot9 A cyc0 rx max64 single ppi0 int0\n"
" --> frbtcfgbufD1 slot10 A cyc0 tx max0x40 single ppi0 int0\n"
" frbtcfgbufD1 slot10 A cyc0 tx max64 single ppi0 int0\n",
- CMD_HANDLER(cmd_do_fr_config_bufer), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_config_bufer), (void *)&cmd_list_fr_basic_test
};
cmd_des_t const cmd_des_fr_config_fifo = {
"\n"
" --> frbtcfgfifo rejslot6 slotmask6 depth5 AB cyc0 max0x20 rejnull accstat\n"
" frbtcfgfifo rejslot6 slotmask6 depth5 AB cyc0 max0x20 rejnull accstat\n",
- CMD_HANDLER(cmd_do_fr_config_fifo), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_config_fifo), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay init command */
" --> frbtinitA\n"
" FlexRay driver initialized.\n"
" FlexRay controller initialized.\n",
- CMD_HANDLER(cmd_do_fr_init), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_init), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller init command */
"\n"
" --> frbtstart\n"
" FlexRay communication is running.\n",
- CMD_HANDLER(cmd_do_fr_start), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_start), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller all slots command */
"\n"
" --> frbtallslots\n"
" FlexRay node started communication on all slots.\n",
- CMD_HANDLER(cmd_do_fr_allslots), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_allslots), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller halt command */
"\n"
" --> frbthalt\n"
" FlexRay node communication halted.\n",
- CMD_HANDLER(cmd_do_fr_halt), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_halt), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller abort command */
"\n"
" --> frbtabort\n"
" FlexRay node communication aborted.\n",
- CMD_HANDLER(cmd_do_fr_abort), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_abort), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller send wake up pattern command */
"\n"
" --> frbtwup\n"
" Wake up pattern has been sent.\n",
- CMD_HANDLER(cmd_do_fr_sendwup), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_sendwup), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller sent wake up pattern channel command */
"\n"
" --> frbtsetwuchA\n"
" Wake up channel has been set.\n",
- CMD_HANDLER(cmd_do_fr_setwuchannel), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_setwuchannel), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay controller get POC status command */
" StartupState: UNDEFINED\n"
" State: READY\n"
" WakeupStatus: UNDEFINED\n",
- CMD_HANDLER(cmd_do_fr_getpocstatus), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getpocstatus), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay transmit tx lpdu command */
"\n"
" --> frbttransmit1 12 34 56 AA BB CC\n"
" Data were set for transmission.\n",
- CMD_HANDLER(cmd_do_fr_transmittxlpdu), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_transmittxlpdu), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay cancel tx lpdu command */
"\n"
" --> frbtcanceltx3\n"
" Transmission canceled.\n",
- CMD_HANDLER(cmd_do_fr_canceltxlpdu), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_canceltxlpdu), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay receive rx lpdu command */
" More messages are still in FIFO:\n"
" Received message (32 B):\n"
" ee ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00\n",
- CMD_HANDLER(cmd_do_fr_receiverxlpdu), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_receiverxlpdu), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay check TX LPdu status command */
"\n"
" --> frbtchecktx1\n"
" Message transmission is not pending.\n",
- CMD_HANDLER(cmd_do_fr_checktxlpdustatus), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_checktxlpdustatus), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay disable LPdu command */
"\n"
" --> frbtdisable3\n"
" Buffer disabled.\n",
- CMD_HANDLER(cmd_do_fr_disablelpdu), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_disablelpdu), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get global time command */
" --> frbtglobtime\n"
" Cycle number: 23\n"
" Macrotick number: 6\n",
- CMD_HANDLER(cmd_do_fr_getglobaltime), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getglobaltime), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get network management vector command */
"\n"
" --> frbtnmvector\n"
" Network management vector: 0 0 0 0 0 0 0 0 0 0 0 0\n",
- CMD_HANDLER(cmd_do_fr_getnmvector), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getnmvector), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get network management vector command */
"\n"
" --> frbtnmwatch\n"
" Network management vector: 0 0 0 0 0 0 0 0 0 0 0 0\n",
- CMD_HANDLER(cmd_do_fr_nmwatch), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_nmwatch), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get channel status command */
" NIT status data vSS!Bviolation: FALSE\n"
" Not used (0): FALSE\n"
" Not used (0): FALSE\n",
- CMD_HANDLER(cmd_do_fr_getchannelstatus), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getchannelstatus), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get clock correction command */
" --> frbtclkcor\n"
" Rate correction: 0\n"
" Offset correction: 0\n",
- CMD_HANDLER(cmd_do_fr_getclockcorrection), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getclockcorrection), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get sync frame list command */
" | 1 | 1 | 1 | 1 |\n"
" | 2 | 2 | 2 | 2 |\n"
" |----------------|----------------|----------------|----------------|\n",
- CMD_HANDLER(cmd_do_fr_getsyncframelist), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getsyncframelist), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get sync frame list command */
" --> frbtgetwurxstat\n"
" Wake up pattern was not yet received on channel A.\n"
" Wake up pattern was not yet received on channel B.\n",
- CMD_HANDLER(cmd_do_fr_getwakeuprxstatus), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getwakeuprxstatus), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay set absolute timer command */
" Timer was set for every 16-th cycle, offset 15, macrotick 50\n"
" --> frbtsettimer0 0x42 0\n"
" Timer was set for every 64-th cycle, offset 2, macrotick 0\n",
- CMD_HANDLER(cmd_do_fr_settimer), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_settimer), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay cancel absolute timer command */
"\n"
" --> frbtcanceltimer0\n"
" Timer was canceled.\n",
- CMD_HANDLER(cmd_do_fr_canceltimer), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_canceltimer), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay absolute timer irq manipulation command */
"\n"
" --> frbttimerirq0 EN\n"
" OK\n",
- CMD_HANDLER(cmd_do_fr_timerirq), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_timerirq), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get version info command */
" sw_major_version: 0x1\n"
" sw_minor_version: 0x2\n"
" sw_patch_version: 0x4\n",
- CMD_HANDLER(cmd_do_fr_getversioninfo), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_getversioninfo), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay get controller configuration command */
"\n"
" --> frbtccconfig1\n"
" Value = 0x1\n",
- CMD_HANDLER(cmd_do_fr_readcconfig), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_readcconfig), (void *)&cmd_list_fr_basic_test
};
/** Command descriptor for FlexRay reconfigure buffer command */
"\n"
" --> frbtreconfigurebuf id2 slot3 AB cycset1 cycoffset0 max9\n"
" frbtreconfigurebuf id2 slot3 AB cycset1 cycoffset0 max9\n",
- CMD_HANDLER(cmd_do_fr_reconfigure_buffer), (void*)&cmd_list_fr_basic_test
+ CMD_HANDLER(cmd_do_fr_reconfigure_buffer), (void *)&cmd_list_fr_basic_test
};
" --> frayxcvrstat1\n"
"\n"
"Prints the status of FRAY1 transceiver.\n",
- CMD_HANDLER(cmd_do_fray_status), (void*)&cmd_list_fray
+ CMD_HANDLER(cmd_do_fray_status), (void *)&cmd_list_fray
};
/** Command descriptor for FlexRay 1 test node A */
"that the message was transmitted correctly, X signals a transmission\n"
"error. The number of TX errors and successfully transmitted messages\n"
"is maintained during the test and printed at the end.\n",
- CMD_HANDLER(cmd_do_test_frayA), (void*)&cmd_list_fray
+ CMD_HANDLER(cmd_do_test_frayA), (void *)&cmd_list_fray
};
/** Command descriptor for FlexRay 1 test node B */
"means timeout (i.e. no message was received within 63 cycles). The\n"
"number of RX errors and successfully received messages is maintained\n"
"during the test and printed at the end.\n",
- CMD_HANDLER(cmd_do_test_frayB), (void*)&cmd_list_fray
+ CMD_HANDLER(cmd_do_test_frayB), (void *)&cmd_list_fray
};
/** List of commands for din, defined as external */
"\n"
"Enables HBR with period 1000 microseconds (frequency 1 kHz). HBR\n"
"output is still inactive, but ready for other commands.\n",
- CMD_HANDLER(cmd_do_hbr_enable), (void*)&cmd_list_hbr
+ CMD_HANDLER(cmd_do_hbr_enable), (void *)&cmd_list_hbr
};
/** Command descriptor for HBR control command */
"\n"
"Stops the motor, but the H-Bridge output is active (low-side active\n"
"free wheeling).\n",
- CMD_HANDLER(cmd_do_hbr_control), (void*)&cmd_list_hbr
+ CMD_HANDLER(cmd_do_hbr_control), (void *)&cmd_list_hbr
};
/** Command descriptor for HBR disable command */
" hbrdisable=0\n"
"\n"
"Stops motor and disables the H-bridge.\n",
- CMD_HANDLER(cmd_do_hbr_disable), (void*)&cmd_list_hbr
+ CMD_HANDLER(cmd_do_hbr_disable), (void *)&cmd_list_hbr
};
/** List of commands for hbr, defined as external */
" OK\n"
"\n"
"Detects the state of the HOUT1 and prints OK, FAIL or NOT RUNNING.\n",
- CMD_HANDLER(cmd_do_test_hout_fault), (void*)&cmd_list_hout
+ CMD_HANDLER(cmd_do_test_hout_fault), (void *)&cmd_list_hout
};
/** Command descriptor for hout read IFBK command */
" HOUT4: 0\n"
" HOUT5: 38924\n"
" HOUT6: 1342231444\n",
- CMD_HANDLER(cmd_do_read_hout_ifbk_values), (void*)&cmd_list_hout
+ CMD_HANDLER(cmd_do_read_hout_ifbk_values), (void *)&cmd_list_hout
};
/** Command descriptor for HOUT set PWM command */
"\n"
"Prints the actual period of HOUT1 PWM in microseconds and the duty\n"
"cycle in percents.\n",
- CMD_HANDLER(cmd_do_hout_pwm), (void*)&cmd_list_hout
+ CMD_HANDLER(cmd_do_hout_pwm), (void *)&cmd_list_hout
};
/** Command descriptor for PWM start command */
" --> houtstartpwm1\n"
"\n"
"HOUT1 PWM generation will be started.\n",
- CMD_HANDLER(cmd_do_hout_pwm_start), (void*)&cmd_list_hout
+ CMD_HANDLER(cmd_do_hout_pwm_start), (void *)&cmd_list_hout
};
/** Command descriptor for PWM stop command */
" --> houtstoppwm1\n"
"\n"
"HOUT1 PWM generation will be deactivated.\n",
- CMD_HANDLER(cmd_do_hout_pwm_stop), (void*)&cmd_list_hout
+ CMD_HANDLER(cmd_do_hout_pwm_stop), (void *)&cmd_list_hout
};
/** List of commands for hout, defined as external */
"This command can be used for testing the LIN. The command starts to\n"
"send a short message on the LIN port and is testing if it is correctly\n"
"received via an internal loopback.\n",
- CMD_HANDLER(cmd_do_lin_loop_back), (void*)&cmd_list_lin
+ CMD_HANDLER(cmd_do_lin_loop_back), (void *)&cmd_list_lin
};
/** List of commands for lin, defined as external */
" --> loutset2 0\n"
"\n"
"Sets LOUT2 to 0.\n",
- CMD_HANDLER(cmd_do_lout_set), (void*)&cmd_list_lout
+ CMD_HANDLER(cmd_do_lout_set), (void *)&cmd_list_lout
};
/** Command descriptor for lout get pin diag value */
" --> loutdiag1\n"
"\n"
"Reads value of the LOUT1 diagnostic signal.\n",
- CMD_HANDLER(cmd_do_lout_diag), (void*)&cmd_list_lout
+ CMD_HANDLER(cmd_do_lout_diag), (void *)&cmd_list_lout
};
"\n"
"The purpose of this pair of commands is to demonstrate functionality\n"
"of the FlexRay, ADC, DIN and HBR peripherals.\n",
- CMD_HANDLER(cmd_do_control), (void*)&cmd_list_motor_example
+ CMD_HANDLER(cmd_do_control), (void *)&cmd_list_motor_example
};
/** Command descriptor for motor */
"\n"
"The purpose of this pair of commands is to demonstrate functionality\n"
"of the FlexRay, ADC, DIN and HBR peripherals.\n",
- CMD_HANDLER(cmd_do_motor), (void*)&cmd_list_motor_example
+ CMD_HANDLER(cmd_do_motor), (void *)&cmd_list_motor_example
};
/** List of commands for example, defined as external */
struct pbuf *p;
boolean_t ncStop = FALSE;
boolean_t flush = FALSE;
- struct nc_arg *nc_arg = (struct nc_arg*)arg;
+ struct nc_arg *nc_arg = (struct nc_arg *)arg;
struct netif *netif = rpp_eth_get_netif(INTERFACE_INSTANCE_NUMBER);
/* fill options from argument */
err_t nc_accept_callback(void *arg, struct tcp_pcb *newpcb, err_t err)
{
- struct tcp_pcb * *newone = arg;
+ struct tcp_pcb **newone = arg;
*newone = newpcb; /* pass accepted connection to main app loop */
/* examine parameters */
for (pindex = 1; param[pindex] != 0; pindex++) {
- if (strncmp((char*)param[pindex], "-h", 3) == 0) {
+ if (strncmp((char *)param[pindex], "-h", 3) == 0) {
help = TRUE;
break;
}
- else if (strncmp((char*)param[pindex], "-u", 3) == 0) {
+ else if (strncmp((char *)param[pindex], "-u", 3) == 0) {
udp = TRUE;
#if !NO_SYS
}
- else if (strncmp((char*)param[pindex], "-t", 3) == 0)
+ else if (strncmp((char *)param[pindex], "-t", 3) == 0)
nc_arg.thread = TRUE;
- else if (strncmp((char*)param[pindex], "-c", 3) == 0) {
+ else if (strncmp((char *)param[pindex], "-c", 3) == 0) {
closeths = TRUE;
return ERR_OK;
#endif
}
- else if (strncmp((char*)param[pindex], "-l", 3) == 0 && !srcPortSpec) {
+ else if (strncmp((char *)param[pindex], "-l", 3) == 0 && !srcPortSpec) {
listen = TRUE;
- srcPortNO = rpp_eth_portStrToInt((uint8_t*)param[++pindex]);
+ srcPortNO = rpp_eth_portStrToInt((uint8_t *)param[++pindex]);
if (srcPortNO == 0) {
rpp_sci_printf("E wrong portNO, portNO must follow immediately after -l option\r\n");
return BAD_PORT_NO;
}
srcPortSpec = TRUE;
}
- else if (strncmp((char*)param[pindex], "-p", 3) == 0 && !srcPortSpec) {
- srcPortNO = rpp_eth_portStrToInt((uint8_t*)param[++pindex]);
+ else if (strncmp((char *)param[pindex], "-p", 3) == 0 && !srcPortSpec) {
+ srcPortNO = rpp_eth_portStrToInt((uint8_t *)param[++pindex]);
if (srcPortNO == 0) {
rpp_sci_printf("E wrong portNO, portNO must follow immediately after -p option\r\n");
return BAD_PORT_NO;
}
srcPortSpec = TRUE;
}
- else if (strncmp((char*)param[pindex], "-m", 3) == 0)
+ else if (strncmp((char *)param[pindex], "-m", 3) == 0)
netLoop = TRUE;
- else if (strncmp((char*)param[pindex], "-d", 3) == 0)
+ else if (strncmp((char *)param[pindex], "-d", 3) == 0)
test = TRUE;
- else if ( (err = rpp_eth_stringToIP(&remoteIP, (uint8_t*)param[pindex])) == SUCCESS ) {
- portNO = rpp_eth_portStrToInt((uint8_t*)param[++pindex]);
+ else if ( (err = rpp_eth_stringToIP(&remoteIP, (uint8_t *)param[pindex])) == SUCCESS ) {
+ portNO = rpp_eth_portStrToInt((uint8_t *)param[++pindex]);
if (portNO == 0) {
rpp_sci_printf("E wrong portNO, portNO must follow immediately after IP address\r\n");
return BAD_PORT_NO;
rpp_sci_printf("STARTING THREAD: %s\r\n", name);
taskNameNum++;
/* start thread */
- if ((err = xTaskCreate(&run_nc,(const signed char*)name, ncTaskStackSize, &nc_arg, ncTaskPriority, NULL)) == pdPASS) {
+ if ((err = xTaskCreate(&run_nc,(const signed char *)name, ncTaskStackSize, &nc_arg, ncTaskPriority, NULL)) == pdPASS) {
/* block on semaphore, till new thread copies arg to own stack */
xSemaphoreTake( nc_arg.args_coppied, portMAX_DELAY );
vSemaphoreDelete(nc_arg.args_coppied);
"Wait for a TCP connection on local port 30000 and loop all incoming data\n"
"back:\n"
" --> ethnc -l 30000 -m\n",
- CMD_HANDLER(cmd_do_init_nc), (void*)&cmd_list_nc
+ CMD_HANDLER(cmd_do_init_nc), (void *)&cmd_list_nc
};
/** List of commands for lwip, defined as external */
}
uint8_t macaddr[18];
rpp_eth_get_macAddrStr(INTERFACE_INSTANCE_NUMBER,macaddr);
- rpp_sci_printf((const char*)"%s\n", macaddr);
+ rpp_sci_printf((const char *)"%s\n", macaddr);
return SUCCESS;
}
return EMAC_CTRL_RAM_BASE_m(0) + bd_num*sizeof(struct emac_tx_bd);
}
-volatile struct emac_tx_bd*findPreviousBD(volatile struct emac_tx_bd *bufferDescriptor)
+volatile struct emac_tx_bd *findPreviousBD(volatile struct emac_tx_bd *bufferDescriptor)
{
volatile struct emac_tx_bd *temporary = bufferDescriptor - 1;
return temporary;
temporary = (temporary + 1); /* going through memory, if you want to go through bd chains put here 'temporary = temporary->next;' */
if ( (uint32_t)(temporary+1) > EMAC_CTRL_RAM_BASE_m(0)+SIZE_EMAC_CTRL_RAM) /* when out of CPPI RAM */
- temporary = (struct emac_tx_bd*)EMAC_CTRL_RAM_BASE_m(0); /* continue scanning from the beginning */
+ temporary = (struct emac_tx_bd *)EMAC_CTRL_RAM_BASE_m(0); /* continue scanning from the beginning */
}
- return (struct emac_tx_bd*)-1; /* not found */
+ return (struct emac_tx_bd *)-1; /* not found */
}
void print_bd_content(volatile struct emac_tx_bd *bufferDescriptor, boolean_t humanReadable)
*/
void print_bds_state(uint8_t mode, uint8_t param)
{
- volatile struct emac_tx_bd *bufferDescriptor = (struct emac_tx_bd*)EMAC_CTRL_RAM_BASE_m(0);
+ volatile struct emac_tx_bd *bufferDescriptor = (struct emac_tx_bd *)EMAC_CTRL_RAM_BASE_m(0);
uint16_t index = 0;
rpp_sci_printf("TX:");
/* examine parameters */
for (pindex = 1; param[pindex] != 0; pindex++) {
- if (strncmp((char*)param[pindex], "-i", 3) == 0) {
+ if (strncmp((char *)param[pindex], "-i", 3) == 0) {
interactive = TRUE;
break;
}
- else if (strncmp((char*)param[pindex], "-o", 3) == 0) {
+ else if (strncmp((char *)param[pindex], "-o", 3) == 0) {
overview = TRUE;
break;
}
#if RPP_ETH_STATS
- else if (strncmp((char*)param[pindex], "-r", 3) == 0) {
+ else if (strncmp((char *)param[pindex], "-r", 3) == 0) {
isrRun = TRUE;
break;
}
- else if (strncmp((char*)param[pindex], "-rb", 4) == 0) {
+ else if (strncmp((char *)param[pindex], "-rb", 4) == 0) {
rb = TRUE;
break;
}
- else if (strncmp((char*)param[pindex], "-tb", 4) == 0) {
+ else if (strncmp((char *)param[pindex], "-tb", 4) == 0) {
tb = TRUE;
break;
}
if (input == 'b') { /* print buffer descriptor at given address */
rpp_sci_printf("-? 0x");
- bufferDescriptor = (struct emac_tx_bd*)readNum(8,8,TRUE);
+ bufferDescriptor = (struct emac_tx_bd *)readNum(8,8,TRUE);
rpp_sci_printf("\n");
/* check it fits EMAC CPPI RAM */
/*if(bufferDescriptor >= EMAC_CTRL_RAM_BASE_m(INTERFACE_INSTANCE_NUMBER) && (bufferDescriptor + sizeof(struct emac_tx_bd)) <= EMAC_CTRL_RAM_BASE_m(INTERFACE_INSTANCE_NUMBER) + SIZE_EMAC_CTRL_RAM)
"\n"
" --> ethlinkstat\n"
" et0 : DOWN\n",
- CMD_HANDLER(cmd_do_read_linkstat), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_read_linkstat), (void *)&cmd_list_netstats
};
cmd_des_t const cmd_des_mac = {
"\n"
" --> ethmac\n"
" 12:34:56:78:9a:bc\n",
- CMD_HANDLER(cmd_do_read_mac), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_read_mac), (void *)&cmd_list_netstats
};
cmd_des_t const cmd_des_ip = {
" Address: 192.168.247.1\n"
" Netmask: 255.255.255.0\n"
" Gateway: 192.168.247.255\n",
- CMD_HANDLER(cmd_do_read_ip), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_read_ip), (void *)&cmd_list_netstats
};
cmd_des_t const cmd_des_bufferdescriptors = {
"### Example ###\n"
"\n"
" --> ethbd\n",
- CMD_HANDLER(cmd_do_bufferdescriptors), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_bufferdescriptors), (void *)&cmd_list_netstats
};
#if LWIP_DHCP
"\n"
" --> dhcp\n"
" \n",
- CMD_HANDLER(cmd_do_dhcp), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_dhcp), (void *)&cmd_list_netstats
};
#endif
".\n"
"Shown sections depends on modules compiled in.\n"
" \n",
- CMD_HANDLER(cmd_do_lwip), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_lwip), (void *)&cmd_list_netstats
};
#endif /* if LWIP_STATS_DISPLAY */
"\n"
" --> ethinit\n"
" \n",
- CMD_HANDLER(cmd_do_ethinit), (void*)&cmd_list_netstats
+ CMD_HANDLER(cmd_do_ethinit), (void *)&cmd_list_netstats
};
/** List of commands for lwip, defined as external */
" HOUT5DIAG\n"
" HOUT6IN\n"
" HOUT6DIAG\n",
- CMD_HANDLER(cmd_do_pin_list), (void*)&cmd_list_pin
+ CMD_HANDLER(cmd_do_pin_list), (void *)&cmd_list_pin
};
/** Command descriptor for pin get/set value */
" pinvalHBREN=1\n"
"\n"
"Gets a value of the HBR_EN pin.\n",
- CMD_HANDLER(cmd_do_pin_val), (void*)&cmd_list_pin
+ CMD_HANDLER(cmd_do_pin_val), (void *)&cmd_list_pin
};
/** Command descriptor for pin get/set direction */
" pindirHBREN=1\n"
"\n"
"Gets the direction of the HBR_EN pin.\n",
- CMD_HANDLER(cmd_do_pin_dir), (void*)&cmd_list_pin
+ CMD_HANDLER(cmd_do_pin_dir), (void *)&cmd_list_pin
};
/** List of commands for pin, defined as external */
"MOUT5IN=1\n"
"MOUT6IN=1\n"
"Which is shown in getter output\n",
- CMD_HANDLER(cmd_do_port_val), (void*)&cmd_list_port
+ CMD_HANDLER(cmd_do_port_val), (void *)&cmd_list_port
};
/** Command descriptor for port list printout */
" FRAY2, SPI\n"
" MOUTEN, GPIO\n"
" MOUTIN, GPIO\n",
- CMD_HANDLER(cmd_do_port_list), (void*)&cmd_list_port
+ CMD_HANDLER(cmd_do_port_list), (void *)&cmd_list_port
};
/** List of commands for port, defined as external */
while (!stop_tasks) {
// Put something in the log
- rpp_sdr_printf((const char*)
+ rpp_sdr_printf((const char *)
"This is the noise generator at iteration %d "
"putting some noise value %d.", i, rand()
);
// after the noise task could not be created, forcing to close the just
// opened command processor.
portBASE_TYPE task_created = xTaskCreate(sdr_test_task,
- (const signed char*)"sdr_test_task",
+ (const signed char *)"sdr_test_task",
TEST_TASK_STACK, NULL, TEST_TASK_PRIORITY,
&test_task_handle
);
if (task_created != pdPASS) {
- rpp_sci_printf((const char*)
+ rpp_sci_printf((const char *)
"ERROR: Problem spawning the test task. "
"Error code: %d\r\n", (uint32_t)task_created
);
tasks_running++;
if (rpp_sdr_setup(TRUE) != SUCCESS) {
- rpp_sci_printf((const char*)
+ rpp_sci_printf((const char *)
"ERROR: Problem enabling the logging module. "
);
wait_for_quit();
/// Reset module configuration
if (rpp_sdr_setup(FALSE) != SUCCESS) {
- rpp_sci_printf((const char*)
+ rpp_sci_printf((const char *)
"ERROR: Could not stop logging module.\r\n"
);
wait_for_quit();
}
- rpp_sci_printf((const char*)"\r\n");
+ rpp_sci_printf((const char *)"\r\n");
return;
}
*/
int cmd_do_test_ram(cmd_io_t *cmd_io, const struct cmd_des *des, char *param[])
{
- volatile uint32_t *addrPtr = (uint32_t*)0x80000000U;
- volatile uint32_t *endAddr = (uint32_t*)0x83FFFFFFU;
+ volatile uint32_t *addrPtr = (uint32_t *)0x80000000U;
+ volatile uint32_t *endAddr = (uint32_t *)0x83FFFFFFU;
uint32_t pattern = 0x55555555U;
uint32_t cnt = 0;
uint32_t errCnt = 0;
addrPtr++;
}
- addrPtr = (uint32_t*)0x80000000U;
+ addrPtr = (uint32_t *)0x80000000U;
pattern = 0x55555555U;
while (addrPtr <= endAddr) {
readVal = *addrPtr;
"\n"
" --> sdramtest\n"
" SDRAM installed: 64 MB\n",
- CMD_HANDLER(cmd_do_test_ram), (void*)&cmd_list_sdram
+ CMD_HANDLER(cmd_do_test_ram), (void *)&cmd_list_sdram
};
/** Command descriptor for test log to SDRAM */
"\n"
"The command opens a subcommand processor, which contains testing\n"
"commands for logging into SDRAM.\n",
- CMD_HANDLER(cmd_do_test_log), (void*)&cmd_list_sdram
+ CMD_HANDLER(cmd_do_test_log), (void *)&cmd_list_sdram
};
/** List of commands for sdram, defined as external */
"readable form.\n"
"Please notice LSB->MSB conversion of the portval result. The necessity\n"
"of the conversion depends on the controller of the examined port.\n",
- CMD_HANDLER(cmd_do_spi_translate), (void*)&cmd_list_spi
+ CMD_HANDLER(cmd_do_spi_translate), (void *)&cmd_list_spi
};
/** Command descriptor for SPI trasfer */
" spirx:0x0(0x3f,0xc0,0xff)\n"
"\n"
"Sends reset command (0x7F0000) to the DIN peripheral.\n",
- CMD_HANDLER(cmd_do_spimst), (void*)&cmd_list_spi
+ CMD_HANDLER(cmd_do_spimst), (void *)&cmd_list_spi
};
/** List of commands for SPI, defined as external */
"Please note that parameters for the PWM signal may change from device\n"
"to device and it might be necessary to tune them (in source code) for\n"
"each device.\n",
- CMD_HANDLER(cmd_do_power_on), (void*)&cmd_list_vbat
+ CMD_HANDLER(cmd_do_power_on), (void *)&cmd_list_vbat
};
/** Command descriptor for poweroff */
"### Description ###\n"
"\n"
"This command turns off VBAT and VBAT1 voltages.\n",
- CMD_HANDLER(cmd_do_power_off), (void*)&cmd_list_vbat
+ CMD_HANDLER(cmd_do_power_off), (void *)&cmd_list_vbat
};
/** List of commands for vbat, defined as external */
static int cmp_des(const void *p1, const void *p2)
{
- const cmd_des_t*const *c1 = p1, *const *c2 = p2;
+ const cmd_des_t *const *c1 = p1, *const *c2 = p2;
return strcmp((*c1)->name, (*c2)->name);
int main(int argc, char *argv[])
{
const cmd_des_t *des;
- const cmd_des_t * *des_arr = cmd_list_main;
- cmd_des_t const * *arr_stack[CMD_ARR_STACK_SIZE];
+ const cmd_des_t **des_arr = cmd_list_main;
+ cmd_des_t const **arr_stack[CMD_ARR_STACK_SIZE];
int arr_stack_sp = 0;
enum disp_mode mode = SHORT_HELP;
}
if (des == CMD_DES_CONTINUE_AT_ID) {
/* list continues at new address */
- des_arr = (const cmd_des_t**)*des_arr;
+ des_arr = (const cmd_des_t **)*des_arr;
continue;
}
if (des == CMD_DES_INCLUDE_SUBLIST_ID) {
des_arr++;
else {
arr_stack[arr_stack_sp++] = des_arr+1;
- des_arr = (const cmd_des_t**)*des_arr;
+ des_arr = (const cmd_des_t **)*des_arr;
continue;
}
}
void vApplicationMallocFailedHook(void)\r
{\r
#ifdef DEBUG\r
- rpp_sci_printf((const char*)\r
+ rpp_sci_printf((const char *)\r
"ERROR: manual memory allocation failed.\r\n"\r
);\r
#endif\r
signed portCHAR *pcTaskName)\r
{\r
#ifdef DEBUG\r
- rpp_sci_printf((const char*)\r
+ rpp_sci_printf((const char *)\r
"ERROR: Stack overflow : \"%s\".\r\n", pcTaskName\r
);\r
#endif\r
projects / pes-rpp / rpp-test-sw.git / commitdiff