diff --git a/README.md b/README.md
index 9fe789b..7014a7e 100644
--- a/README.md
+++ b/README.md
@@ -42,42 +42,31 @@ cd enemeter-data-processing
 make build
 ```
 
-## Data Format
-
-ENEMETER data is provided in CSV format with four columns:
-
-1. **Time Delta (milliseconds)** - Time elapsed since the last measurement
-2. **Temperature (millicelsius)** - System temperature
-3. **Voltage (microvolts)** - Battery voltage
-4. **Current (nanoamperes)** - System current (positive when charging, negative when discharging)
-
-Example:
-```
-0000052051,0004815430,-1275169536,0000023192
-0000000047,0004815430,-1275169536,0000023192
-0000000047,0004815790,-1276443264,0000023192
-```
-
 ## Basic Usage
 
-Process a CSV file with default settings:
+Process a CSV file with required parameters:
 
 ```bash
-./enemeter-data-processing --input=data/data.csv
+./enemeter-data-processing process --input=data/esp32.csv --start="2023-04-01 08:00:00"
 ```
 
+The `--start` parameter specifies the starting time of the measurements and is required. 
+**Important:** You must include both the date AND time of day in the format "YYYY-MM-DD HH:MM:SS".
+
 Save results to a text file:
 
 ```bash
-./enemeter-data-processing --input=data/data.csv --output=report.txt
+./enemeter-data-processing process --input=data/esp32.csv --start="2023-04-01 08:00:00" --output=esp32_report.txt
 ```
 
 ## Command-line Options
 
-### Input/Output Options
+### Required Parameters
+- `--input=<path>`: Path to the input CSV file
+- `--start=<time>`: Start time for measurements (format: YYYY-MM-DD HH:MM:SS) - must include time of day
 
-- `--input=<path>`: Path to the input CSV file (required)
-- `--output=<path>`: Path to save the output report (optional)
+### Optional Parameters
+- `--output=<path>`: Path to save the output report
 - `--format=<text|json|csv>`: Output format (default: text)
 
 ### Processing Options
@@ -88,8 +77,8 @@ Save results to a text file:
 
 ### Time Filtering Options
 
-- `--start=<time>`: Start time for filtering (format: YYYY-MM-DD[THH:MM:SS])
-- `--end=<time>`: End time for filtering (format: YYYY-MM-DD[THH:MM:SS])
+- `--start=<time>`: (Required) Start time for measurements (format: YYYY-MM-DD HH:MM:SS) - must include time of day
+- `--end=<time>`: End time for filtering (format: YYYY-MM-DD HH:MM:SS)
 - `--window=<duration>`: Time window to process (e.g., 1h, 30m, 24h)
 
 ### Data Filtering Options
@@ -123,7 +112,7 @@ Save results to a text file:
 Process a CSV file and display all metrics:
 
 ```bash
-./enemeter-data-processing --input=data/data.csv
+./enemeter-data-processing process --input=data/esp32.csv --start="2023-04-01 08:00:00"
 ```
 
 ### Memory-Efficient Processing for Large Files
@@ -131,23 +120,21 @@ Process a CSV file and display all metrics:
 Use streaming mode with sampling for very large files:
 
 ```bash
-./enemeter-data-processing --input=big-data.csv --stream --sample=10
+./enemeter-data-processing process --input=big-data.csv --start="2023-04-01 10:15:30" --stream --sample=10
 ```
 
 This processes only every 10th record, reducing memory requirements.
 
-### Filtering by Time
+### Time-Based Analysis
 
-Process data from a specific time range:
+To analyze data from a specific time period:
 
 ```bash
-./enemeter-data-processing --input=data.csv --start="2025-04-01" --end="2025-04-02"
-```
-
-Process the last 24 hours of data:
+# Analyze data between specific dates and times
+./enemeter-data-processing process --input=esp32.csv --start="2023-04-01 08:00:00" --end="2023-04-02 17:30:00"
 
-```bash
-./enemeter-data-processing --input=data.csv --window=24h
+# Analyze data for a specific duration
+./enemeter-data-processing process --input=esp32.csv --start="2023-04-01 12:45:00" --window=24h
 ```
 
 ### Extracting Specific Metrics
@@ -155,13 +142,13 @@ Process the last 24 hours of data:
 Get only temperature statistics in JSON format:
 
 ```bash
-./enemeter-data-processing --input=data.csv --metric=temperature --format=json
+./enemeter-data-processing process --input=esp32.csv --start="2023-04-01 08:00:00" --metric=temperature --format=json
 ```
 
 Extract hourly energy consumption in CSV format:
 
 ```bash
-./enemeter-data-processing --input=data.csv --metric=energy_by_hour --format=csv
+./enemeter-data-processing process --input=esp32.csv --start="2023-04-01 08:00:00" --metric=energy_by_hour --format=csv
 ```
 
 ### Filtering by Data Values
@@ -169,77 +156,15 @@ Extract hourly energy consumption in CSV format:
 Process only records with voltage between specified values:
 
 ```bash
-./enemeter-data-processing --input=data.csv --volt-min=3500000 --volt-max=4200000
+./enemeter-data-processing process --input=esp32.csv --start="2023-04-01 08:00:00" --volt-min=3500000 --volt-max=4200000
 ```
 
 Process only records where temperature is above a certain threshold:
 
 ```bash
-./enemeter-data-processing --input=data.csv --min-temp=25000
+./enemeter-data-processing process --input=esp32.csv --start="2023-04-01 08:00:00" --min-temp=25000
 ```
 
 ## Output Examples
 
-### Text Output (Default)
-
-```
-========== ENEMETER DATA PROCESSING REPORT ==========
-Input File: data.csv
-Date: 2025-04-09 10:15:32
-Data Points: 1253
-Time Range: 2025-04-08 08:30:15 to 2025-04-09 08:30:10
-
-ENERGY METRICS
--------------
-Total Energy Consumed: 156.4578 joules
-Average Power: 0.0548 watts
-Peak Power: 0.1245 watts
-Estimated Energy per Day: 157.9825 joules
-Measurement Duration: 86395.00 seconds
-
-TEMPERATURE STATISTICS
----------------------
-Minimum Temperature: 22.45 °C
-Maximum Temperature: 28.95 °C
-Average Temperature: 24.75 °C
-
-... additional sections ...
-```
-
-### JSON Output
-
-```json
-{
-  "TotalJoules": 156.4578,
-  "AveragePowerWatts": 0.0548,
-  "PeakPowerWatts": 0.1245,
-  "JoulesPerDay": 157.9825,
-  "DurationSeconds": 86395.0,
-  "TemperatureStats": {
-    "MinTempCelsius": 22.45,
-    "MaxTempCelsius": 28.95,
-    "AvgTempCelsius": 24.75
-  },
-  ...
-}
-```
-
-### CSV Output
-
-```
-Metric,Value
-TotalJoules,156.457800
-AveragePowerWatts,0.054800
-PeakPowerWatts,0.124500
-JoulesPerDay,157.982500
-DurationSeconds,86395.00
-...
-```
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
-This project is licensed under the GPL License - see the LICENSE file for details.
\ No newline at end of file
+### Text Output (Default)
\ No newline at end of file
diff --git a/cmd/analyze-csv/main.go b/cmd/analyze-csv/main.go
new file mode 100644
index 0000000..848fe05
--- /dev/null
+++ b/cmd/analyze-csv/main.go
@@ -0,0 +1,163 @@
+package main
+
+import (
+	"encoding/csv"
+	"flag"
+	"fmt"
+	"math"
+	"os"
+	"strconv"
+)
+
+func main() {
+	inputFile := flag.String("input", "", "Path to the CSV file to analyze")
+	sampleSize := flag.Int("samples", 10, "Number of sample rows to display")
+	flag.Parse()
+
+	if *inputFile == "" {
+		fmt.Println("Error: Please specify an input file with --input")
+		os.Exit(1)
+	}
+
+	file, err := os.Open(*inputFile)
+	if err != nil {
+		fmt.Printf("Error opening file: %v\n", err)
+		os.Exit(1)
+	}
+	defer func() {
+		if closeErr := file.Close(); closeErr != nil {
+			fmt.Printf("Warning: Error closing file: %v\n", closeErr)
+		}
+	}()
+
+	reader := csv.NewReader(file)
+
+	fmt.Printf("Analyzing file: %s\n", *inputFile)
+	fmt.Printf("Showing %d sample rows:\n\n", *sampleSize)
+
+	var timeDeltas []int64
+	var voltages []int64
+	var currents []int64
+	var temps []int64
+
+	fmt.Println("RAW DATA SAMPLES:")
+	fmt.Println("---------------------------------------------------------------")
+	fmt.Printf("%-15s %-15s %-15s %-15s\n", "TIME_DELTA", "VOLTAGE", "CURRENT", "TEMP")
+	fmt.Println("---------------------------------------------------------------")
+
+	for i := 0; i < *sampleSize; i++ {
+		row, err := reader.Read()
+		if err != nil {
+			break
+		}
+
+		if len(row) != 4 {
+			fmt.Printf("Row %d has %d columns, expected 4\n", i+1, len(row))
+			continue
+		}
+
+		timeDelta, _ := strconv.ParseInt(row[0], 10, 64)
+		voltage, _ := strconv.ParseInt(row[1], 10, 64)
+		current, _ := strconv.ParseInt(row[2], 10, 64)
+		temp, _ := strconv.ParseInt(row[3], 10, 64)
+
+		timeDeltas = append(timeDeltas, timeDelta)
+		voltages = append(voltages, voltage)
+		currents = append(currents, current)
+		temps = append(temps, temp)
+
+		fmt.Printf("%-15d %-15d %-15d %-15d\n", timeDelta, voltage, current, temp)
+	}
+
+	fmt.Println("\nVALUE RANGES:")
+	fmt.Println("---------------------------------------------------------------")
+
+	minTimeDelta, maxTimeDelta := findMinMax(timeDeltas)
+	minTemp, maxTemp := findMinMax(temps)
+	minVoltage, maxVoltage := findMinMax(voltages)
+	minCurrent, maxCurrent := findMinMax(currents)
+
+	fmt.Printf("Time Delta:   Min=%d ms, Max=%d ms\n", minTimeDelta, maxTimeDelta)
+	fmt.Printf("Temperature:  Min=%d, Max=%d (Raw value)\n", minTemp, maxTemp)
+	fmt.Printf("              Min=%.2f °C, Max=%.2f °C (Millicelsius)\n", float64(minTemp)/1000.0, float64(maxTemp)/1000.0)
+	fmt.Printf("              Min=%.2f °C, Max=%.2f °C (Raw/100)\n", float64(minTemp)/100.0, float64(maxTemp)/100.0)
+
+	fmt.Printf("Voltage:      Min=%d, Max=%d (Raw value)\n", minVoltage, maxVoltage)
+	fmt.Printf("              Min=%.6f V, Max=%.6f V (Microvolts)\n", float64(minVoltage)/1000000.0, float64(maxVoltage)/1000000.0)
+	fmt.Printf("              Min=%.6f V, Max=%.6f V (Millivolts)\n", float64(minVoltage)/1000.0, float64(maxVoltage)/1000.0)
+
+	fmt.Printf("Current:      Min=%d, Max=%d (Raw value)\n", minCurrent, maxCurrent)
+	fmt.Printf("              Min=%.6f A, Max=%.6f A (Nanoamperes)\n", float64(minCurrent)/1000000000.0, float64(maxCurrent)/1000000000.0)
+	fmt.Printf("              Min=%.6f A, Max=%.6f A (Microamperes)\n", float64(minCurrent)/1000000.0, float64(maxCurrent)/1000000.0)
+
+	fmt.Printf("\nSUGGESTED UNITS FOR YOUR ESP32 DATA:\n")
+	fmt.Printf("---------------------------------------------------------------\n")
+
+	suggestUnits(0, maxTemp, minVoltage, maxVoltage, minCurrent, maxCurrent)
+
+	fmt.Printf("ENEMETER DATA FORMAT INFORMATION:\n")
+	fmt.Printf("---------------------------------------------------------------\n")
+	fmt.Printf("Column order: TIME_DELTA, VOLTAGE, CURRENT, TEMP\n")
+	fmt.Printf("Temperature: Values are in millicelsius (°C = value / 1000)\n")
+	fmt.Printf("Voltage:     Values are in microvolts (V = value / 1000000)\n")
+	fmt.Printf("Current:     Values are in nanoamperes (A = value / 1000000000)\n")
+}
+
+func findMinMax(values []int64) (int64, int64) {
+	if len(values) == 0 {
+		return 0, 0
+	}
+
+	min := values[0]
+	max := values[0]
+
+	for _, val := range values {
+		if val < min {
+			min = val
+		}
+		if val > max {
+			max = val
+		}
+	}
+
+	return min, max
+}
+
+func suggestUnits(_, maxTemp, minVoltage, maxVoltage, minCurrent, maxCurrent int64) {
+	// Suggest temperature units
+	if maxTemp > 100000 {
+		fmt.Println("Temperature: Values appear to be in raw ADC format")
+		fmt.Println("             Consider using raw_value / 10 as °C")
+	} else if maxTemp > 10000 {
+		fmt.Println("Temperature: Values appear to be in millicelsius")
+		fmt.Println("             Consider using raw_value / 1000 as °C")
+	} else if maxTemp > 1000 {
+		fmt.Println("Temperature: Values appear to be in centicelsius")
+		fmt.Println("             Consider using raw_value / 100 as °C")
+	} else {
+		fmt.Println("Temperature: Values appear to be direct celsius readings")
+	}
+
+	// Suggest voltage units
+	if math.Abs(float64(minVoltage)) > 1000000 || math.Abs(float64(maxVoltage)) > 1000000 {
+		fmt.Println("Voltage:     Values appear to be in microvolts")
+		fmt.Println("             Consider using raw_value / 1000000 as V")
+	} else if math.Abs(float64(minVoltage)) > 1000 || math.Abs(float64(maxVoltage)) > 1000 {
+		fmt.Println("Voltage:     Values appear to be in millivolts")
+		fmt.Println("             Consider using raw_value / 1000 as V")
+	} else {
+		fmt.Println("Voltage:     Values appear to be direct voltage readings (V)")
+	}
+
+	// Suggest current units
+	if maxCurrent > 1000000 || minCurrent < -1000000 {
+		fmt.Println("Current:     Values appear to be in nanoamperes")
+		fmt.Println("             Consider using raw_value / 1000000000 as A")
+	} else if maxCurrent > 1000 || minCurrent < -1000 {
+		fmt.Println("Current:     Values appear to be in microamperes")
+		fmt.Println("             Consider using raw_value / 1000000 as A")
+	} else {
+		fmt.Println("Current:     Values appear to be in milliamperes")
+		fmt.Println("             Consider using raw_value / 1000 as A")
+	}
+}
diff --git a/cmd/enemeter-data-processing/main.go b/cmd/enemeter-data-processing/main.go
index 9cc022b..cd78e4b 100644
--- a/cmd/enemeter-data-processing/main.go
+++ b/cmd/enemeter-data-processing/main.go
@@ -7,7 +7,6 @@ import (
 )
 
 func main() {
-	// Display version and app name
 	fmt.Printf("%s version: %s\n", commands.AppName, commands.CurrentVersion)
 
 	if len(os.Args) < 2 {
@@ -15,10 +14,8 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Check the command
 	switch os.Args[1] {
 	case "process":
-		// Create and configure the process command
 		processCmd := commands.SetupProcessCommand()
 		if err := processCmd.Parse(os.Args[2:]); err != nil {
 			fmt.Fprintf(os.Stderr, "Error parsing arguments: %v\n", err)
@@ -26,7 +23,6 @@ func main() {
 			os.Exit(1)
 		}
 
-		// Parse CLI options and execute the process command
 		options := commands.ParseCommandLineOptions(processCmd)
 		if err := commands.ProcessCommand(options); err != nil {
 			fmt.Fprintf(os.Stderr, "Error: %v\n", err)
@@ -46,15 +42,14 @@ func main() {
 	}
 }
 
-// printUsage displays help information for the CLI tool
 func printUsage() {
 	fmt.Printf("%s - A tool for processing and analyzing ENEMETER data\n\n", commands.AppName)
 	fmt.Println("Usage:")
-	fmt.Println("  enemeter-cli <command> [options]")
+	fmt.Println("  enemeter-data-processing <command> [options]")
 	fmt.Println("\nAvailable Commands:")
 	fmt.Println("  process     Process ENEMETER data files")
 	fmt.Println("  version     Show version information")
 	fmt.Println("  help        Show help information")
 	fmt.Println("\nFor command-specific help:")
-	fmt.Println("  enemeter-cli <command> --help")
+	fmt.Println("  enemeter-data-processing <command> --help")
 }
diff --git a/internal/commands/process.go b/internal/commands/process.go
index 7d79de8..c7c719f 100644
--- a/internal/commands/process.go
+++ b/internal/commands/process.go
@@ -64,8 +64,8 @@ func SetupProcessCommand() *flag.FlagSet {
 	processCmd.Int("sample", 1, "Process every Nth record (1 = all records)")
 	processCmd.Int("max", 0, "Maximum records to process (0 = no limit)")
 
-	// Time filtering options
-	processCmd.String("start", "", "Start time for filtering (format: YYYY-MM-DD[THH:MM:SS])")
+	// Make start time required and clarify that it must include time of day
+	processCmd.String("start", "", "Start time for measurements (format: YYYY-MM-DD HH:MM:SS) - REQUIRED")
 	processCmd.String("end", "", "End time for filtering (format: YYYY-MM-DD[THH:MM:SS])")
 	processCmd.String("window", "", "Time window to process (e.g., 1h, 30m, 24h)")
 
@@ -85,20 +85,23 @@ func SetupProcessCommand() *flag.FlagSet {
 	processCmd.Usage = func() {
 		fmt.Println(AppName + " - Process and analyze ENEMETER data")
 		fmt.Println("\nUsage:")
-		fmt.Println("  enemeter-cli process [options]")
+		fmt.Println("  enemeter-data-processing process [options]")
+		fmt.Println("\nRequired Parameters:")
+		fmt.Println("  --input=<file>     Input CSV file")
+		fmt.Println("  --start=<time>     Start time in format YYYY-MM-DD HH:MM:SS (must include time of day)")
 		fmt.Println("\nExamples:")
-		fmt.Println("  # Basic usage")
-		fmt.Println("  enemeter-cli process --input=data/data.csv")
-		fmt.Println("\n  # Extract specific metrics")
-		fmt.Println("  enemeter-cli process --input=data.csv --metric=average_power")
-		fmt.Println("\n  # Filter by time window")
-		fmt.Println("  enemeter-cli process --input=data.csv --start=2025-04-01 --end=2025-04-02")
-		fmt.Println("\n  # Process large file efficiently")
-		fmt.Println("  enemeter-cli process --input=big-data.csv --stream --sample=10")
-		fmt.Println("\n  # Get temperature statistics in JSON format")
-		fmt.Println("  enemeter-cli process --input=data.csv --metric=temperature --format=json")
-		fmt.Println("\n  # Save output to a file")
-		fmt.Println("  enemeter-cli process --input=data.csv --output=report.txt")
+		fmt.Println("  Basic usage")
+		fmt.Println("  enemeter-data-processing process --input=data/data.csv --start=\"2023-04-01 12:00:00\"")
+		fmt.Println("\n  Extract specific metrics")
+		fmt.Println("  enemeter-data-processing process --input=data.csv --start=\"2023-04-01 08:30:00\" --metric=average_power")
+		fmt.Println("\n  Filter by time window")
+		fmt.Println("  enemeter-data-processing process --input=data.csv --start=\"2023-04-01\" --end=\"2023-04-02\"")
+		fmt.Println("\n  Process large file efficiently")
+		fmt.Println("  enemeter-data-processing process --input=big-data.csv --start=\"2023-04-01\" --stream --sample=10")
+		fmt.Println("\n  Get temperature statistics in JSON format")
+		fmt.Println("  enemeter-data-processing process --input=data.csv --start=\"2023-04-01\" --metric=temperature --format=json")
+		fmt.Println("\n  Save output to a file")
+		fmt.Println("  enemeter-data-processing process --input=data.csv --start=\"2023-04-01\" --output=report.txt")
 		fmt.Println("\nOptions:")
 		processCmd.PrintDefaults()
 	}
@@ -115,20 +118,90 @@ func ParseCommandLineOptions(cmd *flag.FlagSet) CommandLineOptions {
 
 	// Processing options
 	useStreaming := cmd.Lookup("stream").Value.(flag.Getter).Get().(bool)
-	sampleRate := int(cmd.Lookup("sample").Value.(flag.Getter).Get().(int64))
-	maxRecords := int(cmd.Lookup("max").Value.(flag.Getter).Get().(int64))
+
+	// Fix type casting issues - convert to int64 safely
+	sampleRateVal := cmd.Lookup("sample").Value.(flag.Getter).Get()
+	var sampleRate int
+	switch v := sampleRateVal.(type) {
+	case int64:
+		sampleRate = int(v)
+	case int:
+		sampleRate = v
+	default:
+		sampleRate = 1 // Default value if conversion fails
+	}
+
+	maxRecordsVal := cmd.Lookup("max").Value.(flag.Getter).Get()
+	var maxRecords int
+	switch v := maxRecordsVal.(type) {
+	case int64:
+		maxRecords = int(v)
+	case int:
+		maxRecords = v
+	default:
+		maxRecords = 0 // Default value if conversion fails
+	}
 
 	// Time filtering options
 	startTime := cmd.Lookup("start").Value.String()
 	endTime := cmd.Lookup("end").Value.String()
 	timeWindow := cmd.Lookup("window").Value.String()
 
-	// Data filtering options
-	minTemp := cmd.Lookup("min-temp").Value.(flag.Getter).Get().(int64)
-	voltageMin := cmd.Lookup("volt-min").Value.(flag.Getter).Get().(int64)
-	voltageMax := cmd.Lookup("volt-max").Value.(flag.Getter).Get().(int64)
-	currentMin := cmd.Lookup("curr-min").Value.(flag.Getter).Get().(int64)
-	currentMax := cmd.Lookup("curr-max").Value.(flag.Getter).Get().(int64)
+	// Data filtering options - safe type conversion for int64 values
+	minTempVal := cmd.Lookup("min-temp").Value.(flag.Getter).Get()
+	var minTemp int64
+	switch v := minTempVal.(type) {
+	case int64:
+		minTemp = v
+	case int:
+		minTemp = int64(v)
+	default:
+		minTemp = 0 // Default value if conversion fails
+	}
+
+	voltageMinVal := cmd.Lookup("volt-min").Value.(flag.Getter).Get()
+	var voltageMin int64
+	switch v := voltageMinVal.(type) {
+	case int64:
+		voltageMin = v
+	case int:
+		voltageMin = int64(v)
+	default:
+		voltageMin = 0
+	}
+
+	voltageMaxVal := cmd.Lookup("volt-max").Value.(flag.Getter).Get()
+	var voltageMax int64
+	switch v := voltageMaxVal.(type) {
+	case int64:
+		voltageMax = v
+	case int:
+		voltageMax = int64(v)
+	default:
+		voltageMax = 0
+	}
+
+	currentMinVal := cmd.Lookup("curr-min").Value.(flag.Getter).Get()
+	var currentMin int64
+	switch v := currentMinVal.(type) {
+	case int64:
+		currentMin = v
+	case int:
+		currentMin = int64(v)
+	default:
+		currentMin = 0
+	}
+
+	currentMaxVal := cmd.Lookup("curr-max").Value.(flag.Getter).Get()
+	var currentMax int64
+	switch v := currentMaxVal.(type) {
+	case int64:
+		currentMax = v
+	case int:
+		currentMax = int64(v)
+	default:
+		currentMax = 0
+	}
 
 	// Specific metrics extraction
 	metric := cmd.Lookup("metric").Value.String()
@@ -167,7 +240,12 @@ func ParseCommandLineOptions(cmd *flag.FlagSet) CommandLineOptions {
 func ProcessCommand(options CommandLineOptions) error {
 	// Validate input file
 	if options.InputFile == "" {
-		return fmt.Errorf("input file is required")
+		return fmt.Errorf("input file is required (--input)")
+	}
+
+	// Validate start time (now required)
+	if options.StartTime == "" {
+		return fmt.Errorf("start time is required (--start)")
 	}
 
 	// Ensure input file exists
@@ -258,15 +336,21 @@ func buildFilterOptions(cliOptions CommandLineOptions) (parser.FilterOptions, er
 		MaxRecords: cliOptions.MaxRecords,
 	}
 
-	// Process time filters
-	if cliOptions.StartTime != "" {
-		startTime, err := parseTimeString(cliOptions.StartTime)
-		if err != nil {
-			return filterOptions, fmt.Errorf("invalid start time: %w", err)
-		}
-		filterOptions.StartTime = &startTime
+	// Process start time (required with time of day)
+	startTime, err := parseTimeString(cliOptions.StartTime)
+	if err != nil {
+		return filterOptions, fmt.Errorf("invalid start time: %w. Must provide both date and time (YYYY-MM-DD HH:MM:SS)", err)
 	}
 
+	// Check if time component is included (not midnight exactly)
+	if startTime.Hour() == 0 && startTime.Minute() == 0 && startTime.Second() == 0 {
+		// Only warn if the time appears to be exactly midnight
+		fmt.Println("Warning: Start time appears to be exactly midnight. Make sure you provided the time of day, not just the date.")
+	}
+
+	filterOptions.StartTime = &startTime
+
+	// Process end time if specified
 	if cliOptions.EndTime != "" {
 		endTime, err := parseTimeString(cliOptions.EndTime)
 		if err != nil {
@@ -538,14 +622,14 @@ func formatMetricAsText(metric interface{}, metricType metrics.MetricType) strin
 		sb.WriteString(fmt.Sprintf("Total Discharge Time: %.2f seconds\n", batteryStats.TotalDischargeTime))
 		sb.WriteString(fmt.Sprintf("Total Charge Time: %.2f seconds\n", batteryStats.TotalChargeTime))
 		sb.WriteString(fmt.Sprintf("Discharge to Charge Ratio: %.2f%%\n", batteryStats.DischargeToChargeRatio*100))
-		sb.WriteString(fmt.Sprintf("Average Discharge Rate: %.4f watts\n", batteryStats.AverageDischargeRate))
+		sb.WriteString(fmt.Sprintf("Average Discharge Rate: %.4f watts\n\n", batteryStats.AverageDischargeRate))
 
 	case metrics.MetricSolarContribution:
 		solarStats := metric.(metrics.SolarStats)
 		sb.WriteString(fmt.Sprintf("Total Energy Produced: %.4f joules\n", solarStats.TotalEnergyProduced))
 		sb.WriteString(fmt.Sprintf("Average Output: %.4f watts\n", solarStats.AverageOutput))
 		sb.WriteString(fmt.Sprintf("Peak Output: %.4f watts\n", solarStats.PeakOutput))
-		sb.WriteString(fmt.Sprintf("Contribution to Energy: %.2f%%\n", solarStats.ContributionPercentage))
+		sb.WriteString(fmt.Sprintf("Contribution to Energy: %.2f%%\n\n", solarStats.ContributionPercentage))
 
 	default:
 		sb.WriteString(fmt.Sprintf("No text formatter available for metric type: %s\n", metricType))
diff --git a/internal/metrics/energy_calc.go b/internal/metrics/energy_calc.go
index 49e8229..92bf3d9 100644
--- a/internal/metrics/energy_calc.go
+++ b/internal/metrics/energy_calc.go
@@ -193,10 +193,12 @@ func newMetricsTracker(options MetricsOptions) *metricsTracker {
 	}
 }
 
-func (mt *metricsTracker) processRecord(record parser.EnemeterRecord, index int) {
-	volts := float64(record.VoltageMicroV) / 1_000_000.0
-	amps := float64(record.CurrentNanoA) / 1_000_000_000.0
+func (mt *metricsTracker) processRecord(record parser.EnemeterRecord, _ int) {
 	tempCelsius := float64(record.TempMiliCelsius) / 1000.0
+	volts := float64(record.VoltageMicroV) / 1000000.0
+	amps := float64(record.CurrentNanoA) / 1000000000.0
+
+	powerVolts := math.Abs(volts)
 
 	if mt.firstTimestamp {
 		mt.startTime = record.Timestamp
@@ -238,7 +240,7 @@ func (mt *metricsTracker) processRecord(record parser.EnemeterRecord, index int)
 		mt.maxCharging = amps
 	}
 
-	instantPower := volts * amps
+	instantPower := powerVolts * amps
 
 	if math.Abs(instantPower) > mt.peakPower {
 		mt.peakPower = math.Abs(instantPower)
diff --git a/internal/parser/csv_parser.go b/internal/parser/csv_parser.go
index 8632747..9cfa8e8 100644
--- a/internal/parser/csv_parser.go
+++ b/internal/parser/csv_parser.go
@@ -54,7 +54,6 @@ func (p *CSVParser) Parse() ([]EnemeterRecord, error) {
 	}
 	defer func() {
 		if closeErr := file.Close(); closeErr != nil {
-			// If we already have an error, we'll keep the original error
 			if err == nil {
 				err = fmt.Errorf("error closing file: %w", closeErr)
 			}
@@ -64,14 +63,24 @@ func (p *CSVParser) Parse() ([]EnemeterRecord, error) {
 	reader := csv.NewReader(file)
 	var records []EnemeterRecord
 
-	baseTime := time.Now()
-	if p.options.StartTime != nil {
-		baseTime = *p.options.StartTime
+	if p.options.StartTime == nil {
+		return nil, fmt.Errorf("start time must be provided")
 	}
+
+	// Use the provided start time since it's required
+	startTime := *p.options.StartTime
+
 	accumulatedTimeMs := int64(0)
 	recordCount := 0
 	sampleCounter := 0
 
+	const (
+		timeCol    = 0
+		voltageCol = 1
+		currentCol = 2
+		tempCol    = 3
+	)
+
 	for p.options.MaxRecords <= 0 || len(records) < p.options.MaxRecords {
 		row, err := reader.Read()
 		if err == io.EOF {
@@ -91,28 +100,28 @@ func (p *CSVParser) Parse() ([]EnemeterRecord, error) {
 			return nil, fmt.Errorf("invalid row format, expected 4 fields but got %d", len(row))
 		}
 
-		timeDelta, err := strconv.ParseInt(row[0], 10, 64)
+		timeDelta, err := strconv.ParseInt(row[timeCol], 10, 64)
 		if err != nil {
 			return nil, fmt.Errorf("failed to parse time delta: %w", err)
 		}
 
-		tempMiliCelsius, err := strconv.ParseInt(row[1], 10, 64)
+		voltageMicroV, err := strconv.ParseInt(row[voltageCol], 10, 64)
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse temperature: %w", err)
+			return nil, fmt.Errorf("failed to parse voltage: %w", err)
 		}
 
-		voltageMicroV, err := strconv.ParseInt(row[2], 10, 64)
+		currentNanoA, err := strconv.ParseInt(row[currentCol], 10, 64)
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse voltage: %w", err)
+			return nil, fmt.Errorf("failed to parse current: %w", err)
 		}
 
-		currentNanoA, err := strconv.ParseInt(row[3], 10, 64)
+		tempMiliCelsius, err := strconv.ParseInt(row[tempCol], 10, 64)
 		if err != nil {
-			return nil, fmt.Errorf("failed to parse current: %w", err)
+			return nil, fmt.Errorf("failed to parse temperature: %w", err)
 		}
 
 		accumulatedTimeMs += timeDelta
-		timestamp := baseTime.Add(time.Duration(accumulatedTimeMs) * time.Millisecond)
+		timestamp := startTime.Add(time.Duration(accumulatedTimeMs) * time.Millisecond)
 
 		if p.options.StartTime != nil && timestamp.Before(*p.options.StartTime) {
 			continue
@@ -223,14 +232,24 @@ func (p *CSVParser) StreamRecords(callback func(record EnemeterRecord) error) er
 
 	reader := csv.NewReader(file)
 
-	baseTime := time.Now()
-	if p.options.StartTime != nil {
-		baseTime = *p.options.StartTime
+	if p.options.StartTime == nil {
+		return fmt.Errorf("start time must be provided")
 	}
+
+	// Use the provided start time since it's required
+	startTime := *p.options.StartTime
+
 	accumulatedTimeMs := int64(0)
 	recordCount := 0
 	sampleCounter := 0
 
+	const (
+		timeCol    = 0
+		voltageCol = 1
+		currentCol = 2
+		tempCol    = 3
+	)
+
 	for {
 		row, err := reader.Read()
 		if err == io.EOF {
@@ -254,28 +273,28 @@ func (p *CSVParser) StreamRecords(callback func(record EnemeterRecord) error) er
 			return fmt.Errorf("invalid row format, expected 4 fields but got %d", len(row))
 		}
 
-		timeDelta, err := strconv.ParseInt(row[0], 10, 64)
+		timeDelta, err := strconv.ParseInt(row[timeCol], 10, 64)
 		if err != nil {
 			return fmt.Errorf("failed to parse time delta: %w", err)
 		}
 
-		tempMiliCelsius, err := strconv.ParseInt(row[1], 10, 64)
+		voltageMicroV, err := strconv.ParseInt(row[voltageCol], 10, 64)
 		if err != nil {
-			return fmt.Errorf("failed to parse temperature: %w", err)
+			return fmt.Errorf("failed to parse voltage: %w", err)
 		}
 
-		voltageMicroV, err := strconv.ParseInt(row[2], 10, 64)
+		currentNanoA, err := strconv.ParseInt(row[currentCol], 10, 64)
 		if err != nil {
-			return fmt.Errorf("failed to parse voltage: %w", err)
+			return fmt.Errorf("failed to parse current: %w", err)
 		}
 
-		currentNanoA, err := strconv.ParseInt(row[3], 10, 64)
+		tempMiliCelsius, err := strconv.ParseInt(row[tempCol], 10, 64)
 		if err != nil {
-			return fmt.Errorf("failed to parse current: %w", err)
+			return fmt.Errorf("failed to parse temperature: %w", err)
 		}
 
 		accumulatedTimeMs += timeDelta
-		timestamp := baseTime.Add(time.Duration(accumulatedTimeMs) * time.Millisecond)
+		timestamp := startTime.Add(time.Duration(accumulatedTimeMs) * time.Millisecond)
 
 		if p.options.StartTime != nil && timestamp.Before(*p.options.StartTime) {
 			continue