Skip to content
Snippets Groups Projects
Commit 1bad50ee authored by Stauder, Lucas's avatar Stauder, Lucas
Browse files

Initial Commit WiSe 2024/25

parents
No related branches found
No related tags found
No related merge requests found
# CLion
/.idea
/*-build-*
# Visual Studio
/.vs
/out
# vscode
/.vscode
/build
cmake_minimum_required(VERSION 3.26)
project(Uebung02)
set(CMAKE_CXX_STANDARD 14)
add_executable(Uebung02
src/main.c
src/log2.c
src/log2.h
src/bit_mods.c
src/bit_mods.h
src/bit_mods_macros.h
src/mp2723.c
src/mp2723.h
)
# Fetch GoogleTest
Include(FetchContent)
FetchContent_Declare(
googletest
GIT_REPOSITORY https://github.com/google/googletest.git
GIT_TAG v1.15.2
)
set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
FetchContent_MakeAvailable(googletest)
# Build Tests
enable_testing()
add_executable(test_log
src/log2.c
src/log2.h
src/log.test.cpp
)
add_executable(test_bitmods
src/bit_mods.c
src/bit_mods.h
src/bit_mods.test.cpp
)
add_executable(test_bitmods_macros
src/bit_mods_macros.h
src/bit_mods_macros.test.cpp
)
add_executable(test_mp2723
src/mp2723.c
src/mp2723.h
src/mp2723.test.cpp
)
target_link_libraries(test_log PRIVATE GTest::gtest_main)
target_link_libraries(test_bitmods PRIVATE GTest::gtest_main)
target_link_libraries(test_bitmods_macros PRIVATE GTest::gtest_main)
target_link_libraries(test_mp2723 PRIVATE GTest::gtest_main)
target_include_directories(test_log PRIVATE src/)
target_include_directories(test_bitmods PRIVATE src/)
target_include_directories(test_bitmods_macros PRIVATE src/)
target_include_directories(test_mp2723 PRIVATE src/)
include(GoogleTest)
gtest_discover_tests(test_log)
gtest_discover_tests(test_bitmods)
gtest_discover_tests(test_bitmods_macros)
gtest_discover_tests(test_mp2723)
#include "bit_mods.h"
bool readBit(uint32_t data, uint8_t position) {
// TODO
return false;
}
uint32_t setBit(uint32_t data, uint8_t position) {
// TODO
return 0;
}
uint32_t clearBit(uint32_t data, uint8_t position) {
// TODO
return 0;
}
uint32_t toggleBit(uint32_t data, uint8_t position) {
// TODO
return 0;
}
uint32_t assignBit(uint32_t data, uint8_t position, bool value) {
// TODO
return 0;
}
#ifndef UEBUNG02_BIT_MODS_H
#define UEBUNG02_BIT_MODS_H
#include <stdbool.h>
#include <stdint.h>
bool readBit(uint32_t data, uint8_t position);
uint32_t setBit(uint32_t data, uint8_t position);
uint32_t clearBit(uint32_t data, uint8_t position);
uint32_t toggleBit(uint32_t data, uint8_t position);
uint32_t assignBit(uint32_t data, uint8_t position, bool value);
#endif // UEBUNG02_BIT_MODS_H
extern "C" {
#include "bit_mods.h"
}
#include <gtest/gtest.h>
TEST(bit_mods, read_bit) {
EXPECT_TRUE(readBit(0b1011011, 0));
EXPECT_FALSE(readBit(0b1011010, 0));
EXPECT_TRUE(readBit(0b1011011, 1));
EXPECT_FALSE(readBit(0b1011011, 2));
EXPECT_FALSE(readBit(0b1011011, 5));
EXPECT_TRUE(readBit(0b1011011, 6));
EXPECT_TRUE(readBit(0xA1234567, 31));
EXPECT_FALSE(readBit(0x71234567, 31));
}
TEST(bit_mods, set_bit) {
EXPECT_EQ(setBit(0b0, 0), 0b1);
EXPECT_EQ(setBit(0b1, 0), 0b1);
EXPECT_EQ(setBit(0b0, 1), 0b10);
EXPECT_EQ(setBit(0b0, 3), 0b1000);
EXPECT_EQ(setBit(0b0001, 3), 0b1001);
EXPECT_EQ(setBit(0xA1234567, 31), 0xA1234567);
EXPECT_EQ(setBit(0x71234567, 31), 0xF1234567);
EXPECT_EQ(setBit(0b0, 0), 0b1);
EXPECT_EQ(setBit(0b0, 1), 0b10);
EXPECT_EQ(setBit(0b0, 3), 0b1000);
EXPECT_EQ(setBit(0b0001, 3), 0b1001);
}
TEST(bit_mods, clear_bit) {
EXPECT_EQ(clearBit(0b1, 0), 0b0);
EXPECT_EQ(clearBit(0b11, 1), 0b01);
EXPECT_EQ(clearBit(0b1111, 2), 0b1011);
EXPECT_EQ(clearBit(0b1111, 3), 0b0111);
EXPECT_EQ(clearBit(0xA1234567, 31), 0x21234567);
EXPECT_EQ(clearBit(0x71234567, 31), 0x71234567);
}
TEST(bit_mods, toggle_bit) {
EXPECT_EQ(toggleBit(0b1, 0), 0b0);
EXPECT_EQ(toggleBit(0b0, 0), 0b1);
EXPECT_EQ(toggleBit(0b11, 1), 0b01);
EXPECT_EQ(toggleBit(0b00, 1), 0b10);
EXPECT_EQ(toggleBit(0b10, 1), 0b00);
EXPECT_EQ(toggleBit(0b01, 1), 0b11);
EXPECT_EQ(toggleBit(0b1111, 2), 0b1011);
EXPECT_EQ(toggleBit(0b1011, 2), 0b1111);
EXPECT_EQ(toggleBit(0b10101011, 3), 0b10100011);
EXPECT_EQ(toggleBit(0b10100011, 3), 0b10101011);
EXPECT_EQ(toggleBit(0xA1234567, 31), 0x21234567);
EXPECT_EQ(toggleBit(0x71234567, 31), 0xF1234567);
}
TEST(bit_mods, assign_bit) {
EXPECT_EQ(assignBit(0b0, 0, true), 0b1);
EXPECT_EQ(assignBit(0b0, 0, false), 0b0);
EXPECT_EQ(assignBit(0b1, 0, true), 0b1);
EXPECT_EQ(assignBit(0b1, 0, false), 0b0);
EXPECT_EQ(assignBit(0b10, 0, true), 0b11);
EXPECT_EQ(assignBit(0b10, 0, false), 0b10);
EXPECT_EQ(assignBit(0b11, 0, true), 0b11);
EXPECT_EQ(assignBit(0b11, 0, false), 0b10);
EXPECT_EQ(assignBit(0b10101011, 3, true), 0b10101011);
EXPECT_EQ(assignBit(0b10101011, 3, false), 0b10100011);
EXPECT_EQ(assignBit(0xA1234567, 31, true), 0xA1234567);
EXPECT_EQ(assignBit(0xA1234567, 31, false), 0x21234567);
EXPECT_EQ(assignBit(0x71234567, 31, true), 0xF1234567);
EXPECT_EQ(assignBit(0x71234567, 31, false), 0x71234567);
}
#ifndef UEBUNG02_BIT_MODS_MACROS_H
#define UEBUNG02_BIT_MODS_MACROS_H
#include <stdbool.h>
#include <stdint.h>
#define READ_BIT(data, pos) 0 /* TODO */
#define SET_BIT(data, pos) 0 /* TODO */
#define CLEAR_BIT(data, pos) 0 /* TODO */
#define TOGGLE_BIT(data, pos) 0 /* TODO */
#define ASSIGN_BIT(data, pos, value) 0 /* TODO */
#endif // UEBUNG02_BIT_MODS_MACROS_H
extern "C" {
#include "bit_mods_macros.h"
}
#include <gtest/gtest.h>
TEST(bit_mods_macros, read_bit) {
EXPECT_TRUE(READ_BIT(0b1011011, 0));
EXPECT_FALSE(READ_BIT(0b1011010, 0));
EXPECT_TRUE(READ_BIT(0b1011011, 1));
EXPECT_FALSE(READ_BIT(0b1011011, 2));
EXPECT_FALSE(READ_BIT(0b1011011, 5));
EXPECT_TRUE(READ_BIT(0b1011011, 6));
EXPECT_TRUE(READ_BIT(0xA1234567, 31));
EXPECT_FALSE(READ_BIT(0x71234567, 31));
// check if macro returns exactly "1" for "true"
EXPECT_EQ(READ_BIT(0b1011011, 6), 1);
}
TEST(bit_mods_macros, read_bit_args) {
EXPECT_FALSE(READ_BIT(0b11111011, 1 << 1));
EXPECT_TRUE(READ_BIT(0b00000100, 1 << 1));
EXPECT_FALSE(READ_BIT(0b11111011 << 1, 3));
EXPECT_TRUE(READ_BIT(0b00000100 << 1, 3));
}
TEST(bit_mods_macros, set_bit) {
uint32_t reg;
reg = 0b0;
SET_BIT(reg, 0);
EXPECT_EQ(reg, 0b1);
reg = 0b1;
SET_BIT(reg, 0);
EXPECT_EQ(reg, 0b1);
reg = 0b0;
SET_BIT(reg, 1);
EXPECT_EQ(reg, 0b10);
reg = 0b0;
SET_BIT(reg, 3);
EXPECT_EQ(reg, 0b1000);
reg = 0b0001;
SET_BIT(reg, 3);
EXPECT_EQ(reg, 0b1001);
reg = 0xA1234567;
SET_BIT(reg, 31);
EXPECT_EQ(reg, 0xA1234567);
reg = 0x71234567;
SET_BIT(reg, 31);
EXPECT_EQ(reg, 0xF1234567);
reg = 0b0;
SET_BIT(reg, 0);
EXPECT_EQ(reg, 0b1);
reg = 0b0;
SET_BIT(reg, 1);
EXPECT_EQ(reg, 0b10);
reg = 0b0;
SET_BIT(reg, 3);
EXPECT_EQ(reg, 0b1000);
reg = 0b0001;
SET_BIT(reg, 3);
EXPECT_EQ(reg, 0b1001);
}
TEST(bit_mods_macros, set_bit_args) {
uint32_t reg;
reg = 0b11101111;
SET_BIT(reg, 1 << 2);
EXPECT_EQ(reg, 0xFF);
}
TEST(bit_mods_macros, clear_bit) {
uint32_t reg;
reg = 0b1;
CLEAR_BIT(reg, 0);
EXPECT_EQ(reg, 0b0);
reg = 0b11;
CLEAR_BIT(reg, 1);
EXPECT_EQ(reg, 0b01);
reg = 0b1111;
CLEAR_BIT(reg, 2);
EXPECT_EQ(reg, 0b1011);
reg = 0b1111;
CLEAR_BIT(reg, 3);
EXPECT_EQ(reg, 0b0111);
reg = 0xA1234567;
CLEAR_BIT(reg, 31);
EXPECT_EQ(reg, 0x21234567);
reg = 0x71234567;
CLEAR_BIT(reg, 31);
EXPECT_EQ(reg, 0x71234567);
}
TEST(bit_mods_macros, clear_bit_args) {
uint32_t reg;
reg = 0b00010000;
CLEAR_BIT(reg, 1 << 2);
EXPECT_EQ(reg, 0);
}
TEST(bit_mods_macros, toggle_bit) {
uint32_t reg;
reg = 0b1;
TOGGLE_BIT(reg, 0);
EXPECT_EQ(reg, 0b0);
reg = 0b0;
TOGGLE_BIT(reg, 0);
EXPECT_EQ(reg, 0b1);
reg = 0b11;
TOGGLE_BIT(reg, 1);
EXPECT_EQ(reg, 0b01);
reg = 0b00;
TOGGLE_BIT(reg, 1);
EXPECT_EQ(reg, 0b10);
reg = 0b10;
TOGGLE_BIT(reg, 1);
EXPECT_EQ(reg, 0b00);
reg = 0b01;
TOGGLE_BIT(reg, 1);
EXPECT_EQ(reg, 0b11);
reg = 0b1111;
TOGGLE_BIT(reg, 2);
EXPECT_EQ(reg, 0b1011);
reg = 0b1011;
TOGGLE_BIT(reg, 2);
EXPECT_EQ(reg, 0b1111);
reg = 0b10101011;
TOGGLE_BIT(reg, 3);
EXPECT_EQ(reg, 0b10100011);
reg = 0b10100011;
TOGGLE_BIT(reg, 3);
EXPECT_EQ(reg, 0b10101011);
reg = 0xA1234567;
TOGGLE_BIT(reg, 31);
EXPECT_EQ(reg, 0x21234567);
reg = 0x71234567;
TOGGLE_BIT(reg, 31);
EXPECT_EQ(reg, 0xF1234567);
}
TEST(bit_mods_macros, toggle_bit_args) {
uint32_t reg;
reg = 0b00010000;
TOGGLE_BIT(reg, 1 << 2);
EXPECT_EQ(reg, 0);
reg = 0b11101111;
TOGGLE_BIT(reg, 1 << 2);
EXPECT_EQ(reg, 0xFF);
}
TEST(bit_mods_macros, assign_bit) {
uint32_t reg;
reg = 0b0;
ASSIGN_BIT(reg, 0, true);
EXPECT_EQ(reg, 0b1);
// check that each value != 0 is accepted as true
reg = 0b0;
ASSIGN_BIT(reg, 0, 0xF4);
EXPECT_EQ(reg, 0b1);
reg = 0b0;
ASSIGN_BIT(reg, 0, false);
EXPECT_EQ(reg, 0b0);
reg = 0b1;
ASSIGN_BIT(reg, 0, true);
EXPECT_EQ(reg, 0b1);
reg = 0b1;
ASSIGN_BIT(reg, 0, false);
EXPECT_EQ(reg, 0b0);
reg = 0b10;
ASSIGN_BIT(reg, 0, true);
EXPECT_EQ(reg, 0b11);
reg = 0b10;
ASSIGN_BIT(reg, 0, false);
EXPECT_EQ(reg, 0b10);
reg = 0b11;
ASSIGN_BIT(reg, 0, true);
EXPECT_EQ(reg, 0b11);
reg = 0b11;
ASSIGN_BIT(reg, 0, false);
EXPECT_EQ(reg, 0b10);
reg = 0b10101011;
ASSIGN_BIT(reg, 3, true);
EXPECT_EQ(reg, 0b10101011);
reg = 0b10101011;
ASSIGN_BIT(reg, 3, false);
EXPECT_EQ(reg, 0b10100011);
reg = 0xA1234567;
ASSIGN_BIT(reg, 31, true);
EXPECT_EQ(reg, 0xA1234567);
reg = 0xA1234567;
ASSIGN_BIT(reg, 31, false);
EXPECT_EQ(reg, 0x21234567);
reg = 0x71234567;
ASSIGN_BIT(reg, 31, true);
EXPECT_EQ(reg, 0xF1234567);
reg = 0x71234567;
ASSIGN_BIT(reg, 31, false);
EXPECT_EQ(reg, 0x71234567);
}
TEST(bit_mods_macros, assign_bit_args) {
uint32_t reg;
volatile int _true = 1;
volatile int _false = 0;
reg = 0b00010000;
ASSIGN_BIT(reg, 1 << 2, _true << 1 ? 0 : 1);
EXPECT_EQ(reg, 0);
reg = 0b00010000;
ASSIGN_BIT(reg, 1 << 2, _false << 1 ? 1 : 0);
EXPECT_EQ(reg, 0);
reg = 0b11101111;
ASSIGN_BIT(reg, 1 << 2, _true << 1 ? 1 : 0);
EXPECT_EQ(reg, 0xFF);
reg = 0b11101111;
ASSIGN_BIT(reg, 1 << 2, _false << 1 ? 0 : 1);
EXPECT_EQ(reg, 0xFF);
}
extern "C" {
#include "log2.h"
}
#include <gtest/gtest.h>
#include <climits>
TEST(log2, zero) {
EXPECT_EQ(floorLog2(0), INT_MIN);
EXPECT_EQ(ceilLog2(0), INT_MIN);
}
TEST(log2, positiv) {
EXPECT_EQ(floorLog2(1), 0);
EXPECT_EQ(ceilLog2(1), 0);
EXPECT_EQ(floorLog2(2), 1);
EXPECT_EQ(ceilLog2(2), 1);
EXPECT_EQ(floorLog2(4), 2);
EXPECT_EQ(ceilLog2(4), 2);
EXPECT_EQ(floorLog2(8), 3);
EXPECT_EQ(ceilLog2(8), 3);
EXPECT_EQ(floorLog2(0x80000000), 31);
EXPECT_EQ(ceilLog2(0x80000000), 31);
}
TEST(log2, floor) {
EXPECT_EQ(floorLog2(3), 1);
EXPECT_EQ(floorLog2(5), 2);
EXPECT_EQ(floorLog2(9), 3);
EXPECT_EQ(floorLog2(INT_MAX), 30);
EXPECT_EQ(floorLog2(0x80000001), 31);
EXPECT_EQ(floorLog2(0xFFFFFFFF), 31);
}
TEST(log2, ceil) {
EXPECT_EQ(ceilLog2(3), 2);
EXPECT_EQ(ceilLog2(5), 3);
EXPECT_EQ(ceilLog2(9), 4);
EXPECT_EQ(ceilLog2(INT_MAX), 31);
EXPECT_EQ(ceilLog2(0x80000001), 32);
EXPECT_EQ(ceilLog2(0xFFFFFFFF), 32);
}
\ No newline at end of file
#include "log2.h"
#include <limits.h>
int floorLog2(unsigned int n) {
// TODO
return 0;
}
int ceilLog2(unsigned int n) {
// TODO
return 0;
}
#ifndef UEBUNG02_LOG2_H
#define UEBUNG02_LOG2_H
int floorLog2(unsigned int n);
int ceilLog2(unsigned int n);
#endif // UEBUNG02_LOG2_H
#include <stdio.h>
#include "bit_mods.h"
#include "bit_mods_macros.h"
#include "log2.h"
int main(void) {
printf("%i", clearBit(0b11, 1));
return 0;
}
#include "mp2723.h"
recharge_threshold_t getRechargeThreshold(uint8_t reg) {
// TODO
return 0;
}
uint16_t getRegVoltage_mV(uint8_t reg) {
// TODO
return 0;
}
uint8_t setRechargeThreshold(uint8_t reg, recharge_threshold_t value) {
// TODO
return 0;
}
uint8_t setRegVoltage_mV(uint8_t reg, uint16_t value) {
// TODO
return 0;
}
#ifndef UEBUNG02_MP2723_H
#define UEBUNG02_MP2723_H
#include <stdint.h>
typedef enum {
RECHARGE_THRESHOLD_100mV = 0,
RECHARGE_THRESHOLD_200mV = 1,
} recharge_threshold_t;
recharge_threshold_t getRechargeThreshold(uint8_t reg);
uint16_t getRegVoltage_mV(uint8_t reg);
uint8_t setRechargeThreshold(uint8_t reg, recharge_threshold_t value);
uint8_t setRegVoltage_mV(uint8_t reg, uint16_t value);
#endif // UEBUNG02_MP2723_H
extern "C" {
#include "mp2723.h"
}
#include <gtest/gtest.h>
TEST(mp2723, getRechargeThreshold) {
EXPECT_EQ(getRechargeThreshold(0b00000000), RECHARGE_THRESHOLD_100mV);
EXPECT_EQ(getRechargeThreshold(0b00000001), RECHARGE_THRESHOLD_200mV);
EXPECT_EQ(getRechargeThreshold(0b01100000), RECHARGE_THRESHOLD_100mV);
EXPECT_EQ(getRechargeThreshold(0b01100001), RECHARGE_THRESHOLD_200mV);
EXPECT_EQ(getRechargeThreshold(0b11111110), RECHARGE_THRESHOLD_100mV);
EXPECT_EQ(getRechargeThreshold(0b11111111), RECHARGE_THRESHOLD_200mV);
EXPECT_EQ(getRechargeThreshold(0b10011000), RECHARGE_THRESHOLD_100mV);
EXPECT_EQ(getRechargeThreshold(0b10011001), RECHARGE_THRESHOLD_200mV);
}
TEST(mp2723, getRegVoltage_mV) {
EXPECT_EQ(getRegVoltage_mV(0b00000000), 3400);
EXPECT_EQ(getRegVoltage_mV(0b10000001), 4040);
EXPECT_EQ(getRegVoltage_mV(0b11111111), 4670);
}
TEST(mp2723, setRechargeThreshold) {
EXPECT_EQ(setRechargeThreshold(0b00000001, RECHARGE_THRESHOLD_100mV),
0b00000000);
EXPECT_EQ(setRechargeThreshold(0b00000000, RECHARGE_THRESHOLD_200mV),
0b00000001);
EXPECT_EQ(setRechargeThreshold(0b11111111, RECHARGE_THRESHOLD_100mV),
0b11111110);
EXPECT_EQ(setRechargeThreshold(0b11111110, RECHARGE_THRESHOLD_200mV),
0b11111111);
EXPECT_EQ(setRechargeThreshold(0b11111110, RECHARGE_THRESHOLD_100mV),
0b11111110);
EXPECT_EQ(setRechargeThreshold(0b11111111, RECHARGE_THRESHOLD_200mV),
0b11111111);
}
TEST(mp2723, setRegVoltage_mV_exact) {
EXPECT_EQ(setRegVoltage_mV(0b11111111, 3400), 0b00000001);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4040), 0b10000001);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4070), 0b10000111);
EXPECT_EQ(setRegVoltage_mV(0b11111110, 4070), 0b10000110);
EXPECT_EQ(setRegVoltage_mV(0b11111110, 4670), 0b11111110);
}
TEST(mp2723, setRegVoltage_mV_round) {
EXPECT_EQ(setRegVoltage_mV(0b11111111, 3404), 0b00000001);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 3405), 0b00000011);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4035), 0b10000001);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4034), 0b01111111);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4052), 0b10000011);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4664), 0b11111101);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4665), 0b11111111);
}
TEST(mp2723, setRegVoltage_mV_limit) {
EXPECT_EQ(setRegVoltage_mV(0b11111111, 3399), 0b00000001);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 0), 0b00000001);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 4671), 0b11111111);
EXPECT_EQ(setRegVoltage_mV(0b11111111, 0xFFFF), 0b11111111);
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment