92 |
93 |
94 | ## What's Next
95 | Since building the Magic Calendar two years back, I've been looking at E-Ink tablets that emulate the experience of writing on paper, and allow the users to take notes on the go. Those familiar with this range of products would be aware of the Kindle Scribe, reMarkable tablet, Ratta Supernote, Kobo Elipsa and many others. I've had some limited success with getting a Kindle Paperwhite to display a calendar while sleeping but it felt too "hacky" and prone to breaking when Amazon updates the OS. I'm still looking for the right device (possibly a PineNote?), so if you're aware of any suitable candidates, do let me know!
96 |
--------------------------------------------------------------------------------
/config.json:
--------------------------------------------------------------------------------
1 | {
2 | "displayTZ": "Asia/Hong_Kong",
3 | "calendars": ["primary"],
4 | "numCalDaysToShow": 3,
5 | "owm_api_key": "ENTER YOUR OWN API KEY HERE",
6 | "lat": 22.3193,
7 | "lon": 114.1694,
8 | "imageWidth": 1200,
9 | "imageHeight": 825,
10 | "rotateAngle": 0,
11 | "openai_api_key": "ENTER YOUR OWN API KEY HERE",
12 | "path_to_server_image": "/var/www/html/maginkdash.png"
13 | }
--------------------------------------------------------------------------------
/gcal/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/speedyg0nz/MagInkDash/d907d35550805a93b9cc835532e9b3958fe8cd48/gcal/__init__.py
--------------------------------------------------------------------------------
/gcal/gcal.py:
--------------------------------------------------------------------------------
1 | """
2 | This is where we retrieve events from the Google Calendar. Before doing so, make sure you have both the
3 | credentials.json and token.pickle in the same folder as this file. If not, run quickstart.py first.
4 | """
5 |
6 | from gcal.gcalhelper import GcalHelper
7 | import logging
8 |
9 |
10 | class GcalModule:
11 | def __init__(self):
12 | self.logger = logging.getLogger('maginkdash')
13 | self.calHelper = GcalHelper()
14 |
15 | def get_day_in_cal(self, startDate, eventDate):
16 | delta = eventDate - startDate
17 | return delta.days
18 |
19 | def get_short_time(self, datetimeObj):
20 | datetime_str = ''
21 | if datetimeObj.minute > 0:
22 | datetime_str = '.{:02d}'.format(datetimeObj.minute)
23 |
24 | if datetimeObj.hour == 0:
25 | datetime_str = '12{}am'.format(datetime_str)
26 | elif datetimeObj.hour == 12:
27 | datetime_str = '12{}pm'.format(datetime_str)
28 | elif datetimeObj.hour > 12:
29 | datetime_str = '{}{}pm'.format(str(datetimeObj.hour % 12), datetime_str)
30 | else:
31 | datetime_str = '{}{}am'.format(str(datetimeObj.hour), datetime_str)
32 | return datetime_str
33 |
34 | def get_events(self, currDate, calendars, calStartDatetime, calEndDatetime, displayTZ, numDays):
35 | eventList = self.calHelper.retrieve_events(calendars, calStartDatetime, calEndDatetime, displayTZ)
36 |
37 | # check if event stretches across multiple days
38 | calList = []
39 | for i in range(numDays):
40 | calList.append([])
41 | for event in eventList:
42 | idx = self.get_day_in_cal(currDate, event['startDatetime'].date())
43 | if event['isMultiday']:
44 | end_idx = self.get_day_in_cal(currDate, event['endDatetime'].date())
45 | if idx < 0:
46 | idx = 0
47 | if end_idx >= len(calList):
48 | end_idx = len(calList) - 1
49 | for i in range(idx, end_idx + 1):
50 | calList[i].append(event)
51 | elif idx >= 0:
52 | calList[idx].append(event)
53 |
54 | return calList
--------------------------------------------------------------------------------
/gcal/gcalhelper.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # -*- coding: utf-8 -*-
3 | """
4 | This is where we retrieve events from the Google Calendar. Before doing so, make sure you have both the
5 | credentials.json and token.pickle in the same folder as this file. If not, run quickstart.py first.
6 | """
7 |
8 | from __future__ import print_function
9 | import datetime as dt
10 | import pickle
11 | import os.path
12 | import pathlib
13 | from googleapiclient.discovery import build
14 | from google_auth_oauthlib.flow import InstalledAppFlow
15 | from google.auth.transport.requests import Request
16 | import logging
17 |
18 |
19 | class GcalHelper:
20 |
21 | def __init__(self):
22 | self.logger = logging.getLogger('maginkdash')
23 | # Initialise the Google Calendar using the provided credentials and token
24 | SCOPES = ['https://www.googleapis.com/auth/calendar.readonly']
25 | self.currPath = str(pathlib.Path(__file__).parent.absolute())
26 |
27 | creds = None
28 | # The file token.pickle stores the user's access and refresh tokens, and is
29 | # created automatically when the authorization flow completes for the first
30 | # time.
31 | if os.path.exists(self.currPath + '/token.pickle'):
32 | with open(self.currPath + '/token.pickle', 'rb') as token:
33 | creds = pickle.load(token)
34 | # If there are no (valid) credentials available, let the user log in.
35 | if not creds or not creds.valid:
36 | if creds and creds.expired and creds.refresh_token:
37 | creds.refresh(Request())
38 | else:
39 | flow = InstalledAppFlow.from_client_secrets_file(
40 | self.currPath + '/credentials.json', SCOPES)
41 | creds = flow.run_local_server(port=0)
42 | # Save the credentials for the next run
43 | with open(self.currPath + '/token.pickle', 'wb') as token:
44 | pickle.dump(creds, token)
45 |
46 | self.service = build('calendar', 'v3', credentials=creds, cache_discovery=False)
47 |
48 | def list_calendars(self):
49 | # helps to retrieve ID for calendars within the account
50 | # calendar IDs added to config.json will then be queried for retrieval of events
51 | self.logger.info('Getting list of calendars')
52 | calendars_result = self.service.calendarList().list().execute()
53 | calendars = calendars_result.get('items', [])
54 | if not calendars:
55 | self.logger.info('No calendars found.')
56 | for calendar in calendars:
57 | summary = calendar['summary']
58 | cal_id = calendar['id']
59 | self.logger.info("%s\t%s" % (summary, cal_id))
60 |
61 | def to_datetime(self, isoDatetime, localTZ):
62 | # replace Z with +00:00 is a workaround until datetime library decides what to do with the Z notation
63 | to_datetime = dt.datetime.fromisoformat(isoDatetime.replace('Z', '+00:00'))
64 | return to_datetime.astimezone(localTZ)
65 |
66 | def adjust_end_time(self, endTime, localTZ):
67 | # check if end time is at 00:00 of next day, if so set to max time for day before
68 | if endTime.hour == 0 and endTime.minute == 0 and endTime.second == 0:
69 | newEndtime = localTZ.localize(
70 | dt.datetime.combine(endTime.date() - dt.timedelta(days=1), dt.datetime.max.time()))
71 | return newEndtime
72 | else:
73 | return endTime
74 |
75 | def is_multiday(self, start, end):
76 | # check if event stretches across multiple days
77 | return start.date() != end.date()
78 |
79 | def retrieve_events(self, calendars, startDatetime, endDatetime, localTZ):
80 | # Call the Google Calendar API and return a list of events that fall within the specified dates
81 | event_list = []
82 |
83 | min_time_str = startDatetime.isoformat()
84 | max_time_str = endDatetime.isoformat()
85 | if False:
86 | return event_list
87 |
88 | self.logger.info('Retrieving events between ' + min_time_str + ' and ' + max_time_str + '...')
89 | events_result = []
90 | for cal in calendars:
91 | events_result.append(
92 | self.service.events().list(calendarId=cal, timeMin=min_time_str,
93 | timeMax=max_time_str, singleEvents=True,
94 | orderBy='startTime').execute()
95 | )
96 |
97 | events = []
98 | for eve in events_result:
99 | events += eve.get('items', [])
100 | # events = events_result.get('items', [])
101 |
102 | if not events:
103 | self.logger.info('No upcoming events found.')
104 | for event in events:
105 | # extracting and converting events data into a new list
106 | new_event = {'summary': event['summary']}
107 |
108 | if event['start'].get('dateTime') is None:
109 | new_event['allday'] = True
110 | new_event['startDatetime'] = self.to_datetime(event['start'].get('date'), localTZ)
111 | else:
112 | new_event['allday'] = False
113 | new_event['startDatetime'] = self.to_datetime(event['start'].get('dateTime'), localTZ)
114 |
115 | if event['end'].get('dateTime') is None:
116 | new_event['endDatetime'] = self.adjust_end_time(self.to_datetime(event['end'].get('date'), localTZ),
117 | localTZ)
118 | else:
119 | new_event['endDatetime'] = self.adjust_end_time(self.to_datetime(event['end'].get('dateTime'), localTZ),
120 | localTZ)
121 |
122 | new_event['updatedDatetime'] = self.to_datetime(event['updated'], localTZ)
123 | new_event['isMultiday'] = self.is_multiday(new_event['startDatetime'], new_event['endDatetime'])
124 | event_list.append(new_event)
125 |
126 | # We need to sort eventList because the event will be sorted in "calendar order" instead of hours order
127 | # TODO: improve because of double cycle for now is not much cost
128 | event_list = sorted(event_list, key=lambda k: k['startDatetime'])
129 | return event_list
130 |
--------------------------------------------------------------------------------
/gcal/quickstart.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 | # -*- coding: utf-8 -*-
3 | """
4 | Run this script first to obtain the token. Credentials.json must be in the same folder first.
5 | To obtain Credentials.json, follow the instructions listed in the following link.
6 | https://developers.google.com/calendar/api/quickstart/python
7 | """
8 |
9 | from __future__ import print_function
10 | import datetime
11 | import pickle
12 | import os.path
13 | from googleapiclient.discovery import build
14 | from google_auth_oauthlib.flow import InstalledAppFlow
15 | from google.auth.transport.requests import Request
16 |
17 | # If modifying these scopes, delete the file token.pickle.
18 | SCOPES = ['https://www.googleapis.com/auth/calendar.readonly']
19 |
20 |
21 | def main():
22 | """Shows basic usage of the Google Calendar API.
23 | Prints the start and name of the next 10 events on the user's calendar.
24 | """
25 | creds = None
26 | # The file token.pickle stores the user's access and refresh tokens, and is
27 | # created automatically when the authorization flow completes for the first
28 | # time.
29 | if os.path.exists('token.pickle'):
30 | with open('token.pickle', 'rb') as token:
31 | creds = pickle.load(token)
32 | # If there are no (valid) credentials available, let the user log in.
33 | if not creds or not creds.valid:
34 | if creds and creds.expired and creds.refresh_token:
35 | creds.refresh(Request())
36 | else:
37 | flow = InstalledAppFlow.from_client_secrets_file(
38 | 'credentials.json', SCOPES)
39 | creds = flow.run_local_server(port=0)
40 | # Save the credentials for the next run
41 | with open('token.pickle', 'wb') as token:
42 | pickle.dump(creds, token)
43 |
44 | service = build('calendar', 'v3', credentials=creds)
45 |
46 | # Call the Calendar API
47 | now = datetime.datetime.utcnow().isoformat() + 'Z' # 'Z' indicates UTC time
48 | print('Getting the upcoming 10 events')
49 | events_result = service.events().list(calendarId='primary', timeMin=now,
50 | maxResults=10, singleEvents=True,
51 | orderBy='startTime').execute()
52 | events = events_result.get('items', [])
53 |
54 | if not events:
55 | print('No upcoming events found.')
56 | for event in events:
57 | start = event['start'].get('dateTime', event['start'].get('date'))
58 | end = event['end'].get('dateTime', event['start'].get('date'))
59 | updated = event['updated']
60 | print(start + " | " + end + " | " + updated + " | " + event['summary'])
61 |
62 |
63 | if __name__ == '__main__':
64 | main()
--------------------------------------------------------------------------------
/inkplate/inkplate.ino:
--------------------------------------------------------------------------------
1 | /*
2 | Adapted from the Inkplate10_Image_Frame_From_Web example for Soldered Inkplate 10
3 | https://github.com/SolderedElectronics/Inkplate-Arduino-library/blob/master/examples/Inkplate10/Projects/Inkplate10_Image_Frame_From_Web/Inkplate10_Image_Frame_From_Web.ino
4 |
5 | What this code does:
6 | 1. Connect to a WiFi access point
7 | 2. Retrieve an image from a web address
8 | 3. Display the image on the Inkplate 10 device
9 | 4. (Optional) Check the battery level on the Inkplate device
10 | 5. (Optional) Send a message via Telegram if battery level is low
11 | 6. Set a sleep timer for 60 minutes, and allow the Inkplate to go into deep sleep to conserve battery
12 | */
13 |
14 | // Next 3 lines are a precaution, you can ignore those, and the example would also work without them
15 | #if !defined(ARDUINO_INKPLATE10) && !defined(ARDUINO_INKPLATE10V2)
16 | #error "Wrong board selection for this example, please select e-radionica Inkplate10 or Soldered Inkplate10 in the boards menu."
17 | #endif
18 |
19 | #include "Inkplate.h"
20 | #include {day}
22 |{weekday}
{month}