Add support for esp

HomeApi/Controllers/HomeController.cs

@@ -6,13 +6,30 @@ using Microsoft.AspNetCore.Mvc;
 namespace HomeApi.Controllers;
 
 [ApiController]
-[Route("[controller]")]
+[Route("home")]
 public class HomeController(IMediator mediator) : ControllerBase
 {
-    [HttpGet(Name = "GetHome")]
+    [HttpGet(Name = "getHome")]
     public async Task<ActionResult<WeatherInformation>> Get()
     {
-        var result = await mediator.Send(new GetWeather.Command());
+        return Ok(await mediator.Send(new Weather.Command()));
-        return Ok(result);
+    }
+    
+    [HttpGet("default.jpg")]
+    public async Task<IActionResult> GetImage()
+    {
+        return File(await mediator.Send(new ImageGeneration.Command()), "image/jpeg");
+    }
+    
+    [HttpGet("configuration")]
+    public async Task<ActionResult<MicroProcessorConfiguration>> GetCombinedBuffers()
+    {
+        return Ok(await mediator.Send(new Configuration.Command()));
+    }
+    
+    [HttpGet("departure-board")]
+    public async Task<ActionResult<List<TimeTable>>> GetDepartureBoard()
+    {
+        return Ok(await mediator.Send(new DepartureBoard.Command()));
     }
 }

HomeApi/Extensions/ContractExtensions.cs

@@ -53,6 +53,8 @@ public static class ContractExtensions
                     So2 = weather.Current.Air_Quality.So2, // Sulfur Dioxide
                     Pm10 = weather.Current.Air_Quality.Pm10, // Particulate Matter 10 micrometers or less
                     Pm2_5 = weather.Current.Air_Quality.Pm2_5, // Particulate Matter 2.5 micrometers or less
+                    Us_Epa_Index = weather.Current.Air_Quality.Us_Epa_Index, // US EPA Air Quality Index
+                    Gb_Defra_Index = weather.Current.Air_Quality.Gb_Defra_Index, // UK DEFRA Air Quality Index
                 },
                 AuroraProbability = new Probability
                 {
@@ -96,6 +98,8 @@ public static class ContractExtensions
             MaxTempC = day.Day.Maxtemp_C,
             MinTempC = day.Day.Mintemp_C,
             DayIcon = day.Day.Condition.Icon,
+            IconCode = day.Day.Condition.Code,
+            ChanceOfRain = day.Day.Daily_Chance_Of_Rain,
             Astro = new Models.Astro
             {
                 Moon_Illumination = day.Astro.Moon_Illumination,
@@ -126,4 +130,23 @@ public static class ContractExtensions
         };
     }
     
+    public static List<TimeTable>? ToContract(this TrafikLabsApiResponse response)
+    {
+        if (response?.Departure is null)
+            return [];
+
+        return response.Departure.Select(dep => new TimeTable
+        {
+            LineNumber = dep.ProductAtStop?.DisplayNumber ?? dep.ProductAtStop?.Line,
+            LineName = dep.ProductAtStop?.Name,
+            TransportType = dep.ProductAtStop?.CatOutL,
+            Operator = dep.ProductAtStop?.Operator,
+            StopName = dep.Stop,
+            DepartureTime = $"{dep.Date} {dep.Time}",
+            Direction = dep.Direction,
+            JourneyDetailRef = dep.JourneyDetailRef?.Ref,
+            Notes = dep.Notes?.Note?.Select(n => n.Value).ToList() ?? [],
+            InternalTransportationName = dep.ProductAtStop?.InternalName
+        }).ToList();
+    }
 }

HomeApi/Handlers/Configuration.cs

@@ -0,0 +1,31 @@
+using HomeApi.Models;
+using HomeApi.Models.Configuration;
+using MediatR;
+using Microsoft.Extensions.Options;
+
+namespace HomeApi.Handlers;
+
+public static class Configuration
+{
+    public record Command : IRequest<MicroProcessorConfiguration>;
+
+    public class Handler(IOptions<ApiConfiguration> configuration)
+        : IRequestHandler<Command, MicroProcessorConfiguration>
+    {
+        private readonly ApiConfiguration _apiConfiguration = configuration.Value;
+
+        public Task<MicroProcessorConfiguration> Handle(Command request, CancellationToken cancellationToken)
+        {
+            return Task.FromResult(new MicroProcessorConfiguration 
+            {
+                InformationBoardImageUrl = _apiConfiguration.EspConfiguration.InformationBoardImageUrl,
+                UpdateIntervalMinutes = _apiConfiguration.EspConfiguration.UpdateIntervalMinutes,
+                BlackTextThreshold = _apiConfiguration.EspConfiguration.BlackTextThreshold,
+                ContrastStrength = _apiConfiguration.EspConfiguration.ContrastStrength,
+                DitheringStrength = _apiConfiguration.EspConfiguration.DitheringStrength,
+                EnableDithering = _apiConfiguration.EspConfiguration.EnableDithering,
+                EnhanceContrast = _apiConfiguration.EspConfiguration.EnhanceContrast
+            });
+        }
+    }
+}

HomeApi/Handlers/DepartureBoard.cs

@@ -0,0 +1,18 @@
+using HomeApi.Integration;
+using HomeApi.Models;
+using MediatR;
+
+namespace HomeApi.Handlers;
+
+public static class DepartureBoard
+{
+    public record Command : IRequest<List<TimeTable>>;
+
+    public class Handler(IDepartureBoardService departureBoardService) : IRequestHandler<Command, List<TimeTable>>
+    {
+        public async Task<List<TimeTable>> Handle(Command request, CancellationToken cancellationToken)
+        {
+            return await departureBoardService.GetDepartureBoard() ?? new List<TimeTable>();
+        }
+    }
+}

HomeApi/Handlers/ImageGeneration.cs

@@ -0,0 +1,79 @@
+using System.Dynamic;
+using System.Reflection;
+using HomeApi.Models.Configuration;
+using MediatR;
+using Microsoft.Extensions.Options;
+using PuppeteerSharp;
+using RazorLight;
+
+namespace HomeApi.Handlers;
+
+public static class ImageGeneration
+{
+    public record Command : IRequest<Stream>;
+
+    public class Handler(
+        IWebHostEnvironment env,
+        IMediator mediator,
+        IOptions<ApiConfiguration> apiConfiguration)
+        : IRequestHandler<Command, Stream>
+    {
+        private readonly ApiConfiguration _apiConfiguration = apiConfiguration.Value;
+
+        public async Task<Stream> Handle(Command request, CancellationToken cancellationToken)
+        {
+            var weather = await mediator.Send(new Weather.Command(), cancellationToken);
+            var departureBoard = await mediator.Send(new DepartureBoard.Command(), cancellationToken);
+            
+            var model = new Models.Image
+            {
+                Weather = weather,
+                TimeTable = departureBoard
+            };
+            
+            if(weather is null)
+                throw new Exception("Weather data not found");
+            
+            var engine = new RazorLightEngineBuilder()
+                .SetOperatingAssembly(Assembly.GetExecutingAssembly())
+                .UseEmbeddedResourcesProject(typeof(ImageGeneration))
+                .UseMemoryCachingProvider()
+                .Build();
+            
+            var path = Path.Combine(env.WebRootPath, "index.cshtml");
+
+            var template = await File.ReadAllTextAsync(path, cancellationToken);
+
+            dynamic viewBag = new ExpandoObject();
+            viewBag.IsHighContrast = _apiConfiguration.EspConfiguration.IsHighContrastMode;
+            
+            var result = await engine.CompileRenderStringAsync("templateKey", template, model, viewBag: viewBag);
+
+            if (!string.IsNullOrEmpty(result)) 
+                return await CreateImage(result);
+            
+            throw new Exception("Failed to generate HTML content for image.");
+        }
+
+        private static async Task<Stream> CreateImage(string htmlContent)
+        {
+            var browserFetcher = new BrowserFetcher();
+            await browserFetcher.DownloadAsync();
+            var browser = await Puppeteer.LaunchAsync(new LaunchOptions
+            {
+                Headless = true,
+                Args = ["--disable-gpu"]
+            });
+            
+            var page = await browser.NewPageAsync();
+            await page.SetViewportAsync(new ViewPortOptions
+            {
+                Width = 800,
+                Height = 480
+            });
+            
+            await page.SetContentAsync(htmlContent, new NavigationOptions { WaitUntil = [WaitUntilNavigation.Networkidle0] });
+            return await page.ScreenshotStreamAsync(new ScreenshotOptions { Type = ScreenshotType.Jpeg, Quality = 60 });
+        }
+    }
+}

HomeApi/Handlers/Weather.cs

@@ -7,7 +7,7 @@ using Microsoft.Extensions.Options;
 
 namespace HomeApi.Handlers;
 
-public static class GetWeather
+public static class Weather
 {
     public record Command : IRequest<WeatherInformation>;
 

HomeApi/HomeApi.csproj

@@ -5,12 +5,16 @@
         <Nullable>enable</Nullable>
         <ImplicitUsings>enable</ImplicitUsings>
         <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <PreserveCompilationContext>true</PreserveCompilationContext>
+        <EnableDefaultContentItems>false</EnableDefaultContentItems>
     </PropertyGroup>
 
     <ItemGroup>
         <PackageReference Include="MediatR" Version="13.0.0" />
         <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="11.1.0" />
         <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="9.0.7"/>
+        <PackageReference Include="PuppeteerSharp" Version="20.2.0" />
+        <PackageReference Include="RazorLight" Version="2.3.1" />
         <PackageReference Include="Refit.HttpClientFactory" Version="8.0.0" />
         <PackageReference Include="Scalar.AspNetCore" Version="2.5.6" />
     </ItemGroup>
@@ -21,4 +25,9 @@
       </Content>
     </ItemGroup>
 
+    <ItemGroup>
+        <Content Include="wwwroot\index.cshtml">
+            <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+        </Content>
+    </ItemGroup>
 </Project>

HomeApi/HomeApi.http

@@ -1,6 +0,0 @@
-@HomeApi_HostAddress = http://localhost:5128
-
-GET {{HomeApi_HostAddress}}/weatherforecast/
-Accept: application/json
-
-###

HomeApi/Integration/AuroraService.cs

@@ -12,6 +12,14 @@ public class AuroraService(IAuroraClient auroraApi) : IAuroraService
 {
     public Task<AuroraForecastApiResponse> GetAuroraForecastAsync(string lat, string lon)
     {
-        return auroraApi.GetForecastAsync(latitude: lat, longitude: lon);
+        try
+        {
+            return auroraApi.GetForecastAsync(latitude: lat, longitude: lon);
+        }
+        catch (Exception e)
+        {
+            Console.WriteLine(e);
+            throw;
+        }
     }
 }

HomeApi/Integration/Client/ResRobotClient.cs

@@ -0,0 +1,30 @@
+using HomeApi.Models.Response;
+using Refit;
+
+namespace HomeApi.Integration.Client;
+
+public interface IResRobotClient
+{
+    [Get("/v2.1/departureBoard")]
+    Task<TrafikLabsApiResponse> GetDepartureBoardAsync(
+        [AliasAs("accessId")] string accessId,
+        [AliasAs("id")] string stopId,
+        [AliasAs("direction")] string direction = null,
+        [AliasAs("date")] string date = null,              // Format: YYYY-MM-DD
+        [AliasAs("time")] string time = null,              // Format: HH:MM
+        [AliasAs("duration")] int? duration = null,
+        [AliasAs("maxJourneys")] int? maxJourneys = null,
+        [AliasAs("operators")] string operators = null,    // Example: "275,287"
+        [AliasAs("products")] int? products = null,
+        [AliasAs("passlist")] int? passlist = 0,
+        [AliasAs("lang")] string language = "sv",
+        [AliasAs("format")] string format = "json"
+    );
+    
+    [Get("/v2.1/location.name")]
+    Task<LocationNameResponse> GetLocationsByNameAsync(
+        [AliasAs("input")] string input,
+        [AliasAs("format")] string format = "json",
+        [AliasAs("accessId")] string accessId = "YOUR_API_KEY"
+    );
+}

HomeApi/Integration/Client/WeatherClient/WeatherClient.cs

@@ -1,16 +1,15 @@
 using HomeApi.Models.Response;
-
-namespace HomeApi.Integration.Client;
-
 using Refit;
 
+namespace HomeApi.Integration.Client.WeatherClient;
+
 public interface IWeatherClient
 {
     [Get("/forecast.json")]
     Task<WeatherData> GetForecastAsync(
         [AliasAs("key")] string apiKey,
         [AliasAs("q")] string coordinates,
-        [AliasAs("days")] int days = 7,
+        [AliasAs("days")] int days = 14,
         [AliasAs("lang")] string language = "sv",
         [AliasAs("aqi")] string aqi = "yes",
         [AliasAs("alerts")] string alerts = "yes");

HomeApi/Integration/DepartureBoardService.cs

@@ -0,0 +1,46 @@
+using HomeApi.Extensions;
+using HomeApi.Integration.Client;
+using HomeApi.Models;
+using HomeApi.Models.Configuration;
+using Microsoft.Extensions.Options;
+
+namespace HomeApi.Integration;
+
+public interface IDepartureBoardService
+{
+    Task<List<TimeTable>?> GetDepartureBoard();
+}
+
+public class DepartureBoardService(IResRobotClient departureBoardApi, IOptions<ApiConfiguration> options) : IDepartureBoardService
+{
+    private readonly ApiConfiguration _apiConfig = options.Value;
+
+    public async Task<List<TimeTable>?> GetDepartureBoard()
+    {
+        var locationResponse = await departureBoardApi.GetLocationsByNameAsync(
+            input: _apiConfig.DefaultStation,
+            format: "json",
+            accessId: _apiConfig.Keys.ResRobot
+        );
+
+        var id = locationResponse.StopLocationOrCoordLocation.FirstOrDefault()?.StopLocation?.ExtId;
+
+        if (id == null)
+            return null;
+        
+        var result = await departureBoardApi.GetDepartureBoardAsync(
+            accessId: _apiConfig.Keys.ResRobot,
+            stopId: id,
+            direction: null,
+            date: DateTime.Now.ToString("yyyy-MM-dd"),
+            time: DateTime.Now.ToString("HH:mm"),
+            duration: 60,
+            maxJourneys: 10,
+            passlist: 1,
+            language: "sv",
+            format: "json"
+        );
+    
+        return result.ToContract();
+    }
+}

HomeApi/Integration/WeatherService.cs

@@ -1,4 +1,4 @@
-using HomeApi.Integration.Client;
+using HomeApi.Integration.Client.WeatherClient;
 using HomeApi.Models.Configuration;
 using HomeApi.Models.Response;
 using Microsoft.Extensions.Options;

HomeApi/Models/Configuration/ApiConfiguration.cs

@@ -5,6 +5,8 @@ public class ApiConfiguration
     public Keys Keys { get; set; } = new();
     public BaseUrls BaseUrls { get; set; } = new();
     public string DefaultCity { get; set; } = "Vega stockholms lan";
+    public string DefaultStation { get; set; } = "Vega station";
+    public EspConfig EspConfiguration { get; set; } = new();
 }
 
 public class BaseUrls
@@ -12,6 +14,7 @@ public class BaseUrls
     public string Weather { get; set; } = string.Empty;
     public string Nominatim { get; set; } = string.Empty;
     public string Aurora { get; set; } = string.Empty;
+    public string ResRobot { get; set; } = string.Empty;
 }
 
 public class Keys
@@ -19,4 +22,17 @@ public class Keys
     public string Weather { get; set; } = string.Empty;
     public string Nominatim { get; set; } = string.Empty;
     public string Aurora { get; set; } = string.Empty;
+    public string ResRobot { get; set; } = string.Empty;
+}
+
+public class EspConfig
+{
+    public string InformationBoardImageUrl { get; set; } = string.Empty;
+    public int UpdateIntervalMinutes { get; set; } = 2;
+    public int BlackTextThreshold { get; set; } = 190; // (0-255)
+    public bool EnableDithering { get; set; } = true;
+    public int DitheringStrength { get; set; } = 8; // (8-32)
+    public bool EnhanceContrast { get; set; } = true;
+    public int ContrastStrength { get; set; } = 10; // (0-100)
+    public bool IsHighContrastMode { get; set; } = true;
 }

HomeApi/Models/ImageGeneration.cs

@@ -0,0 +1,7 @@
+namespace HomeApi.Models;
+
+public class Image
+{
+    public WeatherInformation Weather { get; set; }
+    public List<TimeTable> TimeTable { get; set; }
+}

HomeApi/Models/MicroProcessorConfiguration.cs

@@ -0,0 +1,12 @@
+namespace HomeApi.Models;
+
+public class MicroProcessorConfiguration
+{
+    public string InformationBoardImageUrl { get; set; } = string.Empty;
+    public int UpdateIntervalMinutes { get; set; } = 2;
+    public int BlackTextThreshold { get; set; } = 190; // (0-255)
+    public bool EnableDithering { get; set; } = true;
+    public int DitheringStrength { get; set; } = 8; // (8-32)
+    public bool EnhanceContrast { get; set; } = true;
+    public int ContrastStrength { get; set; } = 10; // (0-100)
+}

HomeApi/Models/Response/LocationNameResponse.cs

@@ -0,0 +1,88 @@
+using System.Text.Json.Serialization;
+
+public class LocationNameResponse
+{
+    [JsonPropertyName("stopLocationOrCoordLocation")]
+    public List<StopLocationOrCoordLocation> StopLocationOrCoordLocation { get; set; }
+
+    [JsonPropertyName("TechnicalMessages")]
+    public TechnicalMessages TechnicalMessages { get; set; }
+
+    [JsonPropertyName("serverVersion")]
+    public string ServerVersion { get; set; }
+
+    [JsonPropertyName("dialectVersion")]
+    public string DialectVersion { get; set; }
+
+    [JsonPropertyName("requestId")]
+    public string RequestId { get; set; }
+}
+
+public class StopLocationOrCoordLocation
+{
+    [JsonPropertyName("StopLocation")]
+    public StopLocation StopLocation { get; set; }
+}
+
+public class StopLocation
+{
+    [JsonPropertyName("productAtStop")]
+    public List<ProductAtStop> ProductAtStop { get; set; }
+
+    [JsonPropertyName("timezoneOffset")]
+    public int TimezoneOffset { get; set; }
+
+    [JsonPropertyName("id")]
+    public string Id { get; set; }
+
+    [JsonPropertyName("extId")]
+    public string ExtId { get; set; }
+
+    [JsonPropertyName("name")]
+    public string Name { get; set; }
+
+    [JsonPropertyName("lon")]
+    public double Lon { get; set; }
+
+    [JsonPropertyName("lat")]
+    public double Lat { get; set; }
+
+    [JsonPropertyName("weight")]
+    public int Weight { get; set; }
+
+    [JsonPropertyName("products")]
+    public int Products { get; set; }
+
+    [JsonPropertyName("minimumChangeDuration")]
+    public string MinimumChangeDuration { get; set; }
+}
+
+public class ProductAtStop
+{
+    [JsonPropertyName("icon")]
+    public Icon Icon { get; set; }
+
+    [JsonPropertyName("cls")]
+    public string Cls { get; set; }
+}
+
+public class Icon
+{
+    [JsonPropertyName("res")]
+    public string Res { get; set; }
+}
+
+public class TechnicalMessages
+{
+    [JsonPropertyName("TechnicalMessage")]
+    public List<TechnicalMessage> TechnicalMessage { get; set; }
+}
+
+public class TechnicalMessage
+{
+    [JsonPropertyName("value")]
+    public string Value { get; set; }
+
+    [JsonPropertyName("key")]
+    public string Key { get; set; }
+}

HomeApi/Models/Response/TrafikLabsApiResponse.cs

@@ -0,0 +1,84 @@
+namespace HomeApi.Models.Response;
+public class TrafikLabsApiResponse
+{
+    public List<Departure> Departure { get; set; }
+}
+
+public class Departure
+{
+    public JourneyDetailRef JourneyDetailRef { get; set; }
+    public string JourneyStatus { get; set; }
+    public ProductDetail ProductAtStop { get; set; }
+    public List<ProductDetail> Product { get; set; }
+    public Notes Notes { get; set; }
+    public string Name { get; set; }
+    public string Type { get; set; }
+    public string Stop { get; set; }
+    public string Stopid { get; set; }
+    public string StopExtId { get; set; }
+    public double Lon { get; set; }
+    public double Lat { get; set; }
+    public string Time { get; set; }
+    public string Date { get; set; }
+    public bool Reachable { get; set; }
+    public string Direction { get; set; }
+    public string DirectionFlag { get; set; }
+}
+
+public class JourneyDetailRef
+{
+    public string Ref { get; set; }
+}
+
+public class ProductDetail
+{
+    public Icon Icon { get; set; }
+    public OperatorInfo OperatorInfo { get; set; }
+    public string Name { get; set; }
+    public string InternalName { get; set; }
+    public string DisplayNumber { get; set; }
+    public string Num { get; set; }
+    public string Line { get; set; }
+    public string LineId { get; set; }
+    public string CatOut { get; set; }
+    public string CatIn { get; set; }
+    public string CatCode { get; set; }
+    public string Cls { get; set; }
+    public string CatOutS { get; set; }
+    public string CatOutL { get; set; }
+    public string OperatorCode { get; set; }
+    public string Operator { get; set; }
+    public string Admin { get; set; }
+    public string MatchId { get; set; }
+    public int? RouteIdxFrom { get; set; }
+    public int? RouteIdxTo { get; set; }
+}
+
+public class Icon
+{
+    public string Res { get; set; }
+}
+
+public class OperatorInfo
+{
+    public string Name { get; set; }
+    public string NameS { get; set; }
+    public string NameN { get; set; }
+    public string NameL { get; set; }
+    public string Id { get; set; }
+}
+
+public class Notes
+{
+    public List<Note> Note { get; set; }
+}
+
+public class Note
+{
+    public string Value { get; set; }
+    public string Key { get; set; }
+    public string Type { get; set; }
+    public int RouteIdxFrom { get; set; }
+    public int RouteIdxTo { get; set; }
+    public string TxtN { get; set; }
+}

HomeApi/Models/TimeTable.cs

@@ -0,0 +1,15 @@
+namespace HomeApi.Models;
+
+public class TimeTable
+{
+    public string LineNumber { get; set; }          // e.g. "43", "832"
+    public string LineName { get; set; }            // e.g. "Länstrafik - Tåg 43"
+    public string TransportType { get; set; }       // e.g. "Tåg", "Buss"
+    public string Operator { get; set; }            // e.g. "SL"
+    public string StopName { get; set; }            // e.g. "Vega station (Haninge kn)"
+    public string DepartureTime { get; set; }       // e.g. 2025-07-15 01:03
+    public string Direction { get; set; }           // e.g. "Farsta Strand station"
+    public string JourneyDetailRef { get; set; }    // e.g. "1|39437|0|1|15072025"
+    public List<string> Notes { get; set; }         // e.g. "Pendeltåg", "Endast 2 klass"
+    public string InternalTransportationName { get; set; } // e.g. "Pendeltåg 43"
+}

HomeApi/Models/WeatherInformation.cs

@@ -62,6 +62,9 @@ public class Forecast
     public WeatherSummary? Day { get; set; }
     public WeatherSummary? Night { get; set; }
     public Astro Astro { get; set; }
+    public int IconCode { get; set; }
+    
+    public int ChanceOfRain { get; set; }
 }
 public class Astro
 {

HomeApi/Program.cs

@@ -11,11 +11,10 @@ builder.Services.AddIntegration(builder.Configuration);
 
 var app = builder.Build();
 
-if (app.Environment.IsDevelopment())
+app.UseStaticFiles();
-{
+
-    app.MapOpenApi();
+app.MapOpenApi();
-    app.MapScalarApiReference();
+app.MapScalarApiReference();
-}
 
 app.UseHttpsRedirection();
 

HomeApi/Registration/RegisterIntegration.cs

@@ -1,6 +1,7 @@
 using HomeApi.Extensions;
 using HomeApi.Integration;
 using HomeApi.Integration.Client;
+using HomeApi.Integration.Client.WeatherClient;
 using HomeApi.Models.Configuration;
 using Microsoft.Extensions.Options;
 using Refit;
@@ -28,7 +29,11 @@ public static class RegisterIntegration
 
         services.AddRefitClient<IWeatherClient>()
             .ConfigureBaseAddress(apiConfiguration => apiConfiguration.BaseUrls.Weather);
+        
+        services.AddRefitClient<IResRobotClient>()
+            .ConfigureBaseAddress(apiConfiguration => apiConfiguration.BaseUrls.ResRobot);
 
+        services.AddScoped<IDepartureBoardService, DepartureBoardService>();
         services.AddScoped<IGeocodingService, GeocodingService>();
         services.AddScoped<IAuroraService, AuroraService>();
         services.AddScoped<IWeatherService, WeatherService>();

HomeApi/appsettings.Development.json

@@ -1,4 +1,11 @@
 {
+  "Kestrel": {
+    "Endpoints": {
+      "Http": {
+        "Url": "http://*:5000"
+      }
+    }
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Information",
@@ -6,15 +13,28 @@
     }
   },
   "ApiConfiguration": {
+    "EspConfiguration": {
+      "InformationBoardImageUrl": "http://192.168.101.178:5000/home/default.jpg",
+      "UpdateIntervalMinutes": 2,
+      "BlackTextThreshold": 190,
+      "EnableDithering": true,
+      "DitheringStrength": 8,
+      "EnhanceContrast": true,
+      "ContrastStrength": 10,
+      "IsHighContrastMode": true
+    },
     "Keys": {
-      "Weather": "KEY",
+      "Weather": "NOT COMMITED",
-      "SL": ""
+      "ResRobot": "NOT COMMITED"
     },
     "BaseUrls": {
       "Nominatim": "https://nominatim.openstreetmap.org",
       "Aurora": "http://api.auroras.live",
-      "Weather": "https://api.weatherapi.com/v1"
+      "Weather": "https://api.weatherapi.com/v1",
+      "ResRobot": "https://api.resrobot.se"
     },
-    "DefaultCity": "Vega stockholms lan"
+    "DefaultCity": "Vega stockholms lan",
-  }
+    "DefaultStation": "Vega Station"
+  },
+  "AllowedHosts": "*"
 }

HomeApi/appsettings.json

@@ -1,4 +1,11 @@
 {
+  "Kestrel": {
+    "Endpoints": {
+      "Http": {
+        "Url": "http://*:5000"
+      }
+    }
+  },
   "Logging": {
     "LogLevel": {
       "Default": "Information",
@@ -6,16 +13,28 @@
     }
   },
   "ApiConfiguration": {
+    "EspConfiguration": {
+      "InformationBoardImageUrl": "http://192.168.101.178:5000/home/default.jpg",
+      "UpdateIntervalMinutes": 2,
+      "BlackTextThreshold": 190,
+      "EnableDithering": true,
+      "DitheringStrength": 8,
+      "EnhanceContrast": true,
+      "ContrastStrength": 10,
+      "IsHighContrastMode": true
+    },
     "Keys": {
-      "Weather": "KEY",
+      "Weather": "NOT COMMITED",
-      "SL": ""
+      "ResRobot": "NOT COMMITED"
     },
     "BaseUrls": {
       "Nominatim": "https://nominatim.openstreetmap.org",
       "Aurora": "http://api.auroras.live",
-      "Weather": "https://api.weatherapi.com/v1"
+      "Weather": "https://api.weatherapi.com/v1",
+      "ResRobot": "https://api.resrobot.se"
     },
-    "DefaultCity": "Vega stockholms lan"
+    "DefaultCity": "Vega stockholms lan",
+    "DefaultStation": "Vega Station"
   },
   "AllowedHosts": "*"
 }

HomeApi/wwwroot/index.cshtml

@@ -0,0 +1,635 @@
+@using HomeApi.Models
+@using System;
+@using System.Linq;
+@using System.Collections.Generic;
+@model HomeApi.Models.Image
+
+@functions {
+    private string GetDayStatus(string input)
+    {
+        var date = DateTime.Parse(input);
+        var today = DateTime.Today;
+        var dayOfWeek = date.DayOfWeek.ToString();
+
+        if (date.Date == today)
+            return "Today";
+        if (date.Date == today.AddDays(1))
+            return "Tomorrow";
+        if (date >= today.AddDays(1) && date < today.AddDays(7))
+            return dayOfWeek;
+        return $"On {date:dddd, dd MMM yyyy}";
+    }
+    
+    private string GetTransPortIcon(string transportType)
+    {
+        var transportIcons = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            { "buss", "fa-bus" },
+            { "bus", "fa-bus" },
+            { "tunnelbana", "fa-train-subway" },
+            { "metro", "fa-train-subway" },
+            { "tåg", "fa-train" },
+            { "train", "fa-train" },
+            { "båt", "fa-ferry" },
+            { "ferry", "fa-ferry" }
+        };
+
+        foreach (var keyword in transportIcons.Keys)
+        {
+            if (transportType.Contains(keyword, StringComparison.OrdinalIgnoreCase))
+                return transportIcons[keyword];
+        }
+
+        return "fa-question-circle";
+    }
+    
+    private string GetAirQualityStatus(AirQuality data)
+    {
+        var highestAqi = Math.Max(data.Us_Epa_Index, data.Gb_Defra_Index);
+
+        return highestAqi switch
+        {
+            <= 50 => "Good",
+            <= 100 => "Moderate",
+            <= 150 => "Unhealthy for Sensitive Groups",
+            <= 200 => "Unhealthy",
+            <= 300 => "Very Unhealthy",
+            _ => "Hazardous"
+        };
+    }
+    
+    private static string GetWeatherIcon(int code, bool isNight = false)
+    {
+        var map = new Dictionary<int, string>
+        {
+            // Clear/Sunny
+            { 1000, isNight ? "fa-moon" : "fa-sun" },
+            // Partly cloudy
+            { 1003, isNight ? "fa-cloud-moon" : "fa-cloud-sun" },
+            // Cloudy/Overcast
+            { 1006, "fa-cloud" },
+            { 1009, "fa-cloud" },
+            // Mist/Fog
+            { 1030, "fa-smog" },
+            { 1135, "fa-smog" },
+            { 1147, "fa-smog" },
+            // Rain/drizzle
+            { 1063, "fa-cloud-rain" },
+            { 1150, "fa-cloud-drizzle" },
+            { 1153, "fa-cloud-drizzle" },
+            { 1180, "fa-cloud-rain" },
+            { 1183, "fa-cloud-rain" },
+            { 1186, "fa-cloud-showers-heavy" },
+            { 1189, "fa-cloud-showers-heavy" },
+            { 1240, "fa-cloud-showers-heavy" },
+            { 1243, "fa-cloud-showers-heavy" },
+            { 1246, "fa-cloud-showers-heavy" },
+            // Sleet, freezing drizzle/rain
+            { 1069, "fa-cloud-meatball" },
+            { 1072, "fa-cloud-meatball" },
+            { 1168, "fa-cloud-meatball" },
+            { 1171, "fa-cloud-meatball" },
+            { 1198, "fa-cloud-meatball" },
+            { 1201, "fa-cloud-meatball" },
+            { 1204, "fa-cloud-meatball" },
+            { 1207, "fa-cloud-meatball" },
+            { 1249, "fa-cloud-meatball" },
+            { 1252, "fa-cloud-meatball" },
+            // Snow
+            { 1066, "fa-snowflake" },
+            { 1114, "fa-snowflake" },
+            { 1117, "fa-snowflake" },
+            { 1210, "fa-snowflake" },
+            { 1213, "fa-snowflake" },
+            { 1216, "fa-snowflake" },
+            { 1219, "fa-snowflake" },
+            { 1222, "fa-snowflake" },
+            { 1225, "fa-snowflake" },
+            { 1255, "fa-snowflake" },
+            { 1258, "fa-snowflake" },
+            // Snow showers
+            { 1261, "fa-snowflake" },
+            { 1264, "fa-snowflake" },
+            { 1279, "fa-snowflake" },
+            { 1282, "fa-snowflake" },
+            // Thunderstorms
+            { 1087, "fa-bolt" },
+            { 1273, "fa-bolt" },
+            { 1276, "fa-bolt" },
+            // Ice pellets
+            { 1237, "fa-icicles" },
+        };
+
+        return map.TryGetValue(code, out var value) ? value : "fa-question-circle";
+    }
+    
+    private static string UseHighContrast(bool isHighContrast)
+    {
+        return isHighContrast ? "high-contrast" : string.Empty;
+    }
+}
+
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Weather Dashboard</title>
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css">
+    <style>
+        /* Reset and base styles */
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+        }
+
+        .high-contrast * {
+            color: hsl(0 0% 0%) !important;
+            border-color:  hsl(0 0% 0%) !important;
+        }
+        
+        /* Color Variables */
+        :root {
+            /* Base colors - Grayscale */
+            --background: 0 0% 100%;
+            --foreground: 0 0% 20%;
+            --card: 0 0% 100%;
+            --card-foreground: 0 0% 20%;
+            --primary: 0 0% 30%;
+            --primary-foreground: 0 0% 98%;
+            --muted: 0 0% 96%;
+            --muted-foreground: 0 0% 50%;
+            --border: 0 0% 85%;
+
+            /* Icon colors - All red */
+            --weather: 0 85% 60%;
+            --weather-sunny: 0 85% 60%;
+            --weather-cloudy: 0 85% 60%;
+            --weather-rainy: 0 85% 60%;
+            --weather-aurora: 0 85% 60%;
+
+            /* Air quality colors - Red */
+            --air-good: 0 85% 60%;
+            --air-moderate: 0 85% 60%;
+            --air-bad: 0 85% 60%;
+
+            /* Transport colors - Red */
+            --transport-color: 0 85% 60%;
+        }
+
+        /* Main weather card */
+        .weather-card {
+            width: 800px;
+            height: 480px;
+            background: linear-gradient(135deg,
+            hsl(var(--card)) 0%,
+            hsl(var(--card)) 50%,
+            hsl(var(--muted) / 0.3) 100%);
+            border: 2px solid hsl(var(--border) / 0.2);
+            border-radius: 12px;
+            box-shadow: 0 25px 50px -12px rgba(0, 0, 0, 0.25);
+            padding: 24px;
+            display: grid;
+            grid-template-columns: 1fr 1fr 1fr;
+            gap: 24px;
+            color: hsl(var(--foreground));
+        }
+
+        /* Left Column - Current Weather */
+        .current-weather {
+            display: flex;
+            flex-direction: column;
+            gap: 16px;
+        }
+
+        .location {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            color: hsl(var(--foreground));
+        }
+
+        .location-icon {
+            color: hsl(0 85% 60%) !important;
+            font-size: 14px;
+        }
+
+        .location-text {
+            font-weight: 500;
+            font-size: 14px;
+        }
+
+        .current-temp {
+            text-align: center;
+            margin: 8px 0;
+        }
+
+        .temp-main {
+            font-size: 36px;
+            font-weight: bold;
+            color: hsl(var(--foreground));
+        }
+
+        .feels-like {
+            font-size: 14px;
+            color: hsl(var(--muted-foreground));
+            margin-top: 4px;
+        }
+
+        .weather-details {
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+        }
+
+        .detail-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .detail-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 14px;
+        }
+
+        .detail-value {
+            font-size: 14px;
+            font-weight: 500;
+        }
+
+        .cloud-icon {
+            color: hsl(var(--weather-cloudy)) !important;
+        }
+
+        .wind-icon, .activity-icon {
+            color: hsl(0 85% 60%) !important;
+        }
+
+        .aurora-icon {
+            color: hsl(var(--weather-aurora)) !important;
+        }
+
+        .air-quality-badge {
+            background: hsl(var(--air-good));
+            color: hsl(0, 0%, 100%) !important;
+            padding: 8px 16px;
+            border-radius: 20px;
+            font-size: 12px;
+            font-weight: bolder;
+            text-align: center;
+        }
+
+        /* Middle Column - Forecast */
+        .forecast-section {
+            display: flex;
+            flex-direction: column;
+            gap: 16px;
+        }
+
+        .section-title {
+            font-weight: 600;
+            color: hsl(var(--foreground));
+            font-size: 16px;
+        }
+
+        .forecast-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 8px;
+        }
+
+        .forecast-card {
+            background: hsl(var(--muted) / 0.2);
+            border: 1px solid hsl(var(--border) / 0.5);
+            border-radius: 8px;
+            padding: 8px;
+            text-align: center;
+            display: flex;
+            flex-direction: column;
+            gap: 4px;
+        }
+
+        .forecast-date {
+            font-size: 12px;
+            font-weight: 500;
+            color: hsl(var(--foreground));
+        }
+
+        .forecast-icon {
+            display: flex;
+            justify-content: center;
+            margin: 4px 0;
+            color: hsl(var(--weather)) !important;
+        }
+
+        .forecast-condition {
+            font-size: 12px;
+            color: hsl(var(--muted-foreground));
+        }
+
+        .forecast-temp {
+            font-size: 14px;
+            font-weight: 600;
+            color: hsl(var(--foreground));
+        }
+
+        .forecast-rain {
+            font-size: 12px;
+            color: hsl(var(--muted-foreground));
+        }
+
+        .weather-sunny {
+            color: hsl(var(--weather-sunny));
+            font-size: 24px;
+        }
+
+        .weather-cloudy {
+            color: hsl(var(--weather-cloudy));
+            font-size: 24px;
+        }
+
+        .weather-rainy {
+            color: hsl(var(--weather-rainy));
+            font-size: 24px;
+        }
+
+        .sun-moon-info {
+            padding-top: 8px;
+            border-top: 1px solid hsl(var(--border));
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+        }
+
+        .sun-moon-item {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .sun-moon-label {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            font-size: 12px;
+        }
+
+        .sun-moon-value {
+            font-size: 12px;
+            font-weight: 500;
+        }
+
+        .moon-phase-label {
+            font-size: 12px;
+            color: hsl(var(--muted-foreground));
+        }
+
+        .sunrise-icon, .sunset-icon {
+            color: hsl(0 85% 60%) !important;
+        }
+
+        .moon-icon {
+            color: hsl(0 85% 60%) !important;
+        }
+
+        /* Right Column - Transport */
+        .transport-section {
+            display: flex;
+            flex-direction: column;
+            gap: 16px;
+        }
+
+        .transport-list {
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+            flex: 1;
+        }
+
+        .transport-item {
+            background: hsl(var(--card));
+            border: 1px solid hsl(var(--border));
+            border-radius: 8px;
+            padding: 12px;
+            display: flex;
+            align-items: flex-start;
+            gap: 12px;
+            transition: box-shadow 0.2s ease;
+        }
+
+        .transport-item:hover {
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+
+        .transport-item i {
+            font-size: 20px;
+            margin-top: 2px;
+        }
+
+        .transport-color {
+            color: hsl(var(--transport-color)) !important;
+        }
+
+        .transport-info {
+            flex: 1;
+            min-width: 0;
+        }
+
+        .transport-name {
+            font-weight: 500;
+            font-size: 14px;
+            color: hsl(var(--foreground));
+            white-space: nowrap;
+            overflow: hidden;
+            text-overflow: ellipsis;
+        }
+
+        .transport-destination {
+            font-size: 12px;
+            color: hsl(var(--muted-foreground));
+            white-space: nowrap;
+            overflow: hidden;
+            width: 152px;
+            text-overflow: ellipsis;
+        }
+
+        .transport-time {
+            font-size: 14px;
+            font-weight: 600;
+            color: hsl(var(--primary));
+            text-align: right;
+        }
+
+        .last-updated {
+            padding-top: 16px;
+            margin-top: 16px;
+            border-top: 1px solid hsl(var(--border));
+        }
+
+        .update-text {
+            font-size: 12px;
+            color: hsl(var(--muted-foreground));
+            text-align: center;
+        }
+    </style>
+</head>
+<body>
+<div class="weather-card @UseHighContrast(ViewBag.IsHighContrast)">
+    <!-- Left Column - Current Weather -->
+    <div class="current-weather">
+        <div class="location">
+            <i class="fas fa-map-marker-alt location-icon"></i>
+            <span class="location-text">@Model.Weather.CityName</span>
+        </div>
+
+        <div class="current-temp">
+            <div class="temp-main">@Model.Weather.Current.Temperature°C</div>
+            <div class="feels-like">Feels like @Model.Weather.Current.Feelslike°C</div>
+        </div>
+
+        <div class="weather-details">
+            <div class="detail-item">
+                <div class="detail-label">
+                    <i class="fas fa-cloud cloud-icon"></i>
+                    <span>Clouds</span>
+                </div>
+                <span class="detail-value">@Model.Weather.Current.Cloud%</span>
+            </div>
+
+            <div class="detail-item">
+                <div class="detail-label">
+                    <i class="fas fa-wind wind-icon"></i>
+                    <span>Wind</span>
+                </div>
+                <span class="detail-value">@Model.Weather.Current.WindPerMeterSecond.ToString("0.##"); m/s @Model.Weather.Current.WindDirection</span>
+            </div>
+
+            <div class="detail-item">
+                <div class="detail-label">
+                    <i class="fas fa-chart-line activity-icon"></i>
+                    <span>Gusts</span>
+                </div>
+                <span class="detail-value">@Model.Weather.Current.WindGustPerMeterSecond.ToString("0.##"); m/s</span>
+            </div>
+
+            <div class="detail-item">
+                <div class="detail-label">
+                    <i class="fas fa-star aurora-icon"></i>
+                    <span>Aurora</span>
+                </div>
+                <span class="detail-value">@Model.Weather.Current.AuroraProbability.Value%</span>
+            </div>
+        </div>
+
+        <div class="air-quality-badge">
+            Air Quality: @GetAirQualityStatus(Model.Weather.Current.AirQuality)
+        </div>
+    </div>
+
+    <!-- Middle Column - Forecast -->
+    <div class="forecast-section">
+        <h3 class="section-title">@Model.Weather.Forecast.Count-Day Forecast</h3>
+
+        <div class="forecast-grid">
+            @foreach (var day in Model.Weather.Forecast)
+            {
+                <div class="forecast-card">
+                    <div class="forecast-date">@GetDayStatus(day.Date)</div>
+                    <div class="forecast-icon">
+                        <i class="fas fa-cloud forecast-icon @GetWeatherIcon(day.IconCode)"></i>
+                    </div>
+                    <div class="forecast-condition">@(day.Day?.ConditionText ?? "Unspecified")</div>
+                    <div class="forecast-temp">@day.MinTempC°/@day.MaxTempC°</div>
+                    <div class="forecast-rain">Rain: @day.ChanceOfRain%</div>
+                </div>
+            }
+        </div>
+
+        <div class="sun-moon-info">
+            <div class="sun-moon-item">
+                <div class="sun-moon-label">
+                    <i class="fas fa-sun sunrise-icon"></i>
+                    <span>Sunrise</span>
+                </div>
+                <span class="sun-moon-value">@Model.Weather.Forecast[0].Astro.Sunrise</span>
+            </div>
+
+            <div class="sun-moon-item">
+                <div class="sun-moon-label">
+                    <i class="fas fa-sun sunset-icon"></i>
+                    <span>Sunset</span>
+                </div>
+                <span class="sun-moon-value">@Model.Weather.Forecast[0].Astro.Sunset</span>
+            </div>
+
+            <div class="sun-moon-item">
+                <div class="sun-moon-label">
+                    <i class="fas fa-moon moon-icon"></i>
+                    <span>Moonrise</span>
+                </div>
+                <span class="sun-moon-value">@Model.Weather.Forecast[0].Astro.Moonrise</span>
+            </div>
+
+            <div class="sun-moon-item">
+                <div class="sun-moon-label">
+                    <i class="fas fa-moon moon-icon"></i>
+                    <span>Moonset</span>
+                </div>
+                <span class="sun-moon-value">@Model.Weather.Forecast[0].Astro.Moonset</span>
+            </div>
+
+            <div class="sun-moon-item">
+                <span class="moon-phase-label">Moon phase</span>
+                <span class="sun-moon-value">@Model.Weather.Forecast[0].Astro.Moon_Illumination%</span>
+            </div>
+        </div>
+    </div>
+
+    <!-- Right Column - Public Transport -->
+    <div class="transport-section">
+        <h3 class="section-title">Upcoming Departures</h3>
+
+        <div class="transport-list">
+            @foreach (var transport in Model.TimeTable.Take(5))
+            {
+
+                var departureTime = DateTime.Parse(transport.DepartureTime);
+                var minutesUntilDeparture = (int)(departureTime - DateTime.Now).TotalMinutes;
+
+                <div class="transport-item">
+                    <i class="fas transport-color @GetTransPortIcon(transport.InternalTransportationName)"></i>
+                    <div class="transport-info">
+                        <div class="transport-name">@transport.LineNumber</div>
+                        <div class="transport-destination">to @transport.Direction</div>
+                    </div>
+                    <div class="transport-time">@DateTime.Parse(transport.DepartureTime).ToShortTimeString() (@minutesUntilDeparture min)</div>
+                </div>
+            }
+        </div>
+
+        <div class="last-updated">
+            <div class="update-text">Last updated: <span id="current-time"></span></div>
+        </div>
+    </div>
+</div>
+
+<script>
+    // Update current time
+    function updateTime() {
+        const now = new Date();
+        document.getElementById('current-time').textContent = now.toLocaleTimeString();
+    }
+
+    updateTime();
+    setInterval(updateTime, 1000);
+</script>
+</body>
+</html>