QRZ.COM
VE9EX Canada flag Canada

Login is required for additional detail.

QSL: LOTW, DIRECT, QRZ, EQSL, BUROS CANADA OMISS 3905CCN SKCC

Email: Login required to view

QRZ Lifetime Member #223 Lookups: 34931


Primary Image for VE9EX
' + ''; idocument.open(); // idocument.innerHtml = content; idocument.write(content); // idocument.write(''); // idocument.write(""); // idocument.write(""); // idocument.write(""); // idocument.write(""); idocument.close(); var lazyLoader = { "timer": null, "checkVisible": function (elm, evalType) { evalType = evalType || "visible"; var vpH = jQuery(window).height(); // Viewport Height var st = jQuery(window).scrollTop(); // Scroll Top var y = jQuery(elm).offset().top; var elementHeight = jQuery(elm).height(); var imageTop = jQuery(elm).offset().top; imageTop = imageTop + jQuery('#biodata').offset().top; var imageBottom = imageTop + jQuery(elm).height(); if ( imageBottom > st && imageTop < (st + vpH) ) { return true; } if ( imageBottom > st && imageBottom < (st + vpH) ) { return true; } return false; }, "loadImages": function () { var x = jQuery('#biodata')[0]; if ( x.contentDocument ) { x=x.contentDocument; } else if (x.contentWindow) { // for IE 5.5, 6 and 7: x = x.contentWindow.document; } var imgs = jQuery(x).find("img[data-loading=lazy], input[data-loading=lazy]").get(); var loadable = []; var i; var img; for (i = 0; i < imgs.length; i += 1) { img = imgs[i]; if (img.getAttribute("data-loading") === "lazy") { // if ( lazyLoader.checkVisible(img, "visible") && jQuery(img).is(":visible") ) { if ( lazyLoader.checkVisible(img, "visible") ) { loadable.push(img); } } } for (i = 0; i < loadable.length; i +=1) { img = loadable[i]; img.removeAttribute("data-loading"); img.setAttribute("src", img.getAttribute("data-src")); img.removeAttribute("data-src"); } }, 'triggerLoad' : function() { clearTimeout( lazyLoader.timer ); lazyLoader.timer = setTimeout( function() { lazyLoader.loadImages(); },10); } }; jQuery(document).on("ready", function() { lazyLoader.triggerLoad(); }); jQuery(window).on("resize scroll touchmove", function() { lazyLoader.triggerLoad(); }); document.getElementById('biodata').contentWindow.location.hash = ''; if (document.getElementById('biodata').contentWindow.addEventListener) { document.getElementById('biodata').contentWindow.addEventListener('hashchange', function() { fakeScroll() }); } jQuery('.action-render-').contents().find('body').css('padding', '0px'); jQuery('.action-render-').contents().find('body').css('margin', '0px'); jQuery('.action-render-').contents().find('body').append( jQuery('
') ); jQuery('.action-render-').contents().find('#biodata').html( Base64.decode("<p><strong>Introduction</strong></p>

<p>With the help of the Fredericton Amateur Radio Club, <a href="https://www.qrz.com/db/ve9nd">VE9ND</a>, I obtained my first certificate, dated July 5, 2010. I am a Bronze Maple Leaf Operator of the Radio Amateurs of Canada (RAC). I became the sponsor of the club call signs, <a href="https://www.qrz.com/db/ve9unb">VE9UNB</a>, VE9YFC, VE9CNB, and VE9VLT at the <a href="https://www.unb.ca">University of New Brunswick</a> (UNB) and I created and have been updating <a href="https://www.unb.ca/initiatives/ar/">Amateur Radio</a> web pages at UNB; I am the VE9UNB QSL Manager. I joined UNB in 1997, in the <a href="https://www.ece.unb.ca">Department of Electrical and Computer Engineering</a>, where I am a <a href="https://www.ece.unb.ca/petersen/">Professor</a> and a Senior Member of the <a href="https://www.ieee.org">IEEE</a>, which I joined in 1984. I am a Registered Professional Engineer of <a href="https://www.apegnb.com">APEGNB</a>.</p>

<p>I am a co-principal investigator in <a href="https://www.unb.ca/initiatives/cubesat/">CubeSat NB</a>, at the University of New Brunswick, where as part of the Canadian CubeSat Project, we designed, built, and tested a 2U CubeSat named VIOLET that was deployed into space from the International Space Station on April 18, 2024; VIOLET&#39;s permanent web address is <a href="https://www.unb.ca/cubesat-radio-info">https://www.unb.ca/cubesat-radio-info</a>. CubeSat VIOLET decayed from orbit on, or before, September 17, 2024. The earth station at the University of New Brunswick is described at <a href="https://www.unb.ca/initiatives/cubesat/earthstation.html">https://www.unb.ca/initiatives/cubesat/earthstation.html</a>.</p>

<p>Currently, I possess the basic with honours, advanced, and morse at 5 wpm. With the help of my father, Neal, <a href="https://www.qrz.com/db/ve3dhe">VE3DHE</a>, silent key, I got going quickly with HF and VHF. My usual QTH is my home, near Fredericton which is the capital of the province of New Brunswick, in eastern Canada. New Brunswick is beside the Bay of Fundy which has the world&#39;s highest tides, around 14 metres daily.</p>

<p>I used a piece of firewood to hold the front panel of my Yaesu FT-857D. One of my children punned, &quot;Hey, it&#39;s your radio log!&quot;; I had to label it.</p>

<p><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/x/ve9ex/VE9EX_Radio_Log.jpg?p=713a50354b708d07f7b3a5c9a69bcc91" style="height:310px; width:389px"></p>

<p><strong>QSL Information</strong></p>

<ul>
	<li>LOTW: I use <a href="https://www.arrl.org/logbook-of-the-world">LOTW</a> with all my call signs, dates, and Maidenhead grid squares.</li>
	<li>DIRECT: I respond to direct QSLs and SWLs and I do not require an SAE; I do not require an IRC; I do not require cash.  If one of my cards did not arrive, or has a problem, please email me. For the pleasure of SWLers, I make QSL cards with the extra field for their SWL identifier.</li>
	<li>BUREAU for Canada: I am a member of the bureau for Canada because I am a member of RAC.  The bureau prefers that you write my call sign in the upper right corner, front or back, of your card.</li>
	<li>BUREAU OMISS: I am #8572, as of December 13, 2012; see <a href="https://www.omiss.net/Facelift/QSLBuro.php">https://www.omiss.net/Facelift/QSLBuro.php</a>.</li>
	<li>BUREAU 3905CCN: See <a href="https://3905ccn.org">https://3905ccn.org</a> .</li>
	<li>BUREAU SKCC: I am #10792, as of June 7, 2013. I maintain credits in the SKCC buro, <a href="https://www.skccgroup.com/member_services/qsl_buro/">https://www.skccgroup.com/member_services/qsl_buro/</a>. I will try to use a buro if you indicate or imply one on your QRZ page, otherwise I will direct mail my card.</li>
	<li>QRZ: I use the QRZ logbook with all my call signs, with one exception. Each call sign has its own logbook, dates and Maidenhead grid square. The exception is that I do not use VE9EX/P due to a date conflict with VE9EX, which spans all dates.</li>
	<li>eQSL: I use <a href="https://www.eqsl.cc/">eQSL</a> (AG) for personally significant operations, such as VE9EX, CG9EX, CK9EX, CP1EX, VX9EX and ZL/VE9EX; more details are below in Appendix C.</li>
	<li>CLUBLOG:  I use CLUBLOG with VE9EX, CG9EX, CK9EX, CP1EX, VX9EX and ZL/VE9EX. I enabled OQRS for my primary call sign VE9EX.</li>
	<li>Email:  I will QSL by email.</li>
	<li>From time to time, I upload the relevant logbook to the relevant service: LOTW, QRZ, <a href="https://clublog.org/">CLUBLOG</a>, <a href="https://www.hrdlog.net">HRDLOG.net</a>, eQSL, <a href="https://qrzcq.com">QRZCQ</a> and <a href="https://qsomap.org/">QSOmap.org</a>.</li>
	<li>A QSO map for VE9EX is:</li>
	<li><iframe frameborder="0" height="600" scrolling="no" src="https://www.qsomap.com/QSOmapProduction/testimage.php?call=ve9ex&amp;
z=4&amp;m=l&amp;c=33.418280,-111.759844&amp;color=band" width="1024">A QSO Map for VE9EX is available.</iframe></li>
	<li>My list of portable operations is shown below in Appendix A.</li>
	<li>For VE3DHE QSLs, I am using QRZ and LOTW.</li>
</ul>

<div> </div>

<div>
<table border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<caption><strong>Active Call Signs</strong></caption>
	<tbody>
		<tr>
			<td><strong>Call Sign</strong></td>
			<td><strong>Dates</strong></td>
			<td><strong>Call Sign Type</strong></td>
			<td><strong>Notes</strong></td>
		</tr>
		<tr>
			<td>VE9EX</td>
			<td>2010 July 5 to present</td>
			<td>Personal</td>
			<td>This is my primary call sign.</td>
		</tr>
		<tr>
			<td><a href="https://www.qrz.com/db/VE3DHE">VE3DHE</a></td>
			<td>2024 Aug. 20 to present</td>
			<td>Personal</td>
			<td>I use this call sign when I&#39;m in Ontario, Canada.</td>
		</tr>
		<tr>
			<td><a href="http://www.qrz.com/db/VE9TEA">VE9TEA</a></td>
			<td>2020 Aug. 7 to present</td>
			<td>Personal</td>
			<td>See <a href="http://www.qrz.com/db/VE9TEA">VE9TEA</a>.</td>
		</tr>
		<tr>
			<td><a href="http://www.qrz.com/db/VE9HAN">VE9HAN</a></td>
			<td>2023 Sept. 26 to present</td>
			<td>Club</td>
			<td><a href="https://hanwell.nb.ca/">Hanwell Rural Community</a></td>
		</tr>
		<tr>
			<td><a href="http://www.qrz.com/db/VE9CNB">VE9CNB</a></td>
			<td>2019 Oct. 10 to present</td>
			<td>Club</td>
			<td><a href="https://www.unb.ca/initiatives/ar/ve9unb/club/">University of New Brunswick Amateur Radio Club</a></td>
		</tr>
		<tr>
			<td><a href="http://www.qrz.com/db/VE9VLT">VE9VLT</a></td>
			<td>2019 Oct. 10 to present</td>
			<td>Club</td>
			<td><a href="https://www.unb.ca/initiatives/ar/ve9unb/club/">University of New Brunswick Amateur Radio Club</a></td>
		</tr>
		<tr>
			<td><a href="http://www.qrz.com/db/VE9YFC">VE9YFC</a></td>
			<td>2016 Mar. 31 to present</td>
			<td>Club</td>
			<td><a href="https://www.unb.ca/initiatives/ar/ve9unb/club/">University of New Brunswick Amateur Radio Club</a></td>
		</tr>
		<tr>
			<td><a href="http://www.qrz.com/db/VE9UNB">VE9UNB</a></td>
			<td>2016 Mar. 31 to present</td>
			<td>Club</td>
			<td><a href="https://www.unb.ca/initiatives/ar/ve9unb/club/">University of New Brunswick Amateur Radio Club</a></td>
		</tr>
		<tr>
			<td><a href="https://www.qrz.com/db/W1IY">W1IY</a></td>
			<td>2022 Aug. 05 to present</td>
			<td>Personal</td>
			<td>See <a href="https://www.qrz.com/db/W1IY">W1IY</a>.</td>
		</tr>
	</tbody>
</table>
</div>

<p><iframe frameborder="0" height="480" name="last10" scrolling="auto" src="https://clublog.org/last10_iframe.php?call=ve9ex" width="440"></iframe></p>

<p><strong>Acknowledgments</strong></p>

<ul>
	<li>In 2017, Allen, <a href="https://www.qrz.com/db/VY1KX">VY1KX</a> tried three times over a month to help me get the Yukon on 20 m phone; Ken, <a href="https://www.qrz.com/db/VY2TT">VY2TT</a> (<a href="https://www.qrz.com/db/K6LA">K6LA</a>) helped me by temporarily turning his beam away from Europe during the 2017 IOTA contest to give me credit for Prince Edward Island on 20 m phone; I needed this help to get the CANADAWARD for CG9EX on 20 m phone.</li>
	<li>In 2015, Jerry, <a href="https://www.qrz.com/db/VE9CD">VE9CD</a>, showed <a href="https://www.remotehams.com">RemoteHams.com</a> to the <a href="https://www.qrz.com/db/ve9nd">VE9ND</a> club and helped me with the setup up at home and <a href="https://www.qrz.com/db/ve9unb">VE9UNB</a>.</li>
	<li>In the fall of 2012, Art, <a href="https://www.qrz.com/db/VE9BP">VE9BP</a>, helped me with CW messaging and provided my first CW QSO.</li>
	<li>In September 2012, I returned to Canada. One of my children started grade three and the class asked for postcards from many places in the world to assist their education. I asked
	<ul>
		<li>Lyn, <a href="https://www.qrz.com/db/VK4SWE">VK4SWE</a>,</li>
		<li>Victor, <a href="https://www.qrz.com/db/RV3YR">RV3YR</a>, and</li>
		<li>William, <a href="https://www.qrz.com/db/FO5JV">FO5JV</a> (Silent Key),</li>
	</ul>
	</li>
	<li>three of the amateur radio operators with whom I had QSOs when I was ZL/VE9EX, if they could provide a QSL card for the teacher. All three responded, wrote letters to the school teacher, and provided a generous amount of information about their locations in the world; thank you.</li>
</ul>

<p><strong>Bolivia</strong></p>

<p>I had the pleasure of using the call sign CP1EX from June 11 to July 19, 2019. I had a 20 m horizontal dipole on the roof of Ingeniería Electrónica, Facultad de Ingeniería, Universidad Mayor de San Andrés (UMSA), Plaza del Obelisco, Av. Camacho, La Paz, Bolivia. For all the help I received, I thank the faculty and students at UMSA, the engineer at ATT, and the executive at Radio Club La Paz, <a href="https://www.qrz.com/db/CP1AA">CP1AA</a>. I had possession of CP1EX from 2019 June 1 to 2024 May 31.</p>

<p><strong>New Zealand</strong></p>

<p>From July 4 to September 6, 2012, in New Zealand, I was able to use the call sign ZL/VE9EX. It was a wonderful experience.  Highlights were Westfest 2012 in Murchison as well as the Branch 56 and <a href="http://www.chchhamradio.org.nz">Branch 05</a> club meetings in Christchurch.  Regarding Westfest 2012, I very much enjoyed the conversation with Simon, <a href="https://zl4plm.blogspot.com/">ZL4PLM</a>, about a variety of amateur radio topics, including EME, during the drives between Christchurch and Murchison.</p>

<p><strong>Equipment</strong></p>

<ul>
	<li>I use an IC-7000, an IC-746, a Yaesu FT-857D, and a Yaesu VX-8GR.</li>
	<li>For digital modes, I use a SignaLink USB.</li>
	<li>For CW, I use a K1EL WKmini WinKeyer, Bencher paddles, a J-38 straight key, or a 9251 Canadian leg-mounted Westclox straight key.</li>
	<li>I have an MFJ-267 load with a wattmeter and an LDG AT-1000ProII antenna tuner.</li>
	<li>As of March 6, 2016, I occasionally use an Ameritron AL-80BX amplifier.</li>
	<li>I have an XPR 7550 VHF to use with DMR, as well as a Yaesu FT-70DR fusion radio.</li>
</ul>

<p><strong>Antennas</strong></p>

<p>My antennas are:</p>

<ul>
	<li>a G5RV 102 feet, beaming 90 and 270 degrees, top 12 m high,</li>
	<li>a 20 m elevated no-tuner-needed homemade vertical, four sloping radials, base 9 m high, top 14 m high,</li>
	<li>a 40 m elevated no-tuner-needed homemade vertical, four radials, base 2 m high, top 13 m high,</li>
	<li>a Diamond DIA-X50A, horizontally omnidirectional, 5 m high,</li>
	<li>an Arrow 146/437-10W, handheld satellite antenna, 3-element VHF Yagi and 7-element UHF Yagi, with a built-in duplexer, and</li>
	<li>an Arrow II 146/440-14 (All suffixes), handheld satellite antenna, 4-element VHF Yagi and 10-element UHF Yagi, with a built-in duplexer.</li>
</ul>

<p>The 20 m elevated vertical is shown, with four sloping radials, labelled R, and three guy ropes. Shown is only half of the mast of black 2X4s with six guy ropes, a homemade tower. The latitude and longitude point of the vertical is: 45.88164, -66.76836, shown in <a href="https://www.google.ca/maps/place/45°52&#39;53.9%22N+66°46&#39;06.1%22W/@45.8811672,-66.7692033,348m/data=!3m1!1e3!4m5!3m4!1s0x0:0x0!8m2!3d45.8816361!4d-66.7683639">Google Maps</a>, between the trees in the forest behind my house.</p>

<p><img  data-loading="lazy" data-src="https://cdn-bio.qrz.com/x/ve9ex/VE9EX_2015_20m.jpg?p=713a50354b708d07f7b3a5c9a69bcc91" style="height:800px; width:466px"></p>

<p><strong>APRS</strong></p>

<p>I occasionally use APRS with the Yaesu VX-8GR. I found APRS useful to keep my relatives informed of my travels, but a humorous disadvantage is that if I get lost, there is a record. I have used APRS in Canada, the USA, New Zealand, The Netherlands, Germany, France, and Italy, using VE9EX-7. In Ontario, Canada, I use VE3DHE-7.</p>

<p><strong>Satellites</strong></p>

<p><a href="https://www.unb.ca/initiatives/ieee/events/2019-11-26-satellite-contact.html">Dave, VE3KG (ex. VE9CB), demonstrated satellite QSOs</a>.  With this motivation, on Dec. 3, 2019, I got my first QSO and QSL in LoTW with <a href="https://www.qrz.com/db/N2FYA">John, N2FYA</a>. I used my Yaesu VX-8GR and the Arrow 146/437-10W, 3-element VHF Yagi and 7-element UHF Yagi.</p>

<p><strong>Awards</strong></p>

<p>I received the following awards:</p>

<ul>
	<li>IOTA 100 Islands of the World, All Modes, #4400, September 26, 2024, <a href="https://rsgb.org/">Radio Society of Great Britain (RSGB)</a>.</li>
	<li>DX Challenge, 2023, December 11, 2023, <a href="https://groups.io/g/ve9nd/">Fredericton Amateur Radio Club</a>.</li>
	<li>100-point award, 40 m, SSB, #3147, VE9EX, date August 28, 2023, <a href="https://www.3905ccn.org">3905 Century Club</a>.</li>
	<li>WPX, Mixed, #4660, VE9EX, date August 26, 2023, CQ Magazine.</li>
	<li><a href="https://wp.rac.ca/operating/rac-operating-awards/">CANADAWARD</a>, CG9EX, 20 m, SSB, Number 172-S, Date 2018-07-30, the certificate indicates that it is for QSOs since July 1, 1977, which is the start date of the award. The number 172-S indicates the number of certificates, 172, issued by the current awards manager, <a href="https://www.qrz.com/db/VE1JS">John Scott, VE1JS</a>, since July 1, 1997. Before July 1, 1997, a designation M was used for the initial of the previous awards manager. All 13 of my QSOs were in 2017 using the call sign CG9EX, commemorating Canada&#39;s Sesquicentennial. The award is from the <a href="https://www.rac.ca/">Radio Amateurs of Canada (RAC)</a>.</li>
	<li>DX Century Club, mixed #58,608 on December 3, 2013, from the <a href="https://www.arrl.org/">American Radio Relay League (ARRL)</a>, and</li>
	<li>Worked All States (WAS mixed #57,629 on October 16, 2013, from the <a href="https://www.arrl.org/">American Radio Relay League (ARRL)</a>.</li>
</ul>

<p><strong>Helping Others</strong></p>

<p>Please email me if you would like a sked. My recent satellite sked on AO-91 was successful. My previous 12 m sked request was unsuccessful because I do not have great antennas, but I am most certainly willing to try.</p>

<p><strong>Remote radio</strong></p>

<p>To use my radio by remote, please see the call sign <a href="https://www.qrz.com/db/VE9TEA">VE9TEA</a>.</p>

<p><strong>Contests</strong></p>

<ul>
	<li>In the 2024 Winter Contest from the Radio Amateurs of Canada, I was <a href="https://3830scores.com/showrumor.php?arg=RvYizV77J77n0U">VE9RAC</a>.</li>
	<li><a href="https://3830scores.com/findcall.php?call=VE9EX">3830 Scores</a> shows some of the recent contests in which I participated.</li>
	<li>In the 2020 IARU HF Contest, I co-organized the ten-operator team that used the call signs VA2RAC, VE9RAC, and VO1RAC as described in the The Canadian Amateur, September-October 2020, pages 30-31.</li>
	<li>In the 2018 IARU HF Contest, I operated for my first time as a headquarters station for the Radio Amateurs of Canada (RAC) and due to ITU Zone 9 being the chosen zone for RAC in 2018, I represented Canada on SSB for 10 m, 15 m, 20 m, 40 m and 80 m.  My call sign was <a href="https://3830scores.com/showrumor.php?arg=lTatzhigcsqyo">VE9RAC</a>. I achieved a personal highest number of QSOs in a contest from my own QTH.  Thank you for the opportunity.</li>
	<li>I participated with <a href="https://www.3830scores.com/showrumor.php?arg=R2aTzBgsggagp">Dave VE3KG (ex. VE9CB) in the 2017 IARU HF World Championship</a>; thanks Dave.</li>
	<li>From 2013 to 2018, I was part of the VE9UNB participation in the ARRL Sweepstakes SSB contest.</li>
</ul>

<div> </div>

<p style="text-align:justify"><strong>Appendix A - Portable Operations, Use of Prefixes, Special Event Call Signs</strong></p>

<p style="text-align:justify">Many Canadian amateur radio operators may briefly change their prefix, as documented at a <a href="https://apc-cap.ic.gc.ca/pls/apc_anon/query_spev$.startup">special event call</a> sign lookup page from Innovation, Science and Economic Development Canada. Operating in different provinces is indicated by adding a prefix. This list is chronological.</p>

<div>
<table border="1" cellpadding="1" cellspacing="1" style="width:500px" summary="VE9EX Portable and Special Event Call Signs">
	<caption> </caption>
	<tbody>
		<tr>
			<td><strong>Call Sign</strong></td>
			<td><strong>Dates</strong></td>
			<td><strong>Grid</strong></td>
			<td><strong>Notes</strong></td>
		</tr>
		<tr>
			<td>VE3DHE</td>
			<td>2025 September 8-12</td>
			<td>EN98ci</td>
			<td>Star Lake, Timmins, Ontario, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2025 August 26-31</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island <a href="http://www.iota-world.org/iota-directory/iota-island-group-listings/north-america.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2024 August 5-9</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island <a href="https://www.iota-world.org/iota-directory/iota-island-group-listings/north-america.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>SV5/VE9EX/P</td>
			<td>2023 September 18-21</td>
			<td>KM46ck</td>
			<td>Rhodes, Greece</td>
		</tr>
		<tr>
			<td>VE3/VE9EX</td>
			<td>2023 August 24-25</td>
			<td>FN25el</td>
			<td>Conroy Pit, Ottawa, Ontario, Canada</td>
		</tr>
		<tr>
			<td>VE2/VE9EX</td>
			<td>2023 August 23</td>
			<td>FN46ks</td>
			<td>Lévis, Q<span>uébec</span>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2023 August 14-16</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island, <a href="https://www.iota-world.org/iota-directory/iota-island-group-listings/north-america.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>CK9EX</td>
			<td>2023 June 5-July2</td>
			<td>FN65ov</td>
			<td><a href="https://www.royal.uk/coronation-his-majesty-king">Coronation of His Majesty King Charles III</a></td>
		</tr>
		<tr>
			<td>VE9EX/P</td>
			<td>2022 July 24</td>
			<td>FN65ov</td>
			<td>Hanwell Place, New Brunswick, Canada</td>
		</tr>
		<tr>
			<td>VE2/VE9EX</td>
			<td>2022 July 15-16</td>
			<td>FN46ks</td>
			<td>Lévis, Q<span>uébec</span>, Canada</td>
		</tr>
		<tr>
			<td>VX2/VX9EX</td>
			<td>2022 July 13-14</td>
			<td>FN46ks</td>
			<td><a href="https://www.rac.ca/special-call-signs-available-in-honour-of-the-queens-platinum-jubilee/">The Queen&#39;s Platinum Jubilee</a>, Lévis, Q<span>uébec</span>, Canada</td>
		</tr>
		<tr>
			<td>XK2/VX9EX</td>
			<td>2022 July 9</td>
			<td>FN86lb</td>
			<td><a href="https://www.rac.ca/special-call-signs-available-in-honour-of-the-queens-platinum-jubilee/">The Queen&#39;s Platinum Jubilee</a>, Point Prim ARLHS <a href="http://wlol.arlhs.com/lighthouse/CAN809.html">CAN-809</a>, Prince Edward Island <a href="https://www.iota-world.org/iota-directory/iota-island-group-listings/north-america.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>XK2/VX9EX</td>
			<td>2022 July 5-8</td>
			<td>FN86qf</td>
			<td><a href="https://www.rac.ca/special-call-signs-available-in-honour-of-the-queens-platinum-jubilee/">The Queen&#39;s Platinum Jubilee</a>, Cardigan, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VX9EX</td>
			<td>2022 July 3-4</td>
			<td>FN86ik</td>
			<td><a href="https://www.rac.ca/special-call-signs-available-in-honour-of-the-queens-platinum-jubilee/">The Queen&#39;s Platinum Jubilee</a>, Hunter River, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2022 July 2</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island <a href="https://www.iota-world.org/iota-directory/iota-island-group-listings/north-america.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VE3/VE9EX</td>
			<td>2022 May 18</td>
			<td>FN25ek</td>
			<td>Ottawa, Ontario, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2021 Sep 3</td>
			<td>FN86kk</td>
			<td>Covehead Harbour ARLHS <a href="http://wlol.arlhs.com/lighthouse/CAN150.html">CAN-150</a>, Prince Edward Island National Park POTA VE-0076, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2021 Sep 1-2</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2021 Aug 26-28</td>
			<td>FN86jj</td>
			<td>Brackley Beach, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2021 Aug 23-24</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2020 Sep 1-7</td>
			<td>FN86jj</td>
			<td>Brackley Beach, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>VY2/VE9EX</td>
			<td>2020 Aug 18-24</td>
			<td>FN86ik</td>
			<td>Hunter River, Prince Edward Island <a href="https://www.iota-world.org/islands-on-the-air/iota-groups-islands/group/544.html">NA-029</a>, Canada</td>
		</tr>
		<tr>
			<td>CP1EX</td>
			<td>2019 Jun 11-Jul 5</td>
			<td>FH53wm30sk</td>
			<td>Avenida Camacho, La Paz, Bolivia</td>
		</tr>
		<tr>
			<td>CG9EX</td>
			<td>2017 Jan 1-Dec 31</td>
			<td>FN65ov</td>
			<td>Canada&#39;s Sesquicentennial</td>
		</tr>
		<tr>
			<td>VE1/VE9EX</td>
			<td>2016 Aug 24-26</td>
			<td>FN64xm</td>
			<td>Digby Neck, Nova Scotia, Canada</td>
		</tr>
		<tr>
			<td>CK9EX</td>
			<td>2015 Jul 7-31</td>
			<td>FN65ov</td>
			<td>50th Anniversary of the Canadian Flag</td>
		</tr>
		<tr>
			<td>VE1/VE9EX</td>
			<td>2014 Jul 11</td>
			<td>FN64tg</td>
			<td>Brier Island <a href="https://www.iota-world.org/iota-directory/iota-island-group-listings/north-america.html">NA-127</a>, Nova Scotia, Canada</td>
		</tr>
		<tr>
			<td>VE3/VE9EX</td>
			<td>2013 Dec 26-31</td>
			<td>FN25ek</td>
			<td>Ottawa, Canada</td>
		</tr>
		<tr>
			<td>CG9EX</td>
			<td>2012 Dec 29-30</td>
			<td>FN65ov</td>
			<td>Diamond Jubilee Year of Her Majesty Queen Elizabeth II</td>
		</tr>
		<tr>
			<td>ZL/VE9EX</td>
			<td>2012 Jul 4-Sep 6</td>
			<td>RE66gl</td>
			<td>Riccarton Road, Christchurch, New Zealand</td>
		</tr>
		<tr>
			<td>VX9EX</td>
			<td>2011 Dec 6-30</td>
			<td>FN65ov</td>
			<td>75th Anniversary of the CBC/Radio Canada</td>
		</tr>
		<tr>
			<td>VE3/VE9EX</td>
			<td>2010 Aug 25-30</td>
			<td>FN25el</td>
			<td>Ottawa, Canada</td>
		</tr>
		<tr>
			<td>VE3/VE9EX</td>
			<td>2010 Aug 20-24</td>
			<td>FN25ek</td>
			<td>Ottawa, Canada</td>
		</tr>
	</tbody>
</table>
</div>

<p style="text-align:justify"> </p>

<p style="text-align:justify"><strong>Appendix B - Some Former Call Signs</strong></p>

<div>
<table border="1" cellpadding="1" cellspacing="1" style="width:500px">
	<caption> </caption>
	<tbody>
		<tr>
			<td><strong>Call Sign</strong></td>
			<td><strong>Dates</strong></td>
			<td><strong>Call Sign Type</strong></td>
			<td><strong>Notes</strong></td>
		</tr>
		<tr>
			<td>CP1EX</td>
			<td>2019 June 01 to 2024 May 31</td>
			<td>Personal</td>
			<td>La Paz, Bolivia</td>
		</tr>
	</tbody>
</table>
</div>

<div> </div>

<p style="text-align:justify"><strong>Appendix C - eQSL</strong></p>

<p style="text-align:justify">eQSL is used by many people and for a personally significant operation, I will add an eQSL account, as shown in the image in this appendix; the coronation of King Charles III was a personally significant operation. eQSL has a feature of sending a notification about a pending QSL. The pending QSL feature shows which QSOs I busted. Also, I found the pending QSL feature useful for the University of New Brunswick Amateur Radio Club where I was able to match the request for QSOs as old as sixty years by examining the 60 cm high stack of paper logs.</p>

<p style="text-align:justify"><img alt="VE9EX eQSL Accounts 2022 07 28"  data-loading="lazy" data-src="https://cdn-bio.qrz.com/x/ve9ex/VE9EX_eQSL_2023_06_11.jpg?p=713a50354b708d07f7b3a5c9a69bcc91" style="height:1153px; width:480px"></p>

<p><strong>Appendix D - Service to the Amateur Radio Community</strong></p>

<p><strong>Radio Amateurs of/du Canada (RAC)</strong></p>

<p>The RAC Satellite Committee was formed in July, 2025, and I am one of three members, as described in TCA, September-October, 2025, p. 21.</p>

<p><strong>AMSAT-CA</strong></p>

<p>As of October, 2024, I am a Techncal Director in <a href="https://amsat-ca.org/">AMSAT-CA</a>.</p>

<p><strong>VE9UNB</strong></p>

<p>I have been the sponsor of the UNB Amateur Radio Club since September 24, 2012.</p>

<p>Since November 5, 2014, I have been an <a href="https://ised-isde.canada.ca/site/amateur-radio-operator-certificate-services/en/accredited-examiners">accredited examiner</a> for amateur radio.</p>

<p>Since March 31, 2016, I have held the club call signs VE9UNB and VE9YFC and been the QSL Manager.</p>

<p>Since October 10, 2019, I have held the call signs VE9CNB and VE9VLT.</p>

<p><strong>VE9ND</strong></p>

<p>I was the President of the Fredericton Amateur Radio Club for the year 2023-2024. For only personal reasons, not reasons associated with the club, I had to resign from the duties with the club on the last day of my term as President and I could not fulfill my duties as Past President.</p>

<p>I was the treasurer of the Fredericton Amateur Radio for the following years:</p>

<ul>
	<li>2015-2016</li>
	<li>2016-2017</li>
	<li>2017-2018</li>
	<li>2019-2020</li>
	<li>2020-2021</li>
	<li>2021-2022</li>
	<li>2022-2023</li>
</ul>

<p>I was the QSL Manager of the Fredericton Amateur Radio for the following years:</p>

<ul>
	<li>2016-2017</li>
	<li>2017-2018</li>
	<li>2019-2020</li>
	<li>2020-2021</li>
	<li>2021-2022</li>
	<li>2022-2023</li>
</ul>

<p>In August 2020, I set up</p>

<ul>
	<li><a href="https://groups.io/g/ve9nd/">https://groups.io/g/ve9nd/ </a></li>
	<li><a href="https://ve9nd.slack.com/">https://ve9nd.slack.com</a>/ and co-administered them until June 30, 2024.</li>
</ul>

<p>In February 2021, I set up</p>

<ul>
	<li><a href="https://www.youtube.com/channel/UCn859Id4RcGQCX-mtNTFS8A">https://www.youtube.com/channel/UCn859Id4RcGQCX-mtNTFS8A</a> and I was the video editor until June 30, 2024.</li>
</ul>

<p><strong>Appendix E - Memberships and Financial Support</strong></p>

<p>I regularly pay to be a member of</p>

<ul>
	<li>Fredericton Amateur Radio Club, as a regular member,
	<ul>
		<li>groups.io and Slack: <a href="https://groups.io/g/ve9nd/">https://groups.io/g/ve9nd/</a>,</li>
	</ul>
	</li>
	<li><a href="https://ve9irg.net">International Repeater Group (IRG),</a></li>
	<li><a href="https://www.maritimecontestclub.ca/">Maritime Contest Club (MCC)</a>,</li>
	<li><a href="https://wp.rac.ca">Radio Amateurs of Canada (RAC)</a>, as Maple Leaf Operator, Bronze,</li>
	<li><a href="https://www.unb.ca/initiatives/ar/ve9unb/club/">University of New Brunswick Amateur Radio Club</a>, </li>
	<li><a href="https://www.ieee.org">Institute of Electrical and Electronic Engineers (IEEE)</a>, as a Senior Member and</li>
	<li><a href="https://www.apegnb.com/">Association of Professional Engineers of New Brunswick (APEGNB)</a>, as a Professional Engineer.</li>
</ul>

<p>I am a life member of the following:</p>

<ul>
	<li><a href="https://www.arrl.org">American Radio Relay League (ARRL)</a>, Life Membership International,</li>
	<li><a href="https://www.amsat.org/">AMSAT</a> and</li>
	<li><a href="https://www.qrz.com">QRZ</a>, Life Member #223.</li>
</ul>

<p>I have financially contributed to the following and certainly may contribute again:</p>

<ul>
	<li><a href="https://3905ccn.org/">3905 Century Club</a>,</li>
	<li><a href="https://arlhs.com/">Amateur Radio Lighthouse Society</a>,</li>
	<li><a href="https://www.caraham.org">Calgary Amateur Radio Association</a>,</li>
	<li><a href="http://www.chchhamradio.org.nz">Christchurch Amateur Radio Club Branch 05 of NZART, New Zealand</a>,</li>
	<li><a href="https://clublog.org/">CLUBLOG</a>,</li>
	<li><a href="https://www.eqsl.cc/">eQSL</a>,</li>
	<li><a href="https://ft8dmc.eu/">FT8 Digital Mode Club</a> #09295,</li>
	<li><a href="https://www.qrzcq.com">QRZCQ</a>,</li>
	<li><a href="https://www.qsomap.org">QSOmap</a>, and</li>
	<li><a href="http://www.ctsara.org/">Stamford Amateur Radio Association</a>.</li>
</ul>

<p>I have financially contributed by charitable donation to the following DXpedititons:</p>

<ul>
	<li><a href="https://www.qrz.com/db/HS19IARU">HS19IARU</a>, 2024,</li>
	<li><a href="https://www.qrz.com/db/1a0c">1A0C</a>, 2023,</li>
	<li><a href="https://t-rexsoftware.com/cy0s/">CY0S DXpedition</a>, Sable Island DXpedition 2023,</li>
	<li><a href="https://www.arrl.org/news/k1n-navassa-island-dxpedition-is-ham-radio-history">K1N Navassa Island DXpedition, 2015</a>, and</li>
	<li><a href="https://dxnews.com/yj0x-quake-contesters-vanuatu/">YJ0X DXpedition, 2014</a>, the Quake Contesters DXpedition to Vanuatu.</li>
</ul>

<p>Due to not being required to pay regularly, I am member of:</p>

<ul>
	<li><a href="https://omiss.net/Facelift/">OMISS</a>, #8572, and</li>
	<li><a href="https://www.skccgroup.com">SKCC</a>, #10792.</li>
</ul>

<p><strong>Appendix F - Certifications</strong></p>

<ul>
	<li>I obtained a Pleasure Craft Operating Card (PCOC).</li>
	<li>In 2019, I obtained a Restricted Operators Certificate - Maritime (ROC-M), with Digitial Selective Calling (DSC) Endorsement from the <a href="https://www.cps-ecp.ca/">Canadian Power and Sail Squadron</a>. I also obtained a <a href="https://sd.ic.gc.ca/pls/engdoc_anon/MI_PUBLIC$search.formquery?Z_CHK=0">Maritime Identity (MI)</a>, 831602789, for my Standard Horizon HX870 handheld radio.</li>
	<li>In 2025, I obtained a Restricted Operators Certificate - Aeronautical (ROC-A). </li>
</ul>

<p><strong>Appendix G - Additional information</strong></p>

<ul>
	<li>I set up
	<ul>
		<li><a href="https://network.satnogs.org/stations/2685/">SatNOGS 2685 VE9EX-1</a> with details at <a href="https://brentpetersen.ca/satnogs/2685/"><span>https://brentpetersen.ca/satnogs/2685/</span></a>, and</li>
		<li><a href="https://network.satnogs.org/stations/3044/">SatNOGS 3044 UNB Earth Station Fredericton Canada</a>.</li>
	</ul>
	</li>
	<li>At <a href="https://www.ece.unb.ca/petersen/personal/ar/">https://www.ece.unb.ca/petersen/personal/ar/</a>, I put more statistics and links, mostly for my own interest.</li>
</ul>
") ); jQuery('.action-render-').contents().find('#biodata a').each(function() { var attr = jQuery(this).attr('href'); if (typeof attr !== typeof undefined && attr !== false) { if (attr.indexOf("#") != 0 ) { // if ( ! this.hasAttribute('target') ) { if ( jQuery(this).attr('target') == undefined ) { jQuery(this).attr('target', '_top'); } jQuery(this).attr('href', jQuery(this).attr('href') ); } else { // jQuery(this).attr('target', '_parent'); } } }); function youtube_parser(url){ var regExp = /.*(?:youtu.be\/|v\/|u\/w\/|embed\/|watch\?v=)([^#\&\?]*).*/; var match = url.match(regExp); return (match&&match[1].length==11)? match[1] : false; } var iframes = jQuery('.action-render-').contents().find('iframe'); jQuery.each( iframes, function(k,v) { var yt_url = jQuery(v).attr('src'); if ( !yt_url ) { return true; } var yt_img_url = "//img.youtube.com/vi/" + youtube_parser(yt_url) + "/mqdefault.jpg"; var yt_width = jQuery(v).attr('width'); var yt_height = jQuery(v).attr('height'); if ( yt_url.indexOf('youtu') !== -1 ) { jQuery(v).after("" + "" + "" + "
" + "
" + ""); jQuery(v).remove(); } if ( jQuery(v).attr('data-refresh') >= 1 ) { if ( jQuery(v).attr('data-refresh') <= 30 ) { jQuery(v).attr('data-refresh', 30) } setInterval( function() { jQuery(v).attr('src', jQuery(v).attr('src')); } , jQuery(v).attr('data-refresh')*1000); } }); // Inject CSS jQuery('.action-render-').contents().find('head').append( jQuery('