void print_decrypted(void)
{
printf("Odszyfrowane dane (string) : %s\n", szSecretData);
printf("Odszyfrowane dane (hex) : ");
DUMP_HEX(szSecretData, sizeof(szSecretData));
printf("\n");
}
void print_encrypted(void)
{
printf("\nZaszyfrowane dane (hex) : ");
DUMP_HEX(szSecretData, sizeof(szSecretData));
printf("\n\n");
}
void print_plaintext(void)
{
// niezaszyfrowane dane
printf("Niezaszyfrowane dane (string) : %s\n", szSecretData);
printf("Niezaszyfrowane dane (hex) :");
DUMP_HEX(szSecretData, sizeof(szSecretData));
printf("\n");
}
PUBLIC
void
Jdb_kern_info_cpu::dump_cp0_regs()
{
Mword val;
DUMP_CP0("EBase", read_c0_ebase(), val);
DUMP_INT("Ebase.CPUNum", (val & 0x3ff));
DUMP_CP0("EntryHi", read_c0_entryhi(), val);
DUMP_HEX("EntryHi.ASID", (val & 0xff));
DUMP_CP0("EPC", read_c0_epc(), val);
DUMP_CP0("Status", read_c0_status(), val);
DUMP_CP0("Cause", read_c0_cause(), val);
DUMP_CP0("PRId", read_c0_prid(), val);
DUMP_CP0("HWREna", read_c0_hwrena(), val);
DUMP_CP0("Config", read_c0_config(), val);
if (val & MIPS_CONF_M) {
DUMP_CP0("Config1", read_c0_config1(), val);
if (val & MIPS_CONF_M) {
DUMP_CP0("Config2", read_c0_config2(), val);
if (val & MIPS_CONF_M) {
DUMP_CP0("Config3", read_c0_config3(), val);
if (val & MIPS_CONF3_ULRI)
DUMP_CP0("UserLocal", read_c0_userlocal(), val);
}
}
}
if (cpu_has_vz)
DUMP_CP0("GuestCtl0", read_c0_guestctl0(), val);
if (cpu_has_guestctl0ext)
DUMP_CP0("GuestCtl0Ext", read_c0_guestctl0ext(), val);
if (cpu_has_vz)
DUMP_CP0("GTOffset", read_c0_gtoffset(), val);
if (cpu_has_guestctl1) {
DUMP_CP0("GuestCtl1", read_c0_guestctl1(), val);
DUMP_HEX("GuestCtl1.ID", (val & GUESTCTL1_ID));
}
if (cpu_has_guestctl2) {
DUMP_CP0("GuestCtl2", read_c0_guestctl2(), val);
DUMP_HEX("GuestCtl2.VIP", (val & GUESTCTL2_VIP));
}
}
int main() {
kaco::Core core;
const uint8_t node_id = 10;
auto callback = [] (const uint8_t node_id) {
PRINT("New device! ID = "<<(unsigned)node_id);
};
core.nmt.register_new_device_callback(callback);
bool success = core.start(BUSNAME, BAUDRATE);
if (!success) {
ERROR("Starting core failed.");
return EXIT_FAILURE;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
core.nmt.reset_all_nodes();
std::this_thread::sleep_for(std::chrono::seconds(1));
core.nmt.send_nmt_message(node_id,kaco::NMT::Command::start_node);
std::this_thread::sleep_for(std::chrono::seconds(1));
// set digital output
core.sdo.download(node_id, 0x6200, 0x1, 1, {0x7F});
std::this_thread::sleep_for(std::chrono::seconds(1));
// get device type (usually expedited transfer)
std::vector<uint8_t> device_type = core.sdo.upload(node_id,0x1000,0x0);
for (uint8_t device_type_byte : device_type) {
DUMP_HEX(device_type_byte);
}
std::this_thread::sleep_for(std::chrono::seconds(1));
// get device name (usually segmented transfer)
std::vector<uint8_t> device_name = core.sdo.upload(node_id,0x1008,0x0);
std::string result(reinterpret_cast<char const*>(device_name.data()), device_name.size());
PRINT("Device name: "<<result);
std::this_thread::sleep_for(std::chrono::seconds(3));
core.stop();
}
int main() {
PRINT("This example runs a counter completely without SDO transfers.");
PRINT("There must be a CiA 401 device which is configured to send 'Read input 8-bit/Digital Inputs 1-8'");
PRINT("and 'Read input 8-bit/Digital Inputs 9-16' via TPDO1 and to receive 'Write output 8-bit/Digital Outputs 1-8' via RPDO1.");
kaco::Master master;
bool success = master.start(BUSNAME, BAUDRATE);
if (!success) {
ERROR("Starting master failed.");
return EXIT_FAILURE;
}
std::this_thread::sleep_for(std::chrono::seconds(1));
if (master.num_devices()<1) {
ERROR("No devices found.");
return EXIT_FAILURE;
}
size_t index;
bool found = false;
for (size_t i=0; i<master.num_devices(); ++i) {
kaco::Device& device = master.get_device(i);
device.start();
if (device.get_device_profile_number()==401) {
index = i;
found = true;
PRINT("Found CiA 401 device with node ID "<<device.get_node_id());
}
}
if (!found) {
ERROR("This example is intended for use with a CiA 401 device but I can't find one.");
return EXIT_FAILURE;
}
kaco::Device& device = master.get_device(index);
const auto node_id = device.get_node_id();
// device.start(); // already started
success = device.load_dictionary_from_library();
if (!success) {
ERROR("Specializing device failed.");
return EXIT_FAILURE;
}
DUMP(device.get_entry("Manufacturer device name"));
// TODO: first configure PDO on device side?
device.add_receive_pdo_mapping(0x180+node_id, "Read input 8-bit/Digital Inputs 1-8", 0, 0); // offset 0,
device.add_receive_pdo_mapping(0x180+node_id, "Read input 8-bit/Digital Inputs 9-16", 1, 0); // offset 1
// transmit PDO on change
device.add_transmit_pdo_mapping(0x200+node_id, {{"Write output 8-bit/Digital Outputs 1-8", 0, 0}}); // offset 0
// transmit PDO every 500ms
//device.add_transmit_pdo_mapping(0x20A, {{"write_output", 0, 0, 0}}, kaco::TransmissionType::PERIODIC, std::chrono::milliseconds(500));
for (uint8_t i=0; i<10; ++i) {
PRINT("Set output to 0x"<<std::hex<<i<<" (via cache!) and wait 1 second");
device.set_entry("Write output 8-bit/Digital Outputs 1-8", i, 0, kaco::WriteAccessMethod::cache);
std::this_thread::sleep_for(std::chrono::seconds(1));
DUMP_HEX(device.get_entry("Write output 8-bit/Digital Outputs 1-8",0,kaco::ReadAccessMethod::cache));
DUMP_HEX(device.get_entry("Read input 8-bit/Digital Inputs 1-8",0,kaco::ReadAccessMethod::cache));
DUMP_HEX(device.get_entry("Read input 8-bit/Digital Inputs 9-16",0,kaco::ReadAccessMethod::cache));
}
master.stop();
}
